What's new in Project Analyzer v10.3


Project Analyzer v10.3 detects obsolete and redundant syntax in your Visual Basic code. Locate unwanted code that has been commented out. Upgrade your Project Analyzer and bring new life to your good old VB projects.

Try & upgrade Upgrade prices Upgrade FAQ Old improvements

New to Project Analyzer? Read the introduction.

Latest updates with Project Analyzer v10.3

  • Analyze Office 2019 VBA with VBA Plug v3.3.
  • Windows 10 support enhanced.
  • High-DPI monitor support enhanced.
  • 8 new code review rules and 2 updates:
    • "Possibly commented-out code": Clean up your project by deleting commented-out lines.
    • "DefType statement found": Relying on DefType may confuse. Declare "As Datatype" instead.
    • "For conditions illogical": The rule detects For..Next loops that won't start, loops that may iterate just once and loops that may iterate forever.
    • "For with Step 1 found": Specifying Step 1 is redundant.
    • "Next statement ends multiple For loops": Next i, j was found. For and Next should appear in pairs.
    • "Let statement found": The Let keyword is obsolete and redundant.
    • "On Local Error statement found": The Local keyword is obsolete and redundant.
    • "Rem comment found": The Rem keyword is obsolete.
    • "Default name": Rule updated to detect default project and module names such as Project1 and Module1.
    • "Verify accuracy": Rule updated with the latest known values of physical and astronomical constants.
  • Reporting update:
    • Compiler directives report (new) summarizes compiler directives and compiler constants.
    • Summary report counts statement types, branching statistics, decisions and operators.
    • Design quality report analyzes the amount of commented-out code, line lengths, whitespace, indentation and tab stops.
    • Form report updated. Added Form list with filename and caption.
    • HTML reports updated.
  • Other features updated: Print code, Export code as PDF, Hex viewer.

VBA Plug v3.3

VBA Plug v3.3 supports Office 2010, 2013, 2016 and 2019 in addition to Office 2000–2007.

Project Analyzer v10 requires VBA Plug v3.x to analyze any VBA code. If you have an old VBA Plug, you need to purchase an upgrade ($69).

Other improvements in Project Analyzer v10.x since v9

  • Analyze Visual Basic 2010, 2012 and 2013 code. Project Analyzer v10.3 supports Visual Basic versions 3.0, 4.0, 5.0, 6.0, 2002, 2003, 2005, 2008, 2010, 2012 and 2013.
  • Analyze VBA code (Office 2010, 2013, 2016, 2019) with VBA Plug v3.3.
  • Analyze .NET assemblies. Detect references to the .NET Framework and other binary assemblies. Improve accuracy of advanced analyses. Ent
  • Find rotten code with 34 new review rules. See rules below.
  • Find duplicate code reports more matches.
  • Document code with 6 new reports. 20 reports updated. See reports below.
  • Archive feature rewritten. Zip up your project files.
  • New metrics for dead code and statement density. Ent
  • Visio 2010, 2013, 2016 and 2019 support in Enterprise Diagrams and VBA Plug.
  • Windows 7, 8 and 10 support, including high-density displays and large fonts.

Std = Standard Edition. Pro = Pro Edition. Ent = Enterprise Edition.

34 other new code review rules

Everyone makes mistakes. The skill is in correcting them before it's too late. Appear smarter than your colleagues: Use Project Analyzer to double-check program logic for thoughtless omissions.

Find dead and undefined code

  • "Dead line label or number": Line label or line number is not used as a jump target.
  • "Dead compiler constant": Compiler constant is defined but not used for conditional compilation.
  • "Undefined compiler constant": Compiler constant is used for conditional compilation but not defined.

Find rotten logic

  • "Unreachable code found": A block of code never executes because it is not reachable.
  • "Empty block": This rule reports empty blocks such as If, Else, Catch.
  • "Variable read before written (along some path)": Potential logic mistake.
  • "Variable read before written": Variable always contains its default value at this point.
  • "Object read before written (along some path)": Run-time error (null pointer reference) could occur.
  • "Object read before written": Run-time error (null pointer reference) is likely.
  • "Assigned value not used": Useless assignment, check logic.
  • "Assigned object not used": Useless assignment, check logic.
  • "Loop runs only once": Potential logic flaw. Why loop just 1 time?
  • "Loop runs forever": No reachable exit from this loop. Potential jam.
  • "Condition always True or False at run-time": Statement is unconditional due to run-time conditions.
  • "Verify accuracy": This floating point constant may be imprecise.

