Merge pull request #2970 from Hosch250/tweakRefactorings

retailcoder · web-flow · commit 935f6da811df · 2017-04-15T09:54:37.000-04:00
Kill a few more uses of AllUserDeclarations
diff --git a/Rubberduck.Inspections/Concrete/ImplicitVariantReturnTypeInspection.cs b/Rubberduck.Inspections/Concrete/ImplicitVariantReturnTypeInspection.cs
@@ -18,17 +18,10 @@ public ImplicitVariantReturnTypeInspection(RubberduckParserState state)
 
         public override CodeInspectionType InspectionType => CodeInspectionType.CodeQualityIssues;
 
-        private static readonly DeclarationType[] ProcedureTypes = 
-        {
-            DeclarationType.Function,
-            DeclarationType.PropertyGet,
-            DeclarationType.LibraryFunction
-        };
-
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var issues = from item in UserDeclarations
-                         where ProcedureTypes.Contains(item.DeclarationType) && !item.IsTypeSpecified
+            var issues = from item in State.DeclarationFinder.UserDeclarations(DeclarationType.Function)
+                         where !item.IsTypeSpecified && !IsIgnoringInspectionResultFor(item, AnnotationName)
                          let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}
                          select new ImplicitVariantReturnTypeInspectionResult(this, issue.QualifiedContext, item);
             return issues;
diff --git a/Rubberduck.Inspections/Concrete/MoveFieldCloserToUsageInspection.cs b/Rubberduck.Inspections/Concrete/MoveFieldCloserToUsageInspection.cs
@@ -18,11 +18,12 @@ public MoveFieldCloserToUsageInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            return UserDeclarations
+            return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
                 .Where(declaration =>
                 {
-                    if (declaration.DeclarationType != DeclarationType.Variable || declaration.IsWithEvents ||
-                        !new[] {DeclarationType.ClassModule, DeclarationType.ProceduralModule}.Contains(declaration.ParentDeclaration.DeclarationType))
+                    if (declaration.IsWithEvents
+                        || !new[] {DeclarationType.ClassModule, DeclarationType.ProceduralModule}.Contains(declaration.ParentDeclaration.DeclarationType)
+                        || IsIgnoringInspectionResultFor(declaration, AnnotationName))
                     {
                         return false;
                     }
diff --git a/Rubberduck.Inspections/Concrete/SelfAssignedDeclarationInspection.cs b/Rubberduck.Inspections/Concrete/SelfAssignedDeclarationInspection.cs
@@ -19,15 +19,15 @@ public SelfAssignedDeclarationInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            return UserDeclarations
+            return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
                 .Where(declaration => declaration.IsSelfAssigned 
                     && declaration.IsTypeSpecified
                     && !SymbolList.ValueTypes.Contains(declaration.AsTypeName)
-                    && declaration.DeclarationType == DeclarationType.Variable
                     && (declaration.AsTypeDeclaration == null
                         || declaration.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)
                     && declaration.ParentScopeDeclaration != null
                     && declaration.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member))
+                .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName))
                 .Select(issue => new SelfAssignedDeclarationInspectionResult(this, issue));
         }
     }
diff --git a/Rubberduck.Inspections/Concrete/UnassignedVariableUsageInspection.cs b/Rubberduck.Inspections/Concrete/UnassignedVariableUsageInspection.cs
@@ -20,12 +20,12 @@ public UnassignedVariableUsageInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var declarations = UserDeclarations.Where(declaration => 
-                declaration.DeclarationType == DeclarationType.Variable
-                && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType
-                    && d.IdentifierName == declaration.AsTypeName)
-                && !declaration.IsSelfAssigned
-                && !declaration.References.Any(reference => reference.IsAssignment && !IsIgnoringInspectionResultFor(reference, AnnotationName)));
+            var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
+                .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName))
+                .Where(declaration => 
+                    State.DeclarationFinder.MatchName(declaration.AsTypeName).All(d => d.DeclarationType != DeclarationType.UserDefinedType)
+                    && !declaration.IsSelfAssigned
+                    && !declaration.References.Any(reference => reference.IsAssignment && !IsIgnoringInspectionResultFor(reference, AnnotationName)));
 
             //The parameter scoping was apparently incorrect before - need to filter for the actual function.
             var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
