Made FindModuleAnnotations independent of the VBE

The DeclarationSymbolsListener previously relied on the VBE to determine the declarations section, in which we allow the module annotations to be. Unfortunately, it is often rather counterintuitive how the VBE determines this section. Thus, this PR introduces our own consistent logic.

Author: MDoerner

Rubberduck.Parsing/Symbols/DeclarationSymbolsListener.cs

@@ -21,7 +21,7 @@ public class DeclarationSymbolsListener : VBAParserBaseListener
         private Declaration _currentScopeDeclaration;
         private Declaration _parentDeclaration;
 
-        private readonly IEnumerable<IAnnotation> _annotations;
+        private readonly ICollection<IAnnotation> _annotations;
         private readonly IDictionary<(string scopeIdentifier, DeclarationType scopeType), Attributes> _attributes;
         private readonly IDictionary<(string scopeIdentifier, DeclarationType scopeType), ParserRuleContext> _membersAllowingAttributes;
 
@@ -40,7 +40,7 @@ public DeclarationSymbolsListener(
         {
             _state = state;
             _qualifiedModuleName = qualifiedModuleName;
-            _annotations = annotations;
+            _annotations = annotations.ToList();
             _attributes = attributes;
             _membersAllowingAttributes = membersAllowingAttributes;
 
@@ -61,7 +61,7 @@ public DeclarationSymbolsListener(
                     projectDeclaration,
                     _qualifiedModuleName.ComponentName,
                     true,
-                    FindAnnotations(),
+                    FindModuleAnnotations(),
                     moduleAttributes);
             }
             else
@@ -73,7 +73,7 @@ public DeclarationSymbolsListener(
                     projectDeclaration,
                     _qualifiedModuleName.ComponentName,
                     true,
-                    FindAnnotations(),
+                    FindModuleAnnotations(),
                     moduleAttributes,
                     hasDefaultInstanceVariable: hasDefaultInstanceVariable);
             }
@@ -88,25 +88,72 @@ public DeclarationSymbolsListener(
             }
         }
 
-        private IEnumerable<IAnnotation> FindAnnotations()
+        private IEnumerable<IAnnotation> FindModuleAnnotations()
         {
             if (_annotations == null)
             {
                 return null;
             }
 
-            int lastDeclarationsSectionLine;
-            var component = _state.ProjectsProvider.Component(_qualifiedModuleName);
-            using (var codeModule = component.CodeModule)
+            var lastDeclarationsSectionLine = LastDeclarationsSectionLine();
+
+            //There is no module body.
+            if (lastDeclarationsSectionLine == null)
             {
-                lastDeclarationsSectionLine = codeModule.CountOfDeclarationLines;
+                return _annotations;
             }
 
-            var annotations = _annotations.Where(annotation => annotation.QualifiedSelection.QualifiedName.Equals(_qualifiedModuleName)
-                && annotation.QualifiedSelection.Selection.EndLine <= lastDeclarationsSectionLine);
+            var lastPossibleModuleAnnotationLine = lastDeclarationsSectionLine.Value;
+            var annotations = _annotations.Where(annotation => annotation.QualifiedSelection.Selection.EndLine <= lastPossibleModuleAnnotationLine);
             return annotations.ToList();
         }
 
+        private int? LastDeclarationsSectionLine()
+        {
+            var firstModuleBodyElementLine = FirstModuleBodyElementLine();
+
+            if (firstModuleBodyElementLine == null)
+            {
+                return null;
+            }
+
+            //The VBE uses 1-based lines.
+            for (var currentLine = firstModuleBodyElementLine.Value - 1; currentLine >= 1; currentLine--)
+            {
+                if (_annotations.Any(annotation => annotation.QualifiedSelection.Selection.StartLine <= currentLine
+                                                   && annotation.QualifiedSelection.Selection.EndLine >=
+                                                   currentLine))
+                {
+                    continue;
+                }
+
+                return currentLine;
+            }
+
+            //There is no declaration section.
+            return 0;
+        }
+
+        private int? FirstModuleBodyElementLine()
+        {
+            var moduleTrees = _state.ParseTrees.Where(kvp => kvp.Key.Equals(_qualifiedModuleName)).ToList();
+            if (!moduleTrees.Any())
+            {
+                return null;
+            }
+
+            var startContext = (ParserRuleContext) moduleTrees.First().Value;
+            var moduleBody = startContext.GetDescendent<VBAParser.ModuleBodyContext>();
+
+            var moduleBodyElements = moduleBody.moduleBodyElement();
+            if (!moduleBodyElements.Any())
+            {
+                return null;
+            }
+
+            return moduleBodyElements.Select(context => context.start.Line).Min();
+        }
+
         private IEnumerable<IAnnotation> FindMemberAnnotations(int firstMemberLine)
         {
             if (_annotations == null)

RubberduckTests/Annotations/DeclarationsListenerAnnotationsTests.cs

@@ -148,8 +148,7 @@ Public Function Bar() As Variant
         public void AnnotationsRightAboveFirstMemberAreNotModuleAnnotations_WithoutDeclarationOnTop()
         {
             const string inputCode =
-                @"
-'@TestMethod
+                @"'@TestMethod
 '@Enumerator 17, _
 12 _
 @DefaultMember
@@ -226,5 +225,29 @@ Public Function Bar() As Variant
                 Assert.AreEqual(expectedAnnotationCount, actualAnnotationCount);
             }
         }
+
+        [Test]
+        public void AllAnnotationsAreModuleAnnotationsIfThereIsNoBody()
+        {
+            const string inputCode =
+                @"
+'@TestModule
+'@Folder(""Test"")
+'SomeComment
+'@Enumerator 17, _
+12 _
+@DefaultMember
+";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var moduleDeclaration = state.DeclarationFinder.UserDeclarations(DeclarationType.ProceduralModule).Single();
+
+                var expectedAnnotationCount = 4;
+                var actualAnnotationCount = moduleDeclaration.Annotations.Count();
+
+                Assert.AreEqual(expectedAnnotationCount, actualAnnotationCount);
+            }
+        }
     }
 }