Find rotten parameters

  • "Parameter value not used": Logic flaw: Parameter is overwritten before its value is read.
  • "Passed value not used": Receiving procedure doesn't use this parameter. Could optimize.
  • "Optional parameter never passed a value": Is this parameter superfluous?
  • "Rewrite Sub as Function": Use return value instead of 'out' parameter.

Find rotten design

  • "Possibly orphaned event handler": Sub no longer handles any events.
  • "Event handler called directly": Event handlers should not be explicitly called.
  • "Implementation called directly": Should not call a procedure that implements an interface.
  • "Event handler should be Private": Prevent event handler calls from other modules.
  • "Implementation should be Private": Prevent access to implementation from other modules.
  • "Non-instantiatable class has instance members": Why define members that can't be accessed?
  • "Class/Structure nested inside Interface": Bad programming style.
  • "Magic number found": A numeric literal is not defined as a constant.

Find rotten performance

  • "Slow ^ operator found": Replace ^ by one or more multiplications.
  • "CreateObject found": Use "As New" early binding instead of late binding.

New rules to replace old rules

  • "Microsoft.VisualBasic.Compatibility imported" replaces old rule "Microsoft.VisualBasic imported". The Compatibility namespace is a style problem while the VisualBasic namespace is not.
  • "Conditional block excluded" replaces old rule "Conditional block will not upgrade to VB.NET" and is now available in all editions. Finds lines where #If or #Else block condition is False.
  • 3 rules replace old rule "Return and Exit statement found":
    • Exit Sub|Function|Property found
    • Exit statement found (other Exit statements)
    • Return statement found (VB.NET)

6 new reports and 20 report updates

  • Variable list shows all variables and data type summary.
  • Constant list shows all constants and compiler constants, plus data type summary.
  • Procedure references report shows the call sites of each procedure.
  • Variable references report shows how each variable is accessed.
  • Constant references report shows how each constant is referenced.
  • String literal report lists all strings with the context they appear in. Includes an alphabetical string list for copying to a translator or a spell checker. Lists non-ASCII strings for portability check.
  • Improved reports: Summary report, Design quality report, Procedure list, Procedure list with details, File list with details, Variable use report, Problem report by location, String literal analysis, Module interface report, Module members report, Dictionary, Duplicate code report, Form report, Call tree reports, Library report, Module list, Super report, Source report in dialog View|References.
  • Files and projects report accommodates more projects. Includes a file count section. Ent
  • VB.NET compatibility report considers issues with dead code. Ent
  • General reporting update:
    • Printed reports use improved formatting. Now similar to PDF reports.
    • RTF reports improved. Compatibility with WordPad on Windows 7 and 8.x. Page headers and margins.
    • PDF reports improved and fixed.
    • Plain-text reports reformatted.
    • CSV reports improved for easier data import to Excel.
    • Report formatting improved, report internal links added, and more.

Other improvements

  • Find duplicate code now searches case-insensitively and returns duplicates within a single file as well. Ent
  • New comment directives for controlling code review results: IN_THIS_PROJECT, ANYWHERE, WHERE condition.
  • New metrics: dUDTS Dead user-defined types. dENUMS Dead Enums. dENUMCS Dead Enum constants. SDENS Statement density. Ent
  • Project Printer prints formatted code. Pro, Ent
  • Non-Western character support, including Japanese letters and others.
  • "Short name" problem:
    • New option: Allow single-character local variables (i, j, k, ...) used as For index variables.
    • Allows e As System.EventArgs, Catch ex and short DLL procedure parameters.
    • Reports short Enum constant and Type field names.

Analysis improvements

Improved detection of default member references and COM in/out parameters. Improved accuracy of Overloads resolution, type inference and <Extension()> method calls. Improved support for [keyword] and {..} syntax. Improved handling of generic types. Performance boost with large XML literals. Support for XML Axis syntax: .<tag> and ...<tag> and .@<attrib>. Support for block-level local variables and constants.

Try & upgrade today


Download the newest Project Analyzer demo. It will co-exist with your current Project Analyzer version. Just make sure you put it in a new directory. The free demo can analyze max 10 source code files at a time. You can try it on any of your projects by selecting max 10 files to analyze. Or, analyze some of the nice little sample projects in your Visual Basic directory.