diff --git a/Rubberduck.Inspections/Concrete/UndeclaredVariableInspection.cs b/Rubberduck.Inspections/Concrete/UndeclaredVariableInspection.cs
@@ -18,7 +18,8 @@ public UndeclaredVariableInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            return UserDeclarations.Where(item => item.IsUndeclared && item.DeclarationType == DeclarationType.Variable)
+            return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
+                .Where(item => item.IsUndeclared && !IsIgnoringInspectionResultFor(item, AnnotationName))
                 .Select(item => new UndeclaredVariableInspectionResult(this, item));
         }
     }
diff --git a/Rubberduck.Inspections/Concrete/VariableNotAssignedInspection.cs b/Rubberduck.Inspections/Concrete/VariableNotAssignedInspection.cs
@@ -18,24 +18,19 @@ public VariableNotAssignedInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var items = UserDeclarations.ToList();
-
             // ignore arrays. todo: ArrayIndicesNotAccessedInspection
-            var arrays = items.Where(declaration =>
-                declaration.DeclarationType == DeclarationType.Variable
-                && declaration.IsArray).ToList();
+            var arrays = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable).Where(declaration => declaration.IsArray);
 
-            var declarations = items.Except(arrays).Where(declaration =>
-                declaration.DeclarationType == DeclarationType.Variable
-                && !declaration.IsWithEvents
-                && !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));
+            var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
+                .Except(arrays)
+                .Where(declaration =>
+                    !declaration.IsWithEvents
+                    && State.DeclarationFinder.MatchName(declaration.AsTypeName).All(item => item.DeclarationType != DeclarationType.UserDefinedType) // UDT variables don't need to be assigned
+                    && !declaration.IsSelfAssigned
+                    && !declaration.References.Any(reference => reference.IsAssignment))
+                .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName));
 
-            return declarations.Select(issue => 
-                new IdentifierNotAssignedInspectionResult(this, issue));
+            return declarations.Select(issue => new IdentifierNotAssignedInspectionResult(this, issue));
         }
     }
 }
diff --git a/Rubberduck.Inspections/Concrete/VariableTypeNotDeclaredInspection.cs b/Rubberduck.Inspections/Concrete/VariableTypeNotDeclaredInspection.cs
@@ -18,10 +18,16 @@ public VariableTypeNotDeclaredInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var issues = from item in UserDeclarations
-                         where (item.DeclarationType == DeclarationType.Variable
-                            || item.DeclarationType == DeclarationType.Constant
-                            || (item.DeclarationType == DeclarationType.Parameter && !item.IsArray))
+            var s =
+                State.DeclarationFinder.UserDeclarations(DeclarationType.Variable | DeclarationType.Constant |
+                                                         DeclarationType.Parameter);
+
+            var issues = from item in State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
+                         .Union(State.DeclarationFinder.UserDeclarations(DeclarationType.Constant))
+                         .Union(State.DeclarationFinder.UserDeclarations(DeclarationType.Parameter))
+                         where (item.DeclarationType != DeclarationType.Parameter || (item.DeclarationType == DeclarationType.Parameter && !item.IsArray))
+                         && item.DeclarationType != DeclarationType.Control
+                         && !IsIgnoringInspectionResultFor(item, AnnotationName)
                          && !item.IsTypeSpecified
                          && !item.IsUndeclared
                          select new VariableTypeNotDeclaredInspectionResult(this, item);
