Merge branch 'next' into next

comintern · web-flow · commit c26d64a9a245 · 2017-01-12T20:57:30.000-06:00
diff --git a/RetailCoder.VBE/Inspections/Abstract/InspectionBase.cs b/RetailCoder.VBE/Inspections/Abstract/InspectionBase.cs
@@ -128,6 +128,18 @@ protected bool IsInspectionDisabled(Declaration declaration, string inspectionNa
                 && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
         }
 
+        protected bool IsInspectionDisabled(IdentifierReference reference, string inspectionName)
+        {
+            if (reference == null)
+            {
+                return false;
+            }
+
+            return reference.Annotations.Any(annotation =>
+                annotation.AnnotationType == AnnotationType.Ignore
+                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
+        }
+
         public int CompareTo(IInspection other)
         {
             return string.Compare(InspectionType + Name, other.InspectionType + other.Name, StringComparison.Ordinal);
diff --git a/RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs b/RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs
@@ -25,12 +25,10 @@ public ImplicitByRefParameterInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var interfaceMembersScope = UserDeclarations.FindInterfaceImplementationMembers().Select(m => m.Scope);
-            var builtinEventHandlers = State.AllDeclarations.FindBuiltInEventHandlers();
+            var builtinEventHandlers = Declarations.FindBuiltInEventHandlers();
 
             var issues = (from item in UserDeclarations
-                where
-                    !IsInspectionDisabled(item, AnnotationName)
-                    && item.DeclarationType == DeclarationType.Parameter
+                where item.DeclarationType == DeclarationType.Parameter
                     // ParamArray parameters do not allow an explicit "ByRef" parameter mechanism.               
                     && !((ParameterDeclaration)item).IsParamArray
                     && !interfaceMembersScope.Contains(item.ParentScope)
@@ -40,7 +38,6 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 select new QualifiedContext<VBAParser.ArgContext>(item.QualifiedName, arg))
                 .Select(issue => new ImplicitByRefParameterInspectionResult(this, issue.Context.unrestrictedIdentifier().GetText(), issue));
 
- 
             return issues;
         }
     }
diff --git a/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs b/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs
@@ -33,11 +33,10 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                         where !IsInspectionDisabled(item, AnnotationName) 
-                               && ProcedureTypes.Contains(item.DeclarationType)
+                         where ProcedureTypes.Contains(item.DeclarationType)
                                && item.Accessibility == Accessibility.Implicit
                          let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)
-                               select new ImplicitPublicMemberInspectionResult(this, context, item);
+                         select new ImplicitPublicMemberInspectionResult(this, context, item);
             return issues;
         }
     }
diff --git a/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs b/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs
@@ -31,9 +31,7 @@ public ImplicitVariantReturnTypeInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                               where !IsInspectionDisabled(item, AnnotationName)
-                                && ProcedureTypes.Contains(item.DeclarationType)
-                                && !item.IsTypeSpecified
+                               where ProcedureTypes.Contains(item.DeclarationType) && !item.IsTypeSpecified
                                let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}
                                select new ImplicitVariantReturnTypeInspectionResult(this, issue.Declaration.IdentifierName, issue.QualifiedContext, item);
             return issues;
diff --git a/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs b/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs
@@ -24,7 +24,6 @@ public MultipleDeclarationsInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = UserDeclarations
-                .Where(item => !IsInspectionDisabled(item, AnnotationName))
                 .Where(item => item.DeclarationType == DeclarationType.Variable
                             || item.DeclarationType == DeclarationType.Constant)
                 .GroupBy(variable => variable.Context.Parent as ParserRuleContext)
diff --git a/RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs
@@ -51,8 +51,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                     if (!stringStrippedLines.Contains(":"))
                     {
                         results.Add(new ObsoleteCallStatementUsageInspectionResult(this,
-                                new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName,
-                                    context.Context as VBAParser.CallStmtContext)));
+                                new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName, context.Context)));
                     }
                 }
             }
diff --git a/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs
@@ -36,13 +36,13 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var declarations = UserDeclarations.ToList();
 
-            var classes = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.ClassModule).ToList();
-            var modules = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.ProceduralModule).ToList();
+            var classes = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule).ToList();
+            var modules = declarations.Where(item => item.DeclarationType == DeclarationType.ProceduralModule).ToList();
 
             var handlers = declarations.Where(item => item.DeclarationType == DeclarationType.Control)
                 .SelectMany(control => declarations.FindEventHandlers(control)).ToList();
 