Upgrade prices

Discounted upgrades to Project Analyzer v10 are available from versions 7, 8 and 9 (which were available from 2003 to 2010). A full price is required for upgrading from earlier versions.

Project Analyzer upgrades (US dollars)
Project Analyzer version upgrade Single user 2-pack Team 10-pack Site
v10 Std Upgrade from v7/8/9 all editions $149 $249 $449 $699
v10 Pro Upgrade from v7/8/9 all editions $249 $419 $749 $1090
v10 Ent Upgrade from v7/8/9 Ent $499 $839 $1490 $2290 $4490
v10 Ent Upgrade from v7/8/9 Std/Pro $789 $1390 $2390 $3690
VBA Plug v3 Upgrade from v1/v2
$69 $119 $199
Upgrade requires an existing license (same size or larger). Example: Upgrade to 2-pack requires an old 2-pack or larger.
Upgrade within v10 equals price difference (new price − original price).

Minor updates are free within the major version number: Project Analyzer v10.x, VBA Plug v3.x.

Upgrade FAQ

Q: Does it support the newest Visual Studio?

A: Project Analyzer supports VB.NET from version 2002 to 2013, but not later.

Q: Does it support VB6? VB5? VB4? VB3?

A: Yes, all of them—and better than ever before.

Q: Does it support Office VBA?

A: Project Analyzer supports Office VBA code with VBA Plug. Support includes Office 2019 and older. 32bit and 64bit.

Q: I code in VB6. Is there something for me in the new version?

A: Yes. The new code review rules alone are a perfect reason to upgrade your old copy of Project Analyzer. The older your code, the more useful Project Analyzer gets.

Q: Do I need to upgrade my old VBA Plug v1 or v2?

A: To analyze VBA code, yes. Old VBA Plug versions 1 and 2 are incompatible with Project Analyzer v10.

Q: Is v10.3 a free update?

A: Project Analyzer v10.3 is a free update to all licensed users of v10. Request yours

Old improvements in v9

  • Analyze Visual Basic 2008. Project Analyzer v9.0 supports Visual Basic versions 3.0, 4.0, 5.0, 6.0, 2002, 2003, 2005 and 2008.
  • 52 new code review rules. Find new bugs in your old code! See list below.
  • <Flaw finder> code review rules help locate logical mistakes and omissions and prevent future errors.
  • Create source print-outs in PDF. Produce interactive PDF source documentation where the reader can surf your code via links. Get cool new PDF files from Project Printer and as PDF print-outs.
  • Pseudo-code COM and DLL view. View the interface to library files as regular VB code. Ent
  • Hex viewer for binary files.
  • Analyze directory tree of source code files. It is no longer required to have a complete project (.vbproj or .sln) to analyze source files. Useful for analyzing codebehind classes of web sites.
  • Classify modules to understand legacy projects. The Module list report groups modules into Definitions, Interface, Abstract class, Concrete class, Stateless class, Dialog, Standard module and the like.
  • VB.NET 2008 compatibility check for VB6 code. Ent

52 code review rules added: Find new bugs in old code

Project Analyzer v9 adds 52 code review rules, pushing the total over 250 rules supported. Watch for bad mistakes and thoughtless omissions in your colleagues' code—or your own. Impress your boss by smashing sleeping bugs before they wake up. Insure your applications against future mistakes.

Find hidden flaws with new dead code rules

Project Analyzer has improved considerably in its ability to detect partially unused code. Dead code detection now finds variables and constants that appear alive, but that are not so in reality.

  • "Variable users all dead." A variable seems to be in use, but the user procedures never execute. The variable is practically useless.
  • "Variable readers all dead." A variable is being read and written. The reader procedures never execute. One or more writes do execute, to no benefit.
  • "Variable writers all dead." A variable is being read and written. The writer procedures never execute. One or more reads do execute, though. Since the variable never gets a proper value, this can be a flaw.
  • "Variable not read, writers all dead." A variable is practically unused and useless. It is never read. Write statements never execute. It looks like a leftover from previous functionality.
  • "Variable not written, readers all dead." A variable is practically unused and useless. It is never assigned a value. Read statements never execute. The variable is a sleeping bug waiting to wake up and cause havoc.
  • Rules similar to the above also exist for UDT fields (Type..End Type).
  • "Constant users all dead." "Enum constant users all dead." A constant is referenced in the code, but the user procedures never execute. The value is effectively dead. If the value should be used, the program contains a flaw. Alternatively, this is a leftover from removed or disabled functionality.
  • "Enum users all dead." An Enum is used as a data type, but the user procedures are all dead. The values in the Enum never appear at run-time. The program contains a flaw or a leftover from previous functionality.

