Static code analysis can find hundreds of opportunities in VBA code.
Rubberduck builds its own internal representation of the code, and then proceeds to analyze it. Each individual inspection can easily be disabled, or configured to issue inspection results at different severity levels ranging from Hint to Error.
Use the Inspection Results toolwindow to review Rubberduck’s findings, search, filter, regroup results by inspection, location, type, or severity. Each inspection result comes with a detailed description of what’s being flagged and why, so you can make an enlightened decision.
Unless configured otherwise, Rubberduck automatically runs inspections after the a parser/resolver cycle completes (regardless of whether the inspection results toolwindow is displayed or not).
For the best experience, it would be recommended to first try Rubberduck with an empty project, add a new module, and write, say, a loop that counts 1 to 10 and outputs to the debug pane - then to parse that and review the inspection results; carefully review the inspection settings, and consider disabling the inspections that irreconcilably clash with your preferences: use meaningful names alone can easily produce hundreds upon hundreds of results if you’re not that much into using vowels, or if you, say, prefix all your variable names; these inspections can be re-enabled anytime you’re ready!
This tab lists all items found in the .xml documentation assets from the latest pre-release build. To modify this content, a pull request must be merged into the [next] branch.
Flags Rubberduck annotations used in a component type that is incompatible with that annotation.
Default severity: Warning
Some annotations can only be used in a specific type of module; others cannot be used in certain types of modules.
Warns about late-bound WorksheetFunction calls made against the extended interface of the Application object.
Default severity: Suggestion
An early-bound, equivalent function exists in the object returned by the Application.WorksheetFunction property; late-bound member calls will fail at run-time with error 438 if there is a typo (a typo fails to compile for an early-bound member call); given invalid inputs, these late-bound member calls return a Variant/Error value that cannot be coerced into another type. The equivalent early-bound member calls raise a more VB-idiomatic, trappable runtime error given the same invalid inputs: trying to compare or assign a Variant/Error to another data type will throw error 13 "type mismatch" at run-time. A Variant/Error value cannot be coerced into any other data type, be it for assignment or comparison.
This inspection will only run if the Excel library is referenced.
Locates arguments passed to functions or procedures for object parameters which the do not have a compatible declared type.
Default severity: Warning
The VBA compiler does not check whether different object types are compatible. Instead there is a runtime error whenever the types are incompatible.
Warns about parameters passed by value being assigned a new value in the body of a procedure.
Default severity: Warning
Debugging is easier if the procedure's initial state is preserved and accessible anywhere within its scope. Mutating the inputs destroys the initial state, and makes the intent ambiguous: if the calling code is meant to be able to access the modified values, then the parameter should be passed ByRef; the ByVal modifier might be a bug.
Warns about a local variable that is assigned and never read. Or, warns about a local variable that is assigned and then re-assigned before using the previous value.
Default severity: Suggestion
An assignment that is never used is a meaningless statement that was likely used by an execution path in a prior version of the module.
Indicates that the value of a hidden VB attribute is out of sync with the corresponding Rubberduck annotation comment.
Default severity: Warning
Keeping Rubberduck annotation comments in sync with the hidden VB attribute values, surfaces these hidden attributes in the VBE code panes; Rubberduck can rewrite the attributes to match the corresponding annotation comment.
Identifies conditional assignments to mutually exclusive Boolean literal values in conditional branches.
Default severity: Warning
The assignment could be made directly to the result of the conditional Boolean expression instead.
Locates 'Const' declarations that are never referenced.
Default severity: Warning
Declarations that are never used should be removed.
Locates indexed default member calls for which the corresponding object does not have a suitable suitable default member.
Default severity: Warning
The VBA compiler does not check whether the necessary default member is present. Instead there is a runtime error whenever the runtime type fails to have the default member.
This inspection means to indicate when the project has not been renamed.
Default severity: Suggestion
VBA projects should be meaningfully named, to avoid namespace clashes when referencing other VBA projects.
Warns about Def[Type] statements.
Default severity: Suggestion
These declarative statements make the first letter of identifiers determine the data type.
Warns about duplicated annotations.
Default severity: Error
Rubberduck annotations should not be specified more than once for a given module, member, variable, or expression.
Identifies empty 'Case' blocks that can be safely removed.
Default severity: Warning
Case blocks in VBA do not "fall through"; an empty 'Case' block might be hiding a bug.
Identifies empty 'Do...Loop While' blocks that can be safely removed.
Default severity: Suggestion
Dead code should be removed. A loop without a body is usually redundant.
Identifies empty 'Else' blocks that can be safely removed.
Default severity: Warning
Empty code blocks are redundant, dead code that should be removed. They can also be misleading about their intent: an empty block may be signalling an unfinished thought or an oversight.
Identifies empty 'For Each...Next' blocks that can be safely removed.
Default severity: Warning
Dead code should be removed. A loop without a body is usually redundant.
Identifies empty 'For...Next' blocks that can be safely removed.
Default severity: Warning
Dead code should be removed. A loop without a body is usually redundant.
Identifies empty 'If' blocks.
Default severity: Warning
Conditional expression is inverted; there would not be a need for an 'Else' block otherwise.
Identifies empty module member blocks.
Default severity: Warning
Methods containing no executable statements are misleading as they appear to be doing something which they actually don't. This might be the result of delaying the actual implementation for a later stage of development, and then forgetting all about that.
Flags empty code modules.
Default severity: Hint
An empty module does not need to exist and can be safely removed.
Flags uses of an empty string literal ("").
Default severity: Warning
Standard library constant 'vbNullString' is more explicit about its intent, and should be preferred to a string literal. While the memory gain is meaningless, an empty string literal still takes up 2 bytes of memory, but 'vbNullString' is a null string pointer, and doesn't.
Identifies empty 'While...Wend' blocks that can be safely removed.
Default severity: Warning
Dead code should be removed. A loop without a body is usually redundant.
Flags publicly exposed instance fields.
Default severity: Suggestion
Instance fields are the implementation details of a object's internal state; exposing them directly breaks encapsulation. Often, an object only needs to expose a 'Get' procedure to expose an internal instance field.
Locates instances of member calls made against the result of a Range.Find/FindNext/FindPrevious method, without prior validation.
Default severity: Warning
Range.Find methods return a Range object reference that refers to the cell containing the search string; this object reference will be Nothing if the search didn't turn up any results, and a member call against Nothing will raise run-time error 91.
This inspection will only run if the Excel library is referenced.
Locates public User-Defined Function procedures accidentally named after a cell reference.
Default severity: Warning
Another good reason to avoid numeric suffixes: if the function is meant to be used as a UDF in a cell formula, the worksheet cell by the same name takes precedence and gets the reference, and the function is never invoked.
This inspection will only run if the Excel library is referenced.
Warns when a user function's return value is discarded at all its call sites.
Default severity: Warning
A 'Function' procedure normally means its return value to be captured and consumed by the calling code. It's possible that not all call sites need the return value, but if the value is systematically discarded then this means the function is side-effecting, and thus should probably be a 'Sub' procedure instead.
Warns when a user function's return value is not used at a call site.
Default severity: Warning
A 'Function' procedure normally means its return value to be captured and consumed by the calling code.
Warns about host-evaluated square-bracketed expressions.
Default severity: Warning
Host-evaluated expressions should be implementable using the host application's object model. If the expression yields an object, member calls against that object are late-bound.
Flags identifiers that use [Systems] Hungarian Notation prefixes.
Default severity: Suggestion
Systems Hungarian (encoding data types in variable names) stemmed from a misunderstanding of what its inventor meant when they described that prefixes identified the "kind" of variable in a naming scheme dubbed Apps Hungarian. Modern naming conventions in all programming languages heavily discourage the use of Systems Hungarian prefixes.
Identifies Functions or Properties referenced by the TruePart(second argument) or FalsePart(third argument) of the IIf built-in function.
Default severity: Warning
All arguments of any function/procedure call are always evaluated before the function is invoked so that their respective values can be passed as parameters. Even so, the IIf Function's behavior is sometimes mis-interpreted to expect that ONLY the 'TruePart' or ONLY the 'FalsePart' expression will be evaluated based on the result of the first argument expression. Consequently, the IIf Function can be a source of unanticipated side-effects and errors if the user does not account for the fact that both the TruePart and FalsePart arguments are always evaluated.
Flags invalid Rubberduck annotation comments.
Default severity: Error
Rubberduck is correctly parsing an annotation, but that annotation is illegal in that context.
Identifies class modules that define an interface with one or more members containing a concrete implementation.
Default severity: Suggestion
Interfaces provide an abstract, unified programmatic access to different objects; concrete implementations of their members should be in a separate module that 'Implements' the interface.
Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls implicitly referring to ActiveSheet.
Default severity: Warning
Implicit references to the active worksheet (ActiveSheet) rarely mean to be working with *whatever worksheet is currently active*. By explicitly qualifying these member calls with a specific Worksheet object, the assumptions are removed, the code is more robust, and will be less likely to throw run-time error 1004 or produce unexpected results when the active sheet isn't the expected one.
This inspection will only run if the Excel library is referenced.
Locates unqualified Workbook.Worksheets/Sheets/Names member calls that implicitly refer to ActiveWorkbook.
Default severity: Warning
Implicit references to the active workbook rarely mean to be working with *whatever workbook is currently active*. By explicitly qualifying these member calls with a specific Workbook object, the assumptions are removed, the code is more robust, and will be less likely to throw run-time error 1004 or produce unexpected results when the active workbook isn't the expected one.
This inspection will only run if the Excel library is referenced.
Highlights implicit ByRef modifiers in user code.
Default severity: Hint
VBA parameters are implicitly ByRef, which differs from modern VB (VB.NET) and most other programming languages which are implicitly ByVal. So, explicitly identifing VBA parameter mechanisms (the ByRef and ByVal modifiers) can help surface potentially unexpected language results. The inspection does not flag an implicit parameter mechanism for the last parameter of Property mutators (Let or Set). VBA applies a ByVal parameter mechanism to the last parameter in the absence (or presence!) of a modifier. Exception: UserDefinedType parameters must always be passed as ByRef.
Locates unqualified Workbook.Worksheets/Sheets/Names member calls inside workbook document modules, that implicitly refer to the host workbook.
Default severity: Warning
Implicit references inside a workbook document module can easily be mistaken for implicit references to the active workbook (ActiveWorkbook), which is the behavior in all other module types. By explicitly qualifying these member calls with 'Me', the ambiguity can be resolved. If the intent is to actually refer to the active workbook, qualify with 'ActiveWorkbook' to prevent a bug.
Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls inside worksheet modules, that implicitly refer to the containing sheet component.
Default severity: Warning
Implicit references inside a worksheet document module can easily be mistaken for implicit references to the active worksheet (ActiveSheet), which is the behavior in all other module types. By explicitly qualifying these member calls with 'Me', the ambiguity can be resolved. If the intent is to refer to the active worksheet, qualify with 'ActiveSheet' to prevent a bug.
Identifies the use of non-indexed default member accesses.
Default severity: Warning
Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made and can cause errors in which a member was forgotten to be called to go unnoticed.
Warns about constants that don't have an explicitly defined type.
Default severity: Warning
All constants have a declared type, whether a type is specified or not. The implicit type is determined by the compiler based on the value, which is not always the expected type.
Highlights implicit Public access modifiers in user code.
Default severity: Hint
In modern VB (VB.NET), the implicit access modifier is Private, as it is in most other programming languages. Making the Public modifiers explicit can help surface potentially unexpected language defaults.
Identifies the use of indexed default member accesses that require a recursive default member resolution.
Default severity: Warning
Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made and the final default member is not on the interface of the object itself. In particular, this can cause errors in which a member was forgotten to be called to go unnoticed.
Identifies the use of indexed default member accesses for which the default member cannot be determined at compile time.
Default severity: Warning
Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made and if the default member cannot be determined from the declared type of the object. As a consequence, errors in which a member was forgotten to be called can go unnoticed and should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.
Warns about 'Function' and 'Property Get' procedures that don't have an explicit return type.
Default severity: Hint
All functions return something, whether a type is specified or not. The implicit default is 'Variant'.
Identifies the use of indexed default member accesses.
Default severity: Warning
An indexed default member access hides away the actually called member.
Identifies the use of indexed default member accesses that require a recursive default member resolution.
Default severity: Warning
An indexed default member access hides away the actually called member. This is especially problematic if the corresponding parameterized default member is not on the interface of the object itself.
Identifies the use of indexed default member accesses for which the default member cannot be determined at compile time.
Default severity: Warning
An indexed default member access hides away the actually called member. This is especially problematic if the default member cannot be determined from the declared type of the object. Should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.
Identifies obsolete 16-bit integer variables.
Default severity: Hint
Modern processors are optimized for processing 32-bit integers; internally, a 16-bit integer is still stored as a 32-bit value. Unless code is interacting with APIs that require a 16-bit integer, a Long (32-bit integer) should be used instead.
Flags invalid or misplaced Rubberduck annotation comments.
Default severity: Warning
Rubberduck is correctly parsing an annotation, but that annotation is illegal in that context and couldn't be bound to a code element.
Identifies uses of 'IsMissing' involving non-variant, non-optional, or array parameters.
Default severity: Warning
'IsMissing' only returns True when an optional Variant parameter was not supplied as an argument. This inspection flags uses that attempt to use 'IsMissing' for other purposes, resulting in conditions that are always False.
Identifies uses of 'IsMissing' involving a non-parameter argument.
Default severity: Warning
'IsMissing' only returns True when an optional Variant parameter was not supplied as an argument. This inspection flags uses that attempt to use 'IsMissing' for other purposes, resulting in conditions that are always False.