replaced IdentifierUsageInspector with parseResult.Declarations queries

retailcoder · Mar 23, 2015 · 1545bc1 · 1545bc1
1 parent 256aadd
commit 1545bc1
Show file tree

Hide file tree

Showing 15 changed files with 140 additions and 562 deletions.
diff --git a/RetailCoder.VBE/Inspections/Inspector.cs b/RetailCoder.VBE/Inspections/Inspector.cs
@@ -27,6 +27,9 @@ public async Task<IList<ICodeInspectionResult>> FindIssuesAsync(VBProject projec
             RaiseResetEvent();
 
             var code = new VBProjectParseResult(_parser.Parse(project));
+            code.IdentifySymbols();
+            code.IdentifySymbolUsages(); // surely a bottleneck
+
             var allIssues = new ConcurrentBag<ICodeInspectionResult>();
 
             var inspections = _inspections.Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow)

diff --git a/RetailCoder.VBE/Inspections/ParameterCanBeByValInspection.cs b/RetailCoder.VBE/Inspections/ParameterCanBeByValInspection.cs
@@ -1,5 +1,8 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
@@ -16,11 +19,15 @@ public ParameterCanBeByValInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
-            var issues = parseResult.IdentifierUsageInspector.UnassignedByRefParameters();
+            var declarations = 
+                parseResult.Declarations.Items.Where(declaration =>
+                    declaration.DeclarationType == DeclarationType.Parameter
+                    && ((VBAParser.ArgContext) declaration.Context).BYVAL() == null
+                    && !declaration.References.Any(reference => reference.IsAssignment));
 
-            foreach (var issue in issues)
+            foreach (var issue in declarations)
             {
-                yield return new ParameterCanBeByValInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.MemberName);
+                yield return new ParameterCanBeByValInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
             }
         }
     }

diff --git a/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
@@ -16,10 +18,13 @@ public ParameterNotUsedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
-            var issues = parseResult.IdentifierUsageInspector.UnusedParameters();
-            foreach (var issue in issues)
+            var declarations = parseResult.Declarations.Items.Where(declaration =>
+                declaration.DeclarationType == DeclarationType.Parameter
+                && !declaration.References.Any());
+
+            foreach (var issue in declarations)
             {
-                yield return new ParameterNotUsedInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.MemberName);
+                yield return new ParameterNotUsedInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
             }
         }
     }

diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
@@ -16,11 +18,18 @@ public UnassignedVariableUsageInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
-            var issues = parseResult.IdentifierUsageInspector.AllUnassignedVariableUsages();
-            foreach (var issue in issues)
+            var usages = parseResult.Declarations.Items.Where(declaration =>
+                declaration.DeclarationType == DeclarationType.Variable
+                && !declaration.References.Any(reference => reference.IsAssignment))
+                .SelectMany(declaration => declaration.References);
+
+            foreach (var issue in usages)
             {
-                yield return new UnassignedVariableUsageInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
+                //todo: add context to IdentifierReference
+                //yield return new UnassignedVariableUsageInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
             }
+
+            return null;
         }
     }
 }
diff --git a/RetailCoder.VBE/Inspections/VariableNotAssignedInspection.cs b/RetailCoder.VBE/Inspections/VariableNotAssignedInspection.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
@@ -16,10 +18,17 @@ public VariableNotAssignedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
-            var issues = parseResult.IdentifierUsageInspector.AllUnassignedVariables();
-            foreach (var issue in issues)
+            var declarations = parseResult.Declarations.Items.Where(declaration =>
+                declaration.DeclarationType == DeclarationType.Variable
+                && !parseResult.Declarations.Items.Any(item => 
+                    item.IdentifierName == declaration.AsTypeName 
+                    && item.DeclarationType == DeclarationType.UserDefinedType) // UDT variables don't need to be assigned
+                && !declaration.IsSelfAssigned
+                && !declaration.References.Any(reference => reference.IsAssignment));
+
+            foreach (var issue in declarations)
             {
-                yield return new VariableNotAssignedInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
+                yield return new VariableNotAssignedInspectionResult(string.Format(Name, issue.IdentifierName), Severity, issue.Context, issue.QualifiedName.ModuleScope);
             }
         }
     }

diff --git a/RetailCoder.VBE/Inspections/VariableNotDeclaredInspection.cs b/RetailCoder.VBE/Inspections/VariableNotDeclaredInspection.cs
diff --git a/RetailCoder.VBE/Inspections/VariableNotUsedInspection.cs b/RetailCoder.VBE/Inspections/VariableNotUsedInspection.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
@@ -16,10 +18,13 @@ public VariableNotUsedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(VBProjectParseResult parseResult)
         {
-            var issues = parseResult.IdentifierUsageInspector.AllUnusedVariables();
-            foreach (var issue in issues)
+            var declarations = parseResult.Declarations.Items.Where(declaration =>
+                (declaration.DeclarationType == DeclarationType.Variable)
+                && !declaration.References.Any(reference => !reference.IsAssignment));
+
+            foreach (var issue in declarations)
             {
-                yield return new VariableNotUsedInspectionResult(string.Format(Name, issue.Context.GetText()), Severity, issue.Context, issue.QualifiedName);
+                yield return new VariableNotUsedInspectionResult(string.Format(Name, issue.IdentifierName), Severity, issue.Context, issue.QualifiedName.ModuleScope);
             }
         }
     }

diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj
@@ -250,7 +250,6 @@
     <Compile Include="Inspections\ParameterNotUsedInspectionResult.cs" />
     <Compile Include="Inspections\UnassignedVariableUsageInspection.cs" />
     <Compile Include="Inspections\UnassignedVariableUsageInspectionResult.cs" />
-    <Compile Include="Inspections\VariableNotDeclaredInspection.cs" />
     <Compile Include="Inspections\VariableNotDeclaredInspectionResult.cs" />
     <Compile Include="Inspections\VariableNotUsedInspection.cs" />
     <Compile Include="Inspections\VariableNotUsedInspectionResult.cs" />

diff --git a/RetailCoder.VBE/VBA/RubberduckParser.cs b/RetailCoder.VBE/VBA/RubberduckParser.cs
@@ -1,6 +1,8 @@
-using System.Collections.Concurrent;
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Tree;
@@ -38,25 +40,36 @@ public IEnumerable<VBComponentParseResult> Parse(VBProject project)
             var modules = project.VBComponents.Cast<VBComponent>();
             foreach(var module in modules)
             {
-                yield return Parse(module);
+                var result = Parse(module);
+                if (result != null)
+                {
+                    yield return result;
+                }
             }
         }
 
         public VBComponentParseResult Parse(VBComponent component)
         {
-            VBComponentParseResult cachedValue;
-            var name = component.QualifiedName();
-            if (ParseResultCache.TryGetValue(name, out cachedValue))
+            try
             {
-                return cachedValue;
-            }
+                VBComponentParseResult cachedValue;
+                var name = component.QualifiedName();
+                if (ParseResultCache.TryGetValue(name, out cachedValue))
+                {
+                    return cachedValue;
+                }
 
-            var parseTree = Parse(CodeModuleExtensions.Lines(component.CodeModule));
-            var comments = ParseComments(component);
-            var result = new VBComponentParseResult(component, parseTree, comments);
+                var parseTree = Parse(CodeModuleExtensions.Lines(component.CodeModule));
+                var comments = ParseComments(component);
+                var result = new VBComponentParseResult(component, parseTree, comments);
 
-            ParseResultCache.AddOrUpdate(name, module => result, (qName, module) => result);
-            return result;
+                ParseResultCache.AddOrUpdate(name, module => result, (qName, module) => result);
+                return result;
+            }
+            catch (COMException exception)
+            {
+                return null;
+            }
         }
 
         public IEnumerable<CommentNode> ParseComments(VBComponent component)

diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -93,7 +93,6 @@
     <Compile Include="Grammar\VBAVisitor.cs" />
     <Compile Include="Symbols\IdentifierReference.cs" />
     <Compile Include="Symbols\IdentifierReferenceListener.cs" />
-    <Compile Include="Symbols\IdentifierUsageInspector.cs" />
     <Compile Include="VBComponentExtensions.cs" />
     <Compile Include="VBComponentParseResult.cs" />
     <Compile Include="VBProjectParseResult.cs" />

diff --git a/Rubberduck.Parsing/Symbols/Declaration.cs b/Rubberduck.Parsing/Symbols/Declaration.cs
@@ -1,5 +1,5 @@
-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using Antlr4.Runtime;
 
 namespace Rubberduck.Parsing.Symbols
 {
@@ -8,22 +8,27 @@ namespace Rubberduck.Parsing.Symbols
     /// </summary>
     public class Declaration
     {
-        public Declaration(int projectHashCode, string parentScope,
-            string projectName, string componentName, string identifierName, string asTypeName, bool isSelfAssigned,
-            Accessibility accessibility, DeclarationType declarationType, Selection selection)
+        public Declaration(QualifiedMemberName qualifiedName, string parentScope,
+            string identifierName, string asTypeName, bool isSelfAssigned,
+            Accessibility accessibility, DeclarationType declarationType, ParserRuleContext context)
         {
-            _projectHashCode = projectHashCode;
+            _qualifiedName = qualifiedName;
             _parentScope = parentScope;
-            _projectName = projectName;
-            _componentName = componentName;
             _identifierName = identifierName;
             _asTypeName = asTypeName;
             _isSelfAssigned = isSelfAssigned;
             _accessibility = accessibility;
             _declarationType = declarationType;
-            _selection = selection;
+            _selection = context.GetSelection();
+            _context = context;
         }
 
+        private readonly QualifiedMemberName _qualifiedName;
+        public QualifiedMemberName QualifiedName { get { return _qualifiedName; } }
+
+        private readonly ParserRuleContext _context;
+        public ParserRuleContext Context { get { return _context; } }
+
         private readonly IList<IdentifierReference> _references = new List<IdentifierReference>();
         public IEnumerable<IdentifierReference> References { get { return _references; } }