Prevent problems with Enums, Cases and bad conditions

  • "Enum missing zero value" locates incomplete Enums.
  • "Enum with duplicate value" reports duplicated Enum constants.
  • "Enum constant expected" warns if a number appears in place of Enum. Can be dangerous.
  • "Case branch(es) missing for Enum" compares Select Case against Enum and finds unhandled Enum values.
  • "Case useless" finds Case branches that never execute.
  • "Case overlap" finds Case ranges partially covered by a previous Case.
  • "Condition always True" (or False) reports unconditional branches and loops.

Prevent errors before they hit the user

  • "Hard-coded path found" reports directory paths in the source.
  • "ReDim without Dim" tells to add a Dim statement for arrays.
  • "For index variable not local" warns about a potentially dangerous For..Next.
  • "Octal number found" locates hard-to-read numbers (&O10 = 8).
  • "Declare contains ordinal number" reports DLL Declares with the brittle "#1" syntax.
  • "Cyclic recursion found" locates potential stack overflow.

Enforce consistent style

  • "Data-only class found" reports classes missing any operations.
  • "Dataless class found" reports classes having no internal state.
  • "Write-only property found" reports a missing Property Get, or Property Get having a smaller scope than Set or Let.
  • "Trailing comment found" reports end-of-line comments if you prefer full-line comments.
  • "Line too long" triggers when length exceeds your preferred maximum number of characters.
  • "CVDate found, use CDate" finds the old Variant function CVDate.

Watch for risky VB.NET syntax

  • "Type inference used" finds where the potentially dangerous Option Infer On is in use.
  • "Optional parameter in exposed procedure" verifies cross-language interoperability.
  • "File with several classes or modules" demands that each file should consist of a single class or module.
  • "Implicit variable" warns about an invisible variable declaration in a For statement.
  • "RaiseEvent fails via constructor" warns about nasty unfired Events.
  • "Multiple Return statements found" reports procedures with several exit points.
  • "ReadOnly variable expected" shows which variables to mark as ReadOnly.

Enforce VB.NET class design rules

  • "Shared constructor decreases performance" reports the slow Shared Sub New.
  • "Parent class inherited only once" appears for classes having just one child class.
  • "Shared-only class instantiated" locates unnecessary use of As New.
  • "NotInheritable expected" appears for classes with only Shared members, not suitable for inheritance.
  • "Interface ambiguous" appears when an Interface has two methods or properties with the same name.
  • "Interface duplicated" detects superfluous use of an Interface.
  • "MustInherit class missing MustOverride methods" requires abstract classes have abstract methods or properties.
  • "MustInherit class inherits concrete class" requires abstract classes be on top of the class hierarchy.
  • "MustOverride overrides concrete procedure" appears when a class deletes inherited functionality, not providing replacement.
  • "Shared expected" finds methods and properties that could be declared Shared.

Other improvements in v9

  • Report enhancements:
    • Variables and constants report rewritten. Constants display their actual value in addition to their formula.
    • Variable deadness status added to Variable use report.
    • File LOC and age added to File sizes and dates report.
    • Library base address list added to Library report for optimizing your DLLs.
    • Statistics on names added to Dictionary report.
    • PDF reports rewritten.
  • Code review enhancements:
    • Enhanced rules for "Empty procedure", "Unused file", "Dead parameter", "Excess Scope", "Microsoft.VisualBasic imported".
    • Option to Ignore dead Property Get/Set/Let if another accessor is alive. Allow read/write properties also when either read or write is currently out of use.
    • Option to independently switch on/off the following code review rules: "Dead parameter", "ByVal parameter not read".
  • Find window: Search for "Code or String". Search results reformatted for readability.
  • Print code: New option "Bracket structures" emphasizes decision and loop structures.
  • Auto-fix preserves line continuation characters (_) when possible. Auto-fix can split long lines, move end-of-line comments to full-line comments and add a Dim statement before a ReDim if required.
  • Image version and compile time displayed for library files and executables.
  • Unicode support. Load international source in any codepage (character set).
  • Analysis improvements: Single-line Type and Enum blocks. Single-line classic VB declarations such as Dim x:Dim y or Sub x:End Sub. Generic Structure and Interface (Of T). Time literals #11:25:00#.
  • Late-bound and overloaded call resolution is improved a lot, leading to better accuracy with projects using these techniques.
  • Performance improvements for large analyses.