diff --git a/Rubberduck.Inspections/Concrete/WriteOnlyPropertyInspection.cs b/Rubberduck.Inspections/Concrete/WriteOnlyPropertyInspection.cs
@@ -18,15 +18,13 @@ public WriteOnlyPropertyInspection(RubberduckParserState state)
 
         public override IEnumerable<IInspectionResult> GetInspectionResults()
         {
-            var declarations = UserDeclarations.ToList();
-            var setters = declarations
+            var setters = State.DeclarationFinder.UserDeclarations(DeclarationType.Property | DeclarationType.Procedure)
                 .Where(item => 
                        (item.Accessibility == Accessibility.Implicit || 
                         item.Accessibility == Accessibility.Public || 
                         item.Accessibility == Accessibility.Global)
-                    && (item.DeclarationType == DeclarationType.PropertyLet ||
-                        item.DeclarationType == DeclarationType.PropertySet)
-                    && declarations.Where(declaration => declaration.IdentifierName == item.IdentifierName).All(accessor => accessor.DeclarationType != DeclarationType.PropertyGet))
+                    && State.DeclarationFinder.MatchName(item.IdentifierName).All(accessor => accessor.DeclarationType != DeclarationType.PropertyGet))
+                .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName))
                 .GroupBy(item => new {item.QualifiedName, item.DeclarationType})
                 .Select(grouping => grouping.First()); // don't get both Let and Set accessors
 

Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,12 @@ public MoveFieldCloserToUsageInspection(RubberduckParserState state)`
`18`	`18`
`19`	`19`	`public override IEnumerable<IInspectionResult> GetInspectionResults()`
`20`	`20`	`{`
`21`		`- return UserDeclarations`
	`21`	`+ return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)`
`22`	`22`	`.Where(declaration =>`
`23`	`23`	`{`
`24`		`- if (declaration.DeclarationType != DeclarationType.Variable \|\| declaration.IsWithEvents \|\|`
`25`		`- !new[] {DeclarationType.ClassModule, DeclarationType.ProceduralModule}.Contains(declaration.ParentDeclaration.DeclarationType))`
	`24`	`+ if (declaration.IsWithEvents`
	`25`	`+ \|\| !new[] {DeclarationType.ClassModule, DeclarationType.ProceduralModule}.Contains(declaration.ParentDeclaration.DeclarationType)`
	`26`	`+ \|\| IsIgnoringInspectionResultFor(declaration, AnnotationName))`
`26`	`27`	`{`
`27`	`28`	`return false;`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,15 @@ public SelfAssignedDeclarationInspection(RubberduckParserState state)`
`19`	`19`
`20`	`20`	`public override IEnumerable<IInspectionResult> GetInspectionResults()`
`21`	`21`	`{`
`22`		`- return UserDeclarations`
	`22`	`+ return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)`
`23`	`23`	`.Where(declaration => declaration.IsSelfAssigned`
`24`	`24`	`&& declaration.IsTypeSpecified`
`25`	`25`	`&& !SymbolList.ValueTypes.Contains(declaration.AsTypeName)`
`26`		`- && declaration.DeclarationType == DeclarationType.Variable`
`27`	`26`	`&& (declaration.AsTypeDeclaration == null`
`28`	`27`	`\|\| declaration.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)`
`29`	`28`	`&& declaration.ParentScopeDeclaration != null`
`30`	`29`	`&& declaration.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member))`
	`30`	`+ .Where(result => !IsIgnoringInspectionResultFor(result, AnnotationName))`
`31`	`31`	`.Select(issue => new SelfAssignedDeclarationInspectionResult(this, issue));`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,8 @@ public UndeclaredVariableInspection(RubberduckParserState state)`
`18`	`18`
`19`	`19`	`public override IEnumerable<IInspectionResult> GetInspectionResults()`
`20`	`20`	`{`
`21`		`- return UserDeclarations.Where(item => item.IsUndeclared && item.DeclarationType == DeclarationType.Variable)`
	`21`	`+ return State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)`
	`22`	`+ .Where(item => item.IsUndeclared && !IsIgnoringInspectionResultFor(item, AnnotationName))`
`22`	`23`	`.Select(item => new UndeclaredVariableInspectionResult(this, item));`
`23`	`24`	`}`
`24`	`25`	`}`