added 'AllUserDeclarations' member to parser state, to return declarations where !IsBuiltIn; replaced 'AllDeclarations' and removed redundant where filters where appropriate.

retailcoder · retailcoder · commit e07acaef89b1 · 2015-12-29T02:12:07.000-05:00
diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs
@@ -10,6 +10,7 @@
 using Rubberduck.Common;
 using Rubberduck.Inspections;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.VBA;
 using Rubberduck.Settings;
 using Rubberduck.SmartIndenter;
 using Rubberduck.UI;
@@ -141,7 +142,7 @@ private void _stateBar_Refresh(object sender, EventArgs e)
             _parser.State.OnParseRequested();
         }
 
-        private void Parser_StateChanged(object sender, EventArgs e)
+        private void Parser_StateChanged(object sender, ParserStateEventArgs e)
         {
             _appMenus.EvaluateCanExecute(_parser.State);
         }
diff --git a/RetailCoder.VBE/Inspections/AssignedByValParameterInspection.cs b/RetailCoder.VBE/Inspections/AssignedByValParameterInspection.cs
@@ -27,8 +27,7 @@ public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckPars
         {
             var name = AnnotationName;
             var assignedByValParameters =
-                state.AllDeclarations.Where(declaration => !declaration.IsInspectionDisabled(name)
-                    && !declaration.IsBuiltIn 
+                state.AllUserDeclarations.Where(declaration => !declaration.IsInspectionDisabled(name)
                     && declaration.DeclarationType == DeclarationType.Parameter
                     && ((VBAParser.ArgContext)declaration.Context).BYVAL() != null
                     && declaration.References.Any(reference => reference.IsAssignment));
diff --git a/RetailCoder.VBE/Inspections/ConstantNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ConstantNotUsedInspection.cs
@@ -21,10 +21,8 @@ public ConstantNotUsedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var results = state.AllDeclarations.Where(declaration =>
-                !declaration.IsBuiltIn 
-                && declaration.DeclarationType == DeclarationType.Constant
-                && !declaration.References.Any());
+            var results = state.AllUserDeclarations.Where(declaration =>
+                    declaration.DeclarationType == DeclarationType.Constant && !declaration.References.Any());
 
             return results.Select(issue => 
                 new IdentifierNotUsedInspectionResult(this, issue, ((dynamic)issue.Context).ambiguousIdentifier(), issue.QualifiedName.QualifiedModuleName)).Cast<CodeInspectionResultBase>();
diff --git a/RetailCoder.VBE/Inspections/DefaultProjectNameInspection.cs b/RetailCoder.VBE/Inspections/DefaultProjectNameInspection.cs
@@ -25,9 +25,8 @@ public DefaultProjectNameInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = state.AllDeclarations
-                            .Where(declaration => !declaration.IsBuiltIn 
-                                                && declaration.DeclarationType == DeclarationType.Project
+            var issues = state.AllUserDeclarations
+                            .Where(declaration => declaration.DeclarationType == DeclarationType.Project
                                                 && declaration.IdentifierName.StartsWith("VBAProject"))
                             .Select(issue => new DefaultProjectNameInspectionResult(this, issue, state, _wrapperFactory))
                             .ToList();
diff --git a/RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs b/RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs
@@ -26,14 +26,13 @@ public ImplicitByRefParameterInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var declarations = state.AllDeclarations.ToList();
+            var declarations = state.AllUserDeclarations.ToList();
 
             var interfaceMembers = declarations.FindInterfaceImplementationMembers();
 
             var issues = (from item in declarations
                 where !item.IsInspectionDisabled(AnnotationName)
                     && item.DeclarationType == DeclarationType.Parameter
-                    && !item.IsBuiltIn
                     && !interfaceMembers.Select(m => m.Scope).Contains(item.ParentScope)
                 let arg = item.Context as VBAParser.ArgContext
                 where arg != null && arg.BYREF() == null && arg.BYVAL() == null
diff --git a/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs b/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs
@@ -34,9 +34,8 @@ public ImplicitPublicMemberInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = from item in state.AllDeclarations
+            var issues = from item in state.AllUserDeclarations
                          where !item.IsInspectionDisabled(AnnotationName) 
-                               && !item.IsBuiltIn
                                && ProcedureTypes.Contains(item.DeclarationType)
                                && item.Accessibility == Accessibility.Implicit
                          let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)
diff --git a/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs b/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs
@@ -32,9 +32,8 @@ public ImplicitVariantReturnTypeInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = from item in state.AllDeclarations
+            var issues = from item in state.AllUserDeclarations
                                where !item.IsInspectionDisabled(AnnotationName)
-                                && !item.IsBuiltIn
                                 && ProcedureTypes.Contains(item.DeclarationType)
                                 && !item.IsTypeSpecified()
                                let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}
diff --git a/RetailCoder.VBE/Inspections/Inspector.cs b/RetailCoder.VBE/Inspections/Inspector.cs
@@ -51,7 +51,7 @@ private void UpdateInspectionSeverity()
 
         public async Task<IList<ICodeInspectionResult>> FindIssuesAsync(RubberduckParserState state, CancellationToken token)
         {
-            if (state == null || !state.AllDeclarations.Any())
+            if (state == null || !state.AllUserDeclarations.Any())
             {
                 return new ICodeInspectionResult[]{};
             }
diff --git a/RetailCoder.VBE/Inspections/MultilineParameterInspection.cs b/RetailCoder.VBE/Inspections/MultilineParameterInspection.cs
@@ -22,7 +22,7 @@ public MultilineParameterInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var multilineParameters = from p in state.AllDeclarations
+            var multilineParameters = from p in state.AllUserDeclarations
                 .Where(item => item.DeclarationType == DeclarationType.Parameter)
                 where p.Context.GetSelection().LineCount > 1
                 select p;
diff --git a/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs b/RetailCoder.VBE/Inspections/MultipleDeclarationsInspection.cs
@@ -10,7 +10,6 @@ namespace Rubberduck.Inspections
 {
     public class MultipleDeclarationsInspection : IInspection
     {
-
         public MultipleDeclarationsInspection()
         {
             Severity = CodeInspectionSeverity.Warning;
@@ -26,8 +25,8 @@ public MultipleDeclarationsInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = state.AllDeclarations
-                .Where(item => !item.IsInspectionDisabled(AnnotationName) && !item.IsBuiltIn)
+            var issues = state.AllUserDeclarations
+                .Where(item => !item.IsInspectionDisabled(AnnotationName))
                 .Where(item => item.DeclarationType == DeclarationType.Variable
                             || item.DeclarationType == DeclarationType.Constant)
                 .GroupBy(variable => variable.Context.Parent as ParserRuleContext)
diff --git a/RetailCoder.VBE/Inspections/NonReturningFunctionInspection.cs b/RetailCoder.VBE/Inspections/NonReturningFunctionInspection.cs
@@ -30,13 +30,13 @@ public NonReturningFunctionInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var declarations = state.AllDeclarations.ToList();
+            var declarations = state.AllUserDeclarations.ToList();
 
             var interfaceMembers = declarations.FindInterfaceMembers();
             var interfaceImplementationMembers = declarations.FindInterfaceImplementationMembers();
 
             var functions = declarations
-                .Where(declaration => !declaration.IsBuiltIn && ReturningMemberTypes.Contains(declaration.DeclarationType)
+                .Where(declaration => ReturningMemberTypes.Contains(declaration.DeclarationType)
                     && !interfaceMembers.Contains(declaration)).ToList();
 
             var issues = functions
diff --git a/RetailCoder.VBE/Inspections/ObsoleteGlobalInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteGlobalInspection.cs
@@ -23,9 +23,8 @@ public ObsoleteGlobalInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = from item in state.AllDeclarations
-                         where !item.IsBuiltIn && item.Accessibility == Accessibility.Global
-                         && item.Context != null
+            var issues = from item in state.AllUserDeclarations
+                         where item.Accessibility == Accessibility.Global && item.Context != null
                          select new ObsoleteGlobalInspectionResult(this, Description, new QualifiedContext<ParserRuleContext>(item.QualifiedName.QualifiedModuleName, item.Context));
 
             return issues;
diff --git a/RetailCoder.VBE/Inspections/ObsoleteTypeHintInspection.cs b/RetailCoder.VBE/Inspections/ObsoleteTypeHintInspection.cs
@@ -21,13 +21,13 @@ public ObsoleteTypeHintInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var results = state.AllDeclarations.ToList();
+            var results = state.AllUserDeclarations.ToList();
 
             var declarations = from item in results
-                where !item.IsBuiltIn && item.HasTypeHint()
+                where item.HasTypeHint()
                 select new ObsoleteTypeHintInspectionResult(this, string.Format(Description, RubberduckUI.Inspections_DeclarationOf + item.DeclarationType.ToString().ToLower(), item.IdentifierName), new QualifiedContext(item.QualifiedName, item.Context), item);
 
-            var references = from item in results.Where(item => !item.IsBuiltIn).SelectMany(d => d.References)
+            var references = from item in results.SelectMany(d => d.References)
                 where item.HasTypeHint()
                 select new ObsoleteTypeHintInspectionResult(this, string.Format(Description, RubberduckUI.Inspections_UsageOf + item.Declaration.DeclarationType.ToString().ToLower(), item.IdentifierName), new QualifiedContext(item.QualifiedModuleName, item.Context), item.Declaration);
 
diff --git a/RetailCoder.VBE/Inspections/OptionBaseInspection.cs b/RetailCoder.VBE/Inspections/OptionBaseInspection.cs
@@ -28,9 +28,8 @@ public OptionBaseInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var options = state.AllDeclarations
+            var options = state.AllUserDeclarations
                 .Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)
-                                      && !declaration.IsBuiltIn
                                       && declaration.DeclarationType == DeclarationType.ModuleOption
                                       && declaration.Context is VBAParser.OptionBaseStmtContext)
                 .ToList();
diff --git a/RetailCoder.VBE/Inspections/OptionExplicitInspection.cs b/RetailCoder.VBE/Inspections/OptionExplicitInspection.cs
@@ -28,16 +28,15 @@ public OptionExplicitInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var results = state.AllDeclarations.ToList();
+            var results = state.AllUserDeclarations.ToList();
 
             var options = results
-                .Where(declaration => !declaration.IsBuiltIn 
-                                      && declaration.DeclarationType == DeclarationType.ModuleOption
+                .Where(declaration => declaration.DeclarationType == DeclarationType.ModuleOption
                                       && declaration.Context is VBAParser.OptionExplicitStmtContext)
                 .ToList();
 
             var modules = results
-                .Where(declaration => !declaration.IsBuiltIn && ModuleTypes.Contains(declaration.DeclarationType));
+                .Where(declaration => ModuleTypes.Contains(declaration.DeclarationType));
 
             var issues = modules.Where(module => !options.Select(option => option.Scope).Contains(module.Scope))
                 .Select(issue => new OptionExplicitInspectionResult(this, issue.QualifiedName.QualifiedModuleName));
diff --git a/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs
@@ -16,11 +16,13 @@ namespace Rubberduck.Inspections
     public class ParameterNotUsedInspection : IInspection
     {
         private readonly VBE _vbe;
+        private readonly IMessageBox _messageBox;
         private readonly ICodePaneWrapperFactory _wrapperFactory;
 
-        public ParameterNotUsedInspection(VBE vbe)
+        public ParameterNotUsedInspection(VBE vbe, IMessageBox messageBox)
         {
             _vbe = vbe; // todo: remove this dependency
+            _messageBox = messageBox;
             _wrapperFactory = new CodePaneWrapperFactory();
             Severity = CodeInspectionSeverity.Warning;
         }
@@ -48,7 +50,7 @@ public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckPars
             var quickFixRefactoring =
                 new RemoveParametersRefactoring(
                     new RemoveParametersPresenterFactory(editor, 
-                        new RemoveParametersDialog(), state, new MessageBox()), editor);
+                        new RemoveParametersDialog(), state, _messageBox), editor);
 
             var issues = from issue in unused.Where(parameter => !IsInterfaceMemberParameter(parameter, interfaceMemberScopes))
                          let isInterfaceImplementationMember = IsInterfaceMemberImplementationParameter(issue, interfaceImplementationMemberScopes)
diff --git a/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ProcedureNotUsedInspection.cs
@@ -25,19 +25,18 @@ public ProcedureNotUsedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var declarations = state.AllDeclarations.ToList();
+            var declarations = state.AllUserDeclarations.ToList();
 
-            var classes = declarations.Where(item => !item.IsBuiltIn && item.DeclarationType == DeclarationType.Class).ToList();
-            var modules = declarations.Where(item => !item.IsBuiltIn && item.DeclarationType == DeclarationType.Module).ToList();
+            var classes = declarations.Where(item => item.DeclarationType == DeclarationType.Class).ToList();
+            var modules = declarations.Where(item => item.DeclarationType == DeclarationType.Module).ToList();
 
-            var handlers = declarations.Where(item => !item.IsBuiltIn && item.DeclarationType == DeclarationType.Control)
+            var handlers = declarations.Where(item => item.DeclarationType == DeclarationType.Control)
                 .SelectMany(control => declarations.FindEventHandlers(control)).ToList();
 
-            var withEventFields = declarations.Where(item => !item.IsBuiltIn && 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.IsBuiltIn && item.DeclarationType == DeclarationType.Class
+            var forms = declarations.Where(item => item.DeclarationType == DeclarationType.Class
                         && item.QualifiedName.QualifiedModuleName.Component.Type == vbext_ComponentType.vbext_ct_MSForm)
                 .ToList();
 
@@ -47,7 +46,7 @@ public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckPars
             }
 
             var issues = declarations
-                .Where(item => !item.IsBuiltIn && !IsIgnoredDeclaration(declarations, item, handlers, classes, modules))
+                .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules))
                 .Select(issue => new IdentifierNotUsedInspectionResult(this, issue, issue.Context, issue.QualifiedName.QualifiedModuleName));
 
             issues = DocumentNames.DocumentEventHandlerPrefixes.Aggregate(issues, (current, item) => current.Where(issue => !issue.Name.Contains("'" + item)));
diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs
@@ -20,8 +20,8 @@ public UnassignedVariableUsageInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState parseResult)
         {
-            var usages = parseResult.AllDeclarations.Where(declaration => !declaration.IsBuiltIn 
-                && declaration.DeclarationType == DeclarationType.Variable
+            var usages = parseResult.AllUserDeclarations.Where(declaration => 
+                declaration.DeclarationType == DeclarationType.Variable
                 && !declaration.References.Any(reference => reference.IsAssignment))
                 .SelectMany(declaration => declaration.References);
 
diff --git a/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs b/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs
@@ -26,12 +26,10 @@ public UseMeaningfulNameInspection(IMessageBox messageBox)
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = state.AllDeclarations
-                            .Where(declaration => !declaration.IsBuiltIn &&
-                                                  (declaration.IdentifierName.Length < 3 ||
-                                                   char.IsDigit(declaration.IdentifierName.Last()) ||
-                                                   !declaration.IdentifierName.Any(c => new[] {'a', 'e', 'i', 'o', 'u', 'y'}.Contains(c))
-                                                  ))
+            var issues = state.AllUserDeclarations
+                            .Where(declaration => declaration.IdentifierName.Length < 3 ||
+                                                  char.IsDigit(declaration.IdentifierName.Last()) ||
+                                                  !declaration.IdentifierName.Any(c => new[] {'a', 'e', 'i', 'o', 'u', 'y'}.Contains(c)))
                             .Select(issue => new UseMeaningfulNameInspectionResult(this, issue, state, _wrapperFactory, _messageBox))
                             .ToList();
 
diff --git a/RetailCoder.VBE/Inspections/VariableNotAssignedInspection.cs b/RetailCoder.VBE/Inspections/VariableNotAssignedInspection.cs
@@ -21,7 +21,7 @@ public VariableNotAssignedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var items = state.AllDeclarations.ToList();
+            var items = state.AllUserDeclarations.ToList();
 
             // ignore arrays. todo: ArrayIndicesNotAccessedInspection
             var arrays = items.Where(declaration =>
@@ -30,7 +30,6 @@ public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckPars
 
             var declarations = items.Where(declaration =>
                 declaration.DeclarationType == DeclarationType.Variable
-                && !declaration.IsBuiltIn 
                 && !declaration.IsWithEvents
                 && !arrays.Contains(declaration)
                 && !items.Any(item => 
diff --git a/RetailCoder.VBE/Inspections/VariableNotUsedInspection.cs b/RetailCoder.VBE/Inspections/VariableNotUsedInspection.cs
@@ -21,9 +21,8 @@ public VariableNotUsedInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var declarations = state.AllDeclarations.Where(declaration =>
-                !declaration.IsBuiltIn 
-                && !declaration.IsWithEvents
+            var declarations = state.AllUserDeclarations.Where(declaration =>
+                !declaration.IsWithEvents
                 && declaration.DeclarationType == DeclarationType.Variable
                 && declaration.References.All(reference => reference.IsAssignment));
 
diff --git a/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspection.cs b/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspection.cs
@@ -21,7 +21,7 @@ public VariableTypeNotDeclaredInspection()
 
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)
         {
-            var issues = from item in state.AllDeclarations.Where(item => !item.IsBuiltIn)
+            var issues = from item in state.AllUserDeclarations
                          where (item.DeclarationType == DeclarationType.Variable
                             || item.DeclarationType == DeclarationType.Constant
                             || item.DeclarationType == DeclarationType.Parameter)
diff --git a/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs b/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs
diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs
diff --git a/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerViewModel.cs b/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerViewModel.cs
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/ParserStateCommandBar.cs b/RetailCoder.VBE/UI/Command/MenuItems/ParserStateCommandBar.cs
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`using Rubberduck.Common;`
`11`	`11`	`using Rubberduck.Inspections;`
`12`	`12`	`using Rubberduck.Parsing;`
	`13`	`+using Rubberduck.Parsing.VBA;`
`13`	`14`	`using Rubberduck.Settings;`
`14`	`15`	`using Rubberduck.SmartIndenter;`
`15`	`16`	`using Rubberduck.UI;`
`@@ -141,7 +142,7 @@ private void _stateBar_Refresh(object sender, EventArgs e)`
`141`	`142`	`_parser.State.OnParseRequested();`
`142`	`143`	`}`
`143`	`144`
`144`		`- private void Parser_StateChanged(object sender, EventArgs e)`
	`145`	`+ private void Parser_StateChanged(object sender, ParserStateEventArgs e)`
`145`	`146`	`{`
`146`	`147`	`_appMenus.EvaluateCanExecute(_parser.State);`
`147`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ private void UpdateInspectionSeverity()`
`51`	`51`
`52`	`52`	`public async Task<IList<ICodeInspectionResult>> FindIssuesAsync(RubberduckParserState state, CancellationToken token)`
`53`	`53`	`{`
`54`		`- if (state == null \|\| !state.AllDeclarations.Any())`
	`54`	`+ if (state == null \|\| !state.AllUserDeclarations.Any())`
`55`	`55`	`{`
`56`	`56`	`return new ICodeInspectionResult[]{};`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public MultilineParameterInspection()`
`22`	`22`
`23`	`23`	`public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)`
`24`	`24`	`{`
`25`		`- var multilineParameters = from p in state.AllDeclarations`
	`25`	`+ var multilineParameters = from p in state.AllUserDeclarations`
`26`	`26`	`.Where(item => item.DeclarationType == DeclarationType.Parameter)`
`27`	`27`	`where p.Context.GetSelection().LineCount > 1`
`28`	`28`	`select p;`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ namespace Rubberduck.Inspections`
`10`	`10`	`{`
`11`	`11`	`public class MultipleDeclarationsInspection : IInspection`
`12`	`12`	`{`
`13`		`-`
`14`	`13`	`public MultipleDeclarationsInspection()`
`15`	`14`	`{`
`16`	`15`	`Severity = CodeInspectionSeverity.Warning;`
`@@ -26,8 +25,8 @@ public MultipleDeclarationsInspection()`
`26`	`25`
`27`	`26`	`public IEnumerable<CodeInspectionResultBase> GetInspectionResults(RubberduckParserState state)`
`28`	`27`	`{`
`29`		`- var issues = state.AllDeclarations`
`30`		`- .Where(item => !item.IsInspectionDisabled(AnnotationName) && !item.IsBuiltIn)`
	`28`	`+ var issues = state.AllUserDeclarations`
	`29`	`+ .Where(item => !item.IsInspectionDisabled(AnnotationName))`
`31`	`30`	`.Where(item => item.DeclarationType == DeclarationType.Variable`
`32`	`31`	`\|\| item.DeclarationType == DeclarationType.Constant)`
`33`	`32`	`.GroupBy(variable => variable.Context.Parent as ParserRuleContext)`