-            var withEventFields = UserDeclarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents);
+            var withEventFields = declarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents);
             handlers.AddRange(withEventFields.SelectMany(field => declarations.FindEventProcedures(field)));
 
             var forms = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule
@@ -54,11 +54,10 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 handlers.AddRange(forms.SelectMany(form => State.FindFormEventHandlers(form)));
             }
 
-            handlers.AddRange(State.AllDeclarations.FindBuiltInEventHandlers());
+            handlers.AddRange(Declarations.FindBuiltInEventHandlers());
 
             var items = declarations
-                .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules)
-                            && !IsInspectionDisabled(item, AnnotationName)).ToList();
+                .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules)).ToList();
             var issues = items.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, issue.Context, issue.QualifiedName.QualifiedModuleName));
 
             issues = DocumentEventHandlerPrefixes
diff --git a/RetailCoder.VBE/Inspections/Results/UndeclaredVariableInspectionResult.cs b/RetailCoder.VBE/Inspections/Results/UndeclaredVariableInspectionResult.cs
@@ -17,7 +17,7 @@ public UndeclaredVariableInspectionResult(IInspection inspection, Declaration ta
             _quickFixes = new QuickFixBase[]
             {
                 new IntroduceLocalVariableQuickFix(target), 
-                new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.Name), 
+                new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.AnnotationName), 
             };
         }
 
diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs
@@ -28,7 +28,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType
                     && d.IdentifierName == declaration.AsTypeName)
                 && !declaration.IsSelfAssigned
-                && !declaration.References.Any(reference => reference.IsAssignment));
+                && !declaration.References.Any(reference => reference.IsAssignment && !IsInspectionDisabled(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/RetailCoder.VBE/Inspections/UndeclaredVariableInspection.cs b/RetailCoder.VBE/Inspections/UndeclaredVariableInspection.cs
@@ -3,6 +3,7 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Resources;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
 namespace Rubberduck.Inspections
@@ -20,7 +21,7 @@ public UndeclaredVariableInspection(RubberduckParserState state)
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
-            return UserDeclarations.Where(item => item.IsUndeclared)
+            return UserDeclarations.Where(item => item.IsUndeclared && item.DeclarationType == DeclarationType.Variable)
                 .Select(item => new UndeclaredVariableInspectionResult(this, item));
         }
     }
diff --git a/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs b/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs
@@ -52,7 +52,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             return declarations.SelectMany(declaration => declaration.References
                 .Where(item => _tokens.Contains(item.IdentifierName) &&
-                               !IsInspectionDisabled(item.QualifiedModuleName.Component, item.Selection.StartLine))
+                               !IsInspectionDisabled(item, AnnotationName))
                 .Select(item => new UntypedFunctionUsageInspectionResult(this, item)));
         }
     }
diff --git a/RetailCoder.VBE/Properties/AssemblyInfo.cs b/RetailCoder.VBE/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.11.*")]
-[assembly: AssemblyFileVersion("2.0.11.0")]
+[assembly: AssemblyVersion("2.0.12.*")]
+[assembly: AssemblyFileVersion("2.0.12.0")]
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -149,7 +149,7 @@
     <Compile Include="Symbols\DebugDeclarations.cs" />
     <Compile Include="Symbols\AliasDeclarations.cs" />
     <Compile Include="Symbols\FormEventDeclarations.cs" />
-    <Compile Include="Symbols\ICustomDelarationLoader.cs" />
+    <Compile Include="Symbols\ICustomDeclarationLoader.cs" />
     <Compile Include="Symbols\Identifier.cs" />
     <Compile Include="Binding\IBindingContext.cs" />
     <Compile Include="Binding\IBoundExpression.cs" />
diff --git a/Rubberduck.Parsing/Symbols/ICustomDeclarationLoader.cs b/Rubberduck.Parsing/Symbols/ICustomDeclarationLoader.cs
diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs
@@ -209,7 +209,7 @@ private void ParseAll(object requestor, CancellationTokenSource token)
                 }
 
                 State.SetStatusAndFireStateChanged(requestor, State.Status);
-                return;
+                //return; // returning here leaves state in 'ResolvedDeclarations' when a module is removed, which disables refresh
             }
             
             foreach (var component in toParse)