Old improvements in v8

Metrics added in v8.0 Ent
Project metrics
VARSgm Global and module-level vars
VARSloc Local variables
ENUMSZ Average Enum size
ENUMR Enum ratio
Rc Reuse of constants
TREADS Total variable reads
TWRITES Total variable writes
TRW Total variable reads+writes
DATADENS Data access density
IOg% Global I/O ratio
maxDCALLT Max depth of call tree
maxSCALLT Max size of call tree

MOOD2 object-oriented metrics
OHEF Operation hiding effectiveness
AHEF Attribute hiding effectiveness
IIF Internal inheritance factor
PPF Parametric polymorphism factor

Class metrics
LCOM4 Lack of cohesion of methods
TCCi, TCCl Tight class cohesion
LCCi, LCCl Loose class cohesion

Procedure metrics
IOg Global I/O
IOp Parameter I/O
IOvars Input and output variables
SCALLT Size of call tree

Variable metrics
READS Number of reads from variable
WRITES Number of writes to variable
RW Number of reads and writes
FLOWS Data flows into/out of variable
LENV Length of variable name
VARUSR Variable users
  • Analyze VB.NET 2005 code (plus VB 3.0-6.0, 2002, 2003 and VBA).
  • Enterprise Diagrams visualize your system. Get complete dependency diagrams, inheritance diagrams, call diagrams, data diagrams, object instantiation diagrams etc. More Ent
  • Visio diagramming. Send Enterprise Diagrams to Microsoft Visio. Ent
  • Project Graph news: Instantiation tree shows where classes are being instantiated. Data declaration tree shows where classes, structures, interfaces and forms are being used as data types. Pro, Ent
  • 20 new reports plus improved reporting to html/pdf/rtf/mht files. Find reusable subsystems and bad non-cohesive classes! Report list below.
  • Print code with syntax highlighting. Produce professional multi-column print-outs in color. More
    Sample print-outs: Color, Monochrome.
  • Export code as HTML or RTF with syntax highlighting.
  • Export metrics as XML. Ent
  • Project Metrics supports a total of 180 different metrics. See additions on the right. New metrics reports and XML export. Ent
  • Analyze constants and enums for duplicates and bugs.
  • List and navigate data types, modules, procedures, variables, parameters and constants.
  • New dead code analyses: Dead Enum constant. Dead Type field. Type field written, not read. Type field read, not written. Variable read, not written. Return value not set. Unused COM library file (COM requires Ent). Remove unused code and detect logical flaws!
  • New code review rules: Too many uncommented lines, Pass ByRef, ByRef parameter returns a value, ByVal parameter written to, ByRef parameter read only - consider ByVal, Initializer missing, Optional parameter missing default value, Assignment to self.
  • "In" and "out" parameters detected for procedures.
  • Improved analysis of special cases such as default members, constructor calls, overloads, enumerators.
  • Usability improvements: Bookmarks, mouse wheel support, line numbers, ...
  • Visustin integration for flowcharting. Requires Visustin v3.1 or later.

Reports added in v8

  • Module members report with several sub-options to list the procedures and/or variables of each module: All procedures and variables, Data input, Data output, External access, External data input, External data output, Module data, Private data, Data read access, Data write access, Properties, Procedures, Methods, Events, Constructors, Constructors and finalizers, Procedures with "out" parameters.
  • Interface report lists interfaces with implementations.
  • Files and projects report lists which project includes which files. It is useful for determining the use of shared files. Ent
  • Super report in Super Project Analyzer lists the dead code across all your projects, as well as in which projects your code is being reused. Pro, Ent
  • Variable use report lists the number of live/dead variable reads & writes. Locate potentially dead variables and logical flaws where a variable might not be properly set.
  • Problem statistics report summarizes the number of problems found by code review.
  • Dead code statistics report displays the amount of dead code grouped by deadness type.
  • File dependency levels report lists files in their dependency order.
  • Non-cohesive classes report finds classes to split up.
  • Subsystem report finds reusable subsystems in a program.

More information

Detailed version history
Project Analyzer features and versions pdf
Download demo