alligned the load behaviour of the ICustomDeclarationLoader implementations

MDoerner · MDoerner · commit b0b3e9c9d9c6 · 2017-01-05T22:08:49.000+01:00
diff --git a/Rubberduck.Parsing/Symbols/AliasDeclarations.cs b/Rubberduck.Parsing/Symbols/AliasDeclarations.cs
@@ -53,7 +53,14 @@ public IReadOnlyList<Declaration> Load()
 
         private IReadOnlyList<Declaration> AddAliasDeclarations()
         {
-            UpdateAliasFunctionModulesFromReferencedProjects(_state);
+            var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });
+
+            if (WeHaveAlreadyLoadedTheDeclarationsBefore(finder))
+            {
+                return new List<Declaration>();
+            }
+
+            UpdateAliasFunctionModulesFromReferencedProjects(finder);
 
             if (NoReferenceToProjectContainingTheFunctionAliases())
             {
@@ -67,10 +74,8 @@ private IReadOnlyList<Declaration> AddAliasDeclarations()
             return functionAliases;
         }
 
-        private void UpdateAliasFunctionModulesFromReferencedProjects(RubberduckParserState state)
+        private void UpdateAliasFunctionModulesFromReferencedProjects(DeclarationFinder finder)
         {
-            var finder = new DeclarationFinder(state.AllDeclarations, new CommentNode[] {}, new IAnnotation[] {});
-
             var vba = finder.FindProject("VBA");
             if (vba == null)
             {
@@ -86,6 +91,19 @@ private void UpdateAliasFunctionModulesFromReferencedProjects(RubberduckParserSt
         }
 
 
+        private static bool WeHaveAlreadyLoadedTheDeclarationsBefore(DeclarationFinder finder)
+        {
+            return ThereIsAGlobalBuiltInErrVariableDeclaration(finder);
+        }
+
+        private static bool ThereIsAGlobalBuiltInErrVariableDeclaration(DeclarationFinder finder)
+        {
+            return finder.MatchName(Grammar.Tokens.Err).Any(declaration => declaration.IsBuiltIn
+                                                                    && declaration.DeclarationType == DeclarationType.Variable
+                                                                    && declaration.Accessibility == Accessibility.Global);
+        }
+
+
         private bool NoReferenceToProjectContainingTheFunctionAliases()
         {
             return _conversionModule == null;
diff --git a/Rubberduck.Parsing/Symbols/DebugDeclarations.cs b/Rubberduck.Parsing/Symbols/DebugDeclarations.cs
@@ -21,7 +21,7 @@ public IReadOnlyList<Declaration> Load()
         {
             var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });
 
-            if (ThereIsAGlobalBuiltInErrVariableDeclaration(finder))
+            if (WeHaveAlreadyLoadedTheDeclarationsBefore(finder))
             {
                 return new List<Declaration>();
             }
@@ -37,9 +37,14 @@ public IReadOnlyList<Declaration> Load()
             return LoadDebugDeclarations(vba);
         }
 
+        private static bool WeHaveAlreadyLoadedTheDeclarationsBefore(DeclarationFinder finder)
+        {
+            return ThereIsAGlobalBuiltInErrVariableDeclaration(finder);
+        }
+
             private static bool ThereIsAGlobalBuiltInErrVariableDeclaration(DeclarationFinder finder) 
             {
-                return finder.MatchName(Tokens.Err).Any(declaration => declaration.IsBuiltIn
+                return finder.MatchName(Grammar.Tokens.Err).Any(declaration => declaration.IsBuiltIn
                                                                         && declaration.DeclarationType == DeclarationType.Variable
                                                                         && declaration.Accessibility == Accessibility.Global);
             }
diff --git a/Rubberduck.Parsing/Symbols/SpecialFormDeclarations.cs b/Rubberduck.Parsing/Symbols/SpecialFormDeclarations.cs
@@ -10,38 +10,51 @@ namespace Rubberduck.Parsing.Symbols
 {
     public class SpecialFormDeclarations : ICustomDeclarationLoader
     {
-        private readonly DeclarationFinder _finder;
+        private readonly RubberduckParserState _state;
 
         public SpecialFormDeclarations(RubberduckParserState state)
         {
-            _finder = new DeclarationFinder(state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });
+            _state = state;
         }
 
 
         public IReadOnlyList<Declaration> Load()
         {
-            if (ThereIsAGlobalBuiltInErrVariableDeclaration(_finder))
+            var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });
+
+            if (WeHaveAlreadyLoadedTheDeclarationsBefore(finder))
             {
                 return new List<Declaration>();
             }
 
-            var vba = _finder.FindProject("VBA");
+            var vba = finder.FindProject("VBA");
             if (vba == null)
             {
                 // If the VBA project is null, we haven't loaded any COM references;
                 // we're in a unit test and the mock project didn't setup any references.
                 return new List<Declaration>();
             }
 
-            var informationModule = _finder.FindStdModule("Information", vba, true);
-            Debug.Assert(informationModule != null, "We expect the information module to exist in the VBA project.");
+            var informationModule = finder.FindStdModule("Information", vba, true);
+            if (informationModule == null)
+            {
+                //This should not happen under normal circumstances.
+                //Most probably, we are in a test that only addded parts of the VBA project.
+                return new List<Declaration>();
+            }
 
             return LoadSpecialFormDeclarations(informationModule);
         }
 
+
+        private static bool WeHaveAlreadyLoadedTheDeclarationsBefore(DeclarationFinder finder)
+        {
+            return ThereIsAGlobalBuiltInErrVariableDeclaration(finder);
+        }
+
             private static bool ThereIsAGlobalBuiltInErrVariableDeclaration(DeclarationFinder finder)
             {
-                return finder.MatchName(Tokens.Err).Any(declaration => declaration.IsBuiltIn
+                return finder.MatchName(Grammar.Tokens.Err).Any(declaration => declaration.IsBuiltIn
                                                                         && declaration.DeclarationType == DeclarationType.Variable
                                                                         && declaration.Accessibility == Accessibility.Global);
             }

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public IReadOnlyList<Declaration> Load()`
`21`	`21`	`{`
`22`	`22`	`var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });`
`23`	`23`
`24`		`- if (ThereIsAGlobalBuiltInErrVariableDeclaration(finder))`
	`24`	`+ if (WeHaveAlreadyLoadedTheDeclarationsBefore(finder))`
`25`	`25`	`{`
`26`	`26`	`return new List<Declaration>();`
`27`	`27`	`}`
`@@ -37,9 +37,14 @@ public IReadOnlyList<Declaration> Load()`
`37`	`37`	`return LoadDebugDeclarations(vba);`
`38`	`38`	`}`
`39`	`39`
	`40`	`+ private static bool WeHaveAlreadyLoadedTheDeclarationsBefore(DeclarationFinder finder)`
	`41`	`+ {`
	`42`	`+ return ThereIsAGlobalBuiltInErrVariableDeclaration(finder);`
	`43`	`+ }`
	`44`	`+`
`40`	`45`	`private static bool ThereIsAGlobalBuiltInErrVariableDeclaration(DeclarationFinder finder)`
`41`	`46`	`{`
`42`		`- return finder.MatchName(Tokens.Err).Any(declaration => declaration.IsBuiltIn`
	`47`	`+ return finder.MatchName(Grammar.Tokens.Err).Any(declaration => declaration.IsBuiltIn`
`43`	`48`	`&& declaration.DeclarationType == DeclarationType.Variable`
`44`	`49`	`&& declaration.Accessibility == Accessibility.Global);`
`45`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,38 +10,51 @@ namespace Rubberduck.Parsing.Symbols`
`10`	`10`	`{`
`11`	`11`	`public class SpecialFormDeclarations : ICustomDeclarationLoader`
`12`	`12`	`{`
`13`		`- private readonly DeclarationFinder _finder;`
	`13`	`+ private readonly RubberduckParserState _state;`
`14`	`14`
`15`	`15`	`public SpecialFormDeclarations(RubberduckParserState state)`
`16`	`16`	`{`
`17`		`- _finder = new DeclarationFinder(state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });`
	`17`	`+ _state = state;`
`18`	`18`	`}`
`19`	`19`
`20`	`20`
`21`	`21`	`public IReadOnlyList<Declaration> Load()`
`22`	`22`	`{`
`23`		`- if (ThereIsAGlobalBuiltInErrVariableDeclaration(_finder))`
	`23`	`+ var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[] { }, new IAnnotation[] { });`
	`24`	`+`
	`25`	`+ if (WeHaveAlreadyLoadedTheDeclarationsBefore(finder))`
`24`	`26`	`{`
`25`	`27`	`return new List<Declaration>();`
`26`	`28`	`}`
`27`	`29`
`28`		`- var vba = _finder.FindProject("VBA");`
	`30`	`+ var vba = finder.FindProject("VBA");`
`29`	`31`	`if (vba == null)`
`30`	`32`	`{`
`31`	`33`	`// If the VBA project is null, we haven't loaded any COM references;`
`32`	`34`	`// we're in a unit test and the mock project didn't setup any references.`
`33`	`35`	`return new List<Declaration>();`
`34`	`36`	`}`
`35`	`37`
`36`		`- var informationModule = _finder.FindStdModule("Information", vba, true);`
`37`		`- Debug.Assert(informationModule != null, "We expect the information module to exist in the VBA project.");`
	`38`	`+ var informationModule = finder.FindStdModule("Information", vba, true);`
	`39`	`+ if (informationModule == null)`
	`40`	`+ {`
	`41`	`+ //This should not happen under normal circumstances.`
	`42`	`+ //Most probably, we are in a test that only addded parts of the VBA project.`
	`43`	`+ return new List<Declaration>();`
	`44`	`+ }`
`38`	`45`
`39`	`46`	`return LoadSpecialFormDeclarations(informationModule);`
`40`	`47`	`}`
`41`	`48`
	`49`	`+`
	`50`	`+ private static bool WeHaveAlreadyLoadedTheDeclarationsBefore(DeclarationFinder finder)`
	`51`	`+ {`
	`52`	`+ return ThereIsAGlobalBuiltInErrVariableDeclaration(finder);`
	`53`	`+ }`
	`54`	`+`
`42`	`55`	`private static bool ThereIsAGlobalBuiltInErrVariableDeclaration(DeclarationFinder finder)`
`43`	`56`	`{`
`44`		`- return finder.MatchName(Tokens.Err).Any(declaration => declaration.IsBuiltIn`
	`57`	`+ return finder.MatchName(Grammar.Tokens.Err).Any(declaration => declaration.IsBuiltIn`
`45`	`58`	`&& declaration.DeclarationType == DeclarationType.Variable`
`46`	`59`	`&& declaration.Accessibility == Accessibility.Global);`
`47`	`60`	`}`