diff --git a/RubberduckTests/Grammar/VBAParserTests.cs b/RubberduckTests/Grammar/VBAParserTests.cs
@@ -1543,6 +1543,36 @@ End Sub
             AssertTree(parseResult.Item1, parseResult.Item2, "//argumentExpression", matches => matches.Count == 2);
         }
 
+        [TestMethod]
+        public void TestCaseIsEqExpressionWithLiteral()
+        {
+            const string code = @"
+Sub Test(ByVal foo As Integer)
+    Select Case foo
+        Case Is = 42
+            Exit Sub
+    End Select
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//rangeClause", matches => matches.Count == 1);
+        }
+
+        [TestMethod]
+        public void TestCaseIsEqExpressionWithEnum()
+        {
+            const string code = @"
+Sub Test(ByVal foo As vbext_ComponentType)
+    Select Case foo
+        Case Is = vbext_ct_StdModule
+            Exit Sub
+    End Select
+End Sub
+";
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//rangeClause", matches => matches.Count == 1);
+        }
+
         private Tuple<VBAParser, ParserRuleContext> Parse(string code)
         {
             var stream = new AntlrInputStream(code);

Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,10 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)`
`33`	`33`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`34`	`34`	`{`
`35`	`35`	`var issues = from item in UserDeclarations`
`36`		`- where !IsInspectionDisabled(item, AnnotationName)`
`37`		`- && ProcedureTypes.Contains(item.DeclarationType)`
	`36`	`+ where ProcedureTypes.Contains(item.DeclarationType)`
`38`	`37`	`&& item.Accessibility == Accessibility.Implicit`
`39`	`38`	`let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)`
`40`		`- select new ImplicitPublicMemberInspectionResult(this, context, item);`
	`39`	`+ select new ImplicitPublicMemberInspectionResult(this, context, item);`
`41`	`40`	`return issues;`
`42`	`41`	`}`
`43`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,6 @@ public MultipleDeclarationsInspection(RubberduckParserState state)`
`24`	`24`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`25`	`25`	`{`
`26`	`26`	`var issues = UserDeclarations`
`27`		`- .Where(item => !IsInspectionDisabled(item, AnnotationName))`
`28`	`27`	`.Where(item => item.DeclarationType == DeclarationType.Variable`
`29`	`28`	`\|\| item.DeclarationType == DeclarationType.Constant)`
`30`	`29`	`.GroupBy(variable => variable.Context.Parent as ParserRuleContext)`
Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`51`	`51`	`if (!stringStrippedLines.Contains(":"))`
`52`	`52`	`{`
`53`	`53`	`results.Add(new ObsoleteCallStatementUsageInspectionResult(this,`
`54`		`- new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName,`
`55`		`- context.Context as VBAParser.CallStmtContext)));`
	`54`	`+ new QualifiedContext<VBAParser.CallStmtContext>(context.ModuleName, context.Context)));`
`56`	`55`	`}`
`57`	`56`	`}`
`58`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public UndeclaredVariableInspectionResult(IInspection inspection, Declaration ta`
`17`	`17`	`_quickFixes = new QuickFixBase[]`
`18`	`18`	`{`
`19`	`19`	`new IntroduceLocalVariableQuickFix(target),`
`20`		`- new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.Name),`
	`20`	`+ new IgnoreOnceQuickFix(target.Context, target.QualifiedSelection, inspection.AnnotationName),`
`21`	`21`	`};`
`22`	`22`	`}`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using Rubberduck.Inspections.Abstract;`
`4`	`4`	`using Rubberduck.Inspections.Resources;`
`5`	`5`	`using Rubberduck.Inspections.Results;`
	`6`	`+using Rubberduck.Parsing.Symbols;`
`6`	`7`	`using Rubberduck.Parsing.VBA;`
`7`	`8`
`8`	`9`	`namespace Rubberduck.Inspections`
`@@ -20,7 +21,7 @@ public UndeclaredVariableInspection(RubberduckParserState state)`
`20`	`21`
`21`	`22`	`public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`22`	`23`	`{`
`23`		`- return UserDeclarations.Where(item => item.IsUndeclared)`
	`24`	`+ return UserDeclarations.Where(item => item.IsUndeclared && item.DeclarationType == DeclarationType.Variable)`
`24`	`25`	`.Select(item => new UndeclaredVariableInspectionResult(this, item));`
`25`	`26`	`}`
`26`	`27`	`}`