Merge pull request #1054 from retailcoder/CodeExplorer

retailcoder · retailcoder · commit cfa0ab5cbb22 · 2016-02-10T02:15:43.000-05:00
Grammar &amp; Resolver fixes
diff --git a/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs b/RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs
@@ -12,7 +12,7 @@ public sealed class UntypedFunctionUsageInspection : InspectionBase
         public UntypedFunctionUsageInspection(RubberduckParserState state)
             : base(state)
         {
-            Severity = CodeInspectionSeverity.Hint;
+            Severity = CodeInspectionSeverity.Warning;
         }
 
         public override string Description { get { return RubberduckUI.UntypedFunctionUsage_; } }
diff --git a/RetailCoder.VBE/Root/RubberduckModule.cs b/RetailCoder.VBE/Root/RubberduckModule.cs
@@ -132,7 +132,7 @@ private void ApplyAbstractFactoryConvention(IEnumerable<Assembly> assemblies)
                 .Configure(binding => binding.InSingletonScope()));
         }
 
-        // note: IInspection implementations are discovered in the Rubberduck assembly via reflection.
+        // note: InspectionBase implementations are discovered in the Rubberduck assembly via reflection.
         private void BindCodeInspectionTypes()
         {
             var inspections = Assembly.GetExecutingAssembly()
diff --git a/Rubberduck.Parsing/Grammar/VBA.g4 b/Rubberduck.Parsing/Grammar/VBA.g4
@@ -310,7 +310,7 @@ functionStmt :
 	END_FUNCTION
 ;
 
-getStmt : GET WS valueStmt WS? ',' WS? valueStmt? WS? ',' WS? valueStmt;
+getStmt : GET WS fileNumber WS? ',' WS? valueStmt? WS? ',' WS? valueStmt;
 
 goSubStmt : GOSUB WS valueStmt;
 
@@ -359,18 +359,18 @@ macroConstStmt : MACRO_CONST WS? ambiguousIdentifier WS? EQ WS? valueStmt;
 macroIfThenElseStmt : macroIfBlockStmt macroElseIfBlockStmt* macroElseBlockStmt? MACRO_END_IF;
 
 macroIfBlockStmt : 
-	MACRO_IF WS? ifConditionStmt WS THEN NEWLINE+ 
-	(moduleBody NEWLINE+)?
+	MACRO_IF WS? ifConditionStmt WS THEN NEWLINE*
+	((moduleDeclarationsElement | moduleBody | block) NEWLINE*)*
 ;
 
 macroElseIfBlockStmt : 
-	MACRO_ELSEIF WS? ifConditionStmt WS THEN NEWLINE+ 
-	(moduleBody NEWLINE+)?
+	MACRO_ELSEIF WS? ifConditionStmt WS THEN NEWLINE* 
+	((moduleDeclarationsElement | moduleBody | block) NEWLINE*)*
 ;
 
 macroElseBlockStmt : 
-	MACRO_ELSE NEWLINE+ 
-	(moduleBody NEWLINE+)?
+	MACRO_ELSE NEWLINE* 
+	((moduleDeclarationsElement | moduleBody | block) NEWLINE*)*
 ;
 
 midStmt : MID WS? LPAREN WS? argsCall WS? RPAREN;
@@ -447,7 +447,7 @@ savepictureStmt : SAVEPICTURE WS valueStmt WS? ',' WS? valueStmt;
 
 saveSettingStmt : SAVESETTING WS valueStmt WS? ',' WS? valueStmt WS? ',' WS? valueStmt WS? ',' WS? valueStmt;
 
-seekStmt : SEEK WS valueStmt WS? ',' WS? valueStmt;
+seekStmt : SEEK WS fileNumber WS? ',' WS? valueStmt;
 
 selectCaseStmt : 
 	SELECT WS CASE WS valueStmt NEWLINE+ 
@@ -500,7 +500,7 @@ typeOfStmt : TYPEOF WS valueStmt (WS IS WS type)?;
 
 unloadStmt : UNLOAD WS valueStmt;
 
-unlockStmt : UNLOCK WS valueStmt (WS? ',' WS? valueStmt (WS TO WS valueStmt)?)?;
+unlockStmt : UNLOCK WS fileNumber (WS? ',' WS? valueStmt (WS TO WS valueStmt)?)?;
 
 // operator precedence is represented by rule order
 valueStmt : 
@@ -552,7 +552,7 @@ whileWendStmt :
 	WEND
 ;
 
-widthStmt : WIDTH WS valueStmt WS? ',' WS? valueStmt;
+widthStmt : WIDTH WS fileNumber WS? ',' WS? valueStmt;
 
 withStmt : 
 	WITH WS (implicitCallStmt_InStmt | (NEW WS type)) NEWLINE+ 
@@ -797,8 +797,8 @@ LSET : L S E T;
 MACRO_CONST : '#' C O N S T WS;
 MACRO_IF : '#' I F WS;
 MACRO_ELSEIF : '#' E L S E I F WS;
-MACRO_ELSE : '#' E L S E WS;
-MACRO_END_IF : '#' E N D WS I F;
+MACRO_ELSE : '#' E L S E NEWLINE;
+MACRO_END_IF : '#' E N D WS I F NEWLINE;
 ME : M E;
 MID : M I D;
 MKDIR : M K D I R;
@@ -909,7 +909,7 @@ INTEGERLITERAL : (PLUS|MINUS)? ('0'..'9')+ ( ('e' | 'E') INTEGERLITERAL)* ('#' |
 DOUBLELITERAL : (PLUS|MINUS)? ('0'..'9')* '.' ('0'..'9')+ ( ('e' | 'E') (PLUS|MINUS)? ('0'..'9')+)* ('#' | '&')?;
 BYTELITERAL : ('0'..'9')+;
 // identifier
-IDENTIFIER :  LETTER (LETTERORDIGIT)* | L_SQUARE_BRACKET ((~[!\]\r\n])+ R_SQUARE_BRACKET;
+IDENTIFIER :  (~[!\]\(\)\r\n\t ])+ | L_SQUARE_BRACKET (~[!\]\r\n])+ R_SQUARE_BRACKET;
 // whitespace, line breaks, comments, ...
 LINE_CONTINUATION : [ \t]+ '_' '\r'? '\n' -> skip;
 NEWLINE : (':' WS?) | (WS? ('\r'? '\n') WS?); 
diff --git a/Rubberduck.Parsing/Grammar/VBALexer.cs b/Rubberduck.Parsing/Grammar/VBALexer.cs
diff --git a/Rubberduck.Parsing/Grammar/VBAParser.cs b/Rubberduck.Parsing/Grammar/VBAParser.cs
diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs
@@ -168,11 +168,20 @@ private string FindAnnotations(int line)
             return null;
         }
 
-        private Declaration ResolveType(VBAParser.ComplexTypeContext context)
+        private void ResolveType(VBAParser.ICS_S_MembersCallContext context)
+        {
+            var first = context.iCS_S_VariableOrProcedureCall().ambiguousIdentifier();
+            var identifiers = new[] {first}.Concat(context.iCS_S_MemberCall()
+                        .Select(member => member.iCS_S_VariableOrProcedureCall().ambiguousIdentifier()))
+                        .ToList();
+            ResolveType(identifiers);
+        }
+
+        private void ResolveType(VBAParser.ComplexTypeContext context)
         {
             if (context == null)
             {
-                return null;
+                return;
             }
 
             var identifiers = context.ambiguousIdentifier()
@@ -182,10 +191,16 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)
             // if there's only 1 identifier, resolve to the tightest-scope match:
             if (identifiers.Count == 1)
             {
-                return ResolveInScopeType(identifiers.Single().GetText(), _currentScope);
+                ResolveInScopeType(identifiers.Single().GetText(), _currentScope);
+                return;
             }
 
             // if there's 2 or more identifiers, resolve to the deepest path:
+            ResolveType(identifiers);
+        }
+
+        private void ResolveType(IList<VBAParser.AmbiguousIdentifierContext> identifiers)
+        {
             var first = identifiers[0].GetText();
             var projectMatch = _currentScope.ProjectName == first
                 ? _declarations.SingleOrDefault(declaration =>
@@ -223,22 +238,25 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)
                         if (udtMatch != null)
                         {
                             var udtReference = CreateReference(identifiers[2], udtMatch);
-                            
+
                             projectMatch.AddReference(projectReference);
                             _alreadyResolved.Add(projectReference.Context);
 
                             moduleMatch.AddReference(moduleReference);
                             _alreadyResolved.Add(moduleReference.Context);
-                            
+
                             udtMatch.AddReference(udtReference);
                             _alreadyResolved.Add(udtReference.Context);
-                            
-                            return udtMatch;
+
+                            return;
                         }
                     }
                 }
                 else
                 {
+                    projectMatch.AddReference(projectReference);
+                    _alreadyResolved.Add(projectReference.Context);
+
                     var match = _declarations.SingleOrDefault(declaration =>
                         !declaration.IsBuiltIn && declaration.ParentDeclaration != null
                         && declaration.ParentDeclaration.Equals(projectMatch)
@@ -248,20 +266,19 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)
                     if (match != null)
                     {
                         var reference = CreateReference(identifiers[1], match);
-                        match.AddReference(reference);
-                        _alreadyResolved.Add(reference.Context);
-                        return match;
+                        if (reference != null)
+                        {
+                            match.AddReference(reference);
+                            _alreadyResolved.Add(reference.Context);
+                            return;
+                        }
                     }
                 }
             }
 
             // first identifier didn't match current project.
             // if there are 3 identifiers, type isn't in current project.
-            if (identifiers.Count == 3)
-            {
-                return null;
-            }
-            else
+            if (identifiers.Count != 3)
             {
                 var moduleMatch = _declarations.SingleOrDefault(declaration =>
                     !declaration.IsBuiltIn && declaration.ParentDeclaration != null
@@ -288,13 +305,9 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)
 
                         udtMatch.AddReference(udtReference);
                         _alreadyResolved.Add(udtReference.Context);
-
-                        return udtMatch;
                     }
                 }
             }
-            
-            return null;
         }
 
         private IEnumerable<Declaration> FindMatchingTypes(string identifier)
@@ -306,12 +319,12 @@ private IEnumerable<Declaration> FindMatchingTypes(string identifier)
                 .ToList();
         }
 
-        private Declaration ResolveInScopeType(string identifier, Declaration scope)
+        private void ResolveInScopeType(string identifier, Declaration scope)
         {
             var matches = FindMatchingTypes(identifier).ToList();
             if (matches.Count == 1)
             {
-                return matches.Single();
+                return;
             }
 
             // more than one matching identifiers found.
@@ -324,12 +337,12 @@ private Declaration ResolveInScopeType(string identifier, Declaration scope)
 
             if (sameScopeUdt.Count == 1)
             {
-                return sameScopeUdt.Single();
+                return;
             }
             
             // todo: try to resolve identifier using referenced projects
 
-            return null; // match is ambiguous or unknown, return null
+            return;
         }
 
 
@@ -709,6 +722,13 @@ public void Resolve(VBAParser.ICS_S_MembersCallContext context)
                 return;
             }
 
+            if (context.Parent.Parent.Parent is VBAParser.VsNewContext)
+            {
+                // if we're in a ValueStatement/New context, we're actually resolving for a type:
+                ResolveType(context);
+                return;
+            }
+
             Declaration parent;
             if (_withBlockQualifiers.Any())
             {
@@ -721,7 +741,7 @@ public void Resolve(VBAParser.ICS_S_MembersCallContext context)
             else
             {
                 parent = ResolveInternal(context.iCS_S_ProcedureOrArrayCall(), _currentScope)
-                          ?? ResolveInternal(context.iCS_S_VariableOrProcedureCall(), _currentScope);
+                        ?? ResolveInternal(context.iCS_S_VariableOrProcedureCall(), _currentScope);
                 parent = ResolveType(parent);
             }
 
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -28,9 +28,22 @@ public ParserStateEventArgs(ParserState state)
         public ParserState State { get {return _state; } }
     }
 
+    public class ParseRequestEventArgs : EventArgs
+    {
+        private readonly VBComponent _component;
+
+        public ParseRequestEventArgs(VBComponent component)
+        {
+            _component = component;
+        }
+
+        public VBComponent Component { get { return _component; } }
+        public bool IsFullReparseRequest { get { return _component == null; } }
+    }
+
     public sealed class RubberduckParserState
     {
-        public event EventHandler ParseRequest;
+        public event EventHandler<ParseRequestEventArgs> ParseRequest;
 
         // keys are the declarations; values indicate whether a declaration is resolved.
         private readonly ConcurrentDictionary<Declaration, ResolutionState> _declarations =
@@ -291,12 +304,18 @@ public void AddBuiltInDeclarations(IHostApplication hostApplication)
             }
         }
 
-        public void OnParseRequested()
+        /// <summary>
+        /// Requests reparse for specified component.
+        /// Omit parameter to request a full reparse.
+        /// </summary>
+        /// <param name="component">The component to reparse.</param>
+        public void OnParseRequested(VBComponent component = null)
         {
             var handler = ParseRequest;
             if (handler != null)
             {
-                handler.Invoke(this, EventArgs.Empty);
+                var args = new ParseRequestEventArgs(component);
+                handler.Invoke(this, args);
             }
         }
     }
diff --git a/RubberduckTests/SourceControl/SCPresenterTests.cs b/RubberduckTests/SourceControl/SCPresenterTests.cs
@@ -411,7 +411,8 @@ public void OpenWorkingDir_WhenUserConfirms_RepoIsAddedToConfig()
 
             //assert
             _configService.Verify(c => c.SaveConfiguration(It.IsAny<SourceControlConfiguration>()), Times.Once);
-        }        [TestMethod]
+        }
+        [TestMethod]
         public void InitRepository_WhenUserConfirms_StatusIsOnline()
         {
             //arrange
@@ -706,12 +707,12 @@ public void UnsyncedPresenter_AfterLogin_NewPresenterIsCreatedWithCredentials()
         private SourceControlConfiguration GetDummyConfig()
         {
             return new SourceControlConfiguration()
-                    {
-                        Repositories = new List<Repository>() 
+            {
+                Repositories = new List<Repository>() 
                         { 
                             (Repository)GetDummyRepo()
                         }
-                    };
+            };
         }
 
         private static IRepository GetDummyRepo()
@@ -724,4 +725,4 @@ private static IRepository GetDummyRepo()
                        );
         }
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public sealed class UntypedFunctionUsageInspection : InspectionBase`
`12`	`12`	`public UntypedFunctionUsageInspection(RubberduckParserState state)`
`13`	`13`	`: base(state)`
`14`	`14`	`{`
`15`		`- Severity = CodeInspectionSeverity.Hint;`
	`15`	`+ Severity = CodeInspectionSeverity.Warning;`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public override string Description { get { return RubberduckUI.UntypedFunctionUsage_; } }`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ private void ApplyAbstractFactoryConvention(IEnumerable<Assembly> assemblies)`
`132`	`132`	`.Configure(binding => binding.InSingletonScope()));`
`133`	`133`	`}`
`134`	`134`
`135`		`- // note: IInspection implementations are discovered in the Rubberduck assembly via reflection.`
	`135`	`+ // note: InspectionBase implementations are discovered in the Rubberduck assembly via reflection.`
`136`	`136`	`private void BindCodeInspectionTypes()`
`137`	`137`	`{`
`138`	`138`	`var inspections = Assembly.GetExecutingAssembly()`
Original file line number	Diff line number	Diff line change
`@@ -168,11 +168,20 @@ private string FindAnnotations(int line)`
`168`	`168`	`return null;`
`169`	`169`	`}`
`170`	`170`
`171`		`- private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
	`171`	`+ private void ResolveType(VBAParser.ICS_S_MembersCallContext context)`
	`172`	`+ {`
	`173`	`+ var first = context.iCS_S_VariableOrProcedureCall().ambiguousIdentifier();`
	`174`	`+ var identifiers = new[] {first}.Concat(context.iCS_S_MemberCall()`
	`175`	`+ .Select(member => member.iCS_S_VariableOrProcedureCall().ambiguousIdentifier()))`
	`176`	`+ .ToList();`
	`177`	`+ ResolveType(identifiers);`
	`178`	`+ }`
	`179`	`+`
	`180`	`+ private void ResolveType(VBAParser.ComplexTypeContext context)`
`172`	`181`	`{`
`173`	`182`	`if (context == null)`
`174`	`183`	`{`
`175`		`- return null;`
	`184`	`+ return;`
`176`	`185`	`}`
`177`	`186`
`178`	`187`	`var identifiers = context.ambiguousIdentifier()`
`@@ -182,10 +191,16 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
`182`	`191`	`// if there's only 1 identifier, resolve to the tightest-scope match:`
`183`	`192`	`if (identifiers.Count == 1)`
`184`	`193`	`{`
`185`		`- return ResolveInScopeType(identifiers.Single().GetText(), _currentScope);`
	`194`	`+ ResolveInScopeType(identifiers.Single().GetText(), _currentScope);`
	`195`	`+ return;`
`186`	`196`	`}`
`187`	`197`
`188`	`198`	`// if there's 2 or more identifiers, resolve to the deepest path:`
	`199`	`+ ResolveType(identifiers);`
	`200`	`+ }`
	`201`	`+`
	`202`	`+ private void ResolveType(IList<VBAParser.AmbiguousIdentifierContext> identifiers)`
	`203`	`+ {`
`189`	`204`	`var first = identifiers[0].GetText();`
`190`	`205`	`var projectMatch = _currentScope.ProjectName == first`
`191`	`206`	`? _declarations.SingleOrDefault(declaration =>`
`@@ -223,22 +238,25 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
`223`	`238`	`if (udtMatch != null)`
`224`	`239`	`{`
`225`	`240`	`var udtReference = CreateReference(identifiers[2], udtMatch);`
`226`		`-`
	`241`	`+`
`227`	`242`	`projectMatch.AddReference(projectReference);`
`228`	`243`	`_alreadyResolved.Add(projectReference.Context);`
`229`	`244`
`230`	`245`	`moduleMatch.AddReference(moduleReference);`
`231`	`246`	`_alreadyResolved.Add(moduleReference.Context);`
`232`		`-`
	`247`	`+`
`233`	`248`	`udtMatch.AddReference(udtReference);`
`234`	`249`	`_alreadyResolved.Add(udtReference.Context);`
`235`		`-`
`236`		`- return udtMatch;`
	`250`	`+`
	`251`	`+ return;`
`237`	`252`	`}`
`238`	`253`	`}`
`239`	`254`	`}`
`240`	`255`	`else`
`241`	`256`	`{`
	`257`	`+ projectMatch.AddReference(projectReference);`
	`258`	`+ _alreadyResolved.Add(projectReference.Context);`
	`259`	`+`
`242`	`260`	`var match = _declarations.SingleOrDefault(declaration =>`
`243`	`261`	`!declaration.IsBuiltIn && declaration.ParentDeclaration != null`
`244`	`262`	`&& declaration.ParentDeclaration.Equals(projectMatch)`
`@@ -248,20 +266,19 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
`248`	`266`	`if (match != null)`
`249`	`267`	`{`
`250`	`268`	`var reference = CreateReference(identifiers[1], match);`
`251`		`- match.AddReference(reference);`
`252`		`- _alreadyResolved.Add(reference.Context);`
`253`		`- return match;`
	`269`	`+ if (reference != null)`
	`270`	`+ {`
	`271`	`+ match.AddReference(reference);`
	`272`	`+ _alreadyResolved.Add(reference.Context);`
	`273`	`+ return;`
	`274`	`+ }`
`254`	`275`	`}`
`255`	`276`	`}`
`256`	`277`	`}`
`257`	`278`
`258`	`279`	`// first identifier didn't match current project.`
`259`	`280`	`// if there are 3 identifiers, type isn't in current project.`
`260`		`- if (identifiers.Count == 3)`
`261`		`- {`
`262`		`- return null;`
`263`		`- }`
`264`		`- else`
	`281`	`+ if (identifiers.Count != 3)`
`265`	`282`	`{`
`266`	`283`	`var moduleMatch = _declarations.SingleOrDefault(declaration =>`
`267`	`284`	`!declaration.IsBuiltIn && declaration.ParentDeclaration != null`
`@@ -288,13 +305,9 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
`288`	`305`
`289`	`306`	`udtMatch.AddReference(udtReference);`
`290`	`307`	`_alreadyResolved.Add(udtReference.Context);`
`291`		`-`
`292`		`- return udtMatch;`
`293`	`308`	`}`
`294`	`309`	`}`
`295`	`310`	`}`
`296`		`-`
`297`		`- return null;`
`298`	`311`	`}`
`299`	`312`
`300`	`313`	`private IEnumerable<Declaration> FindMatchingTypes(string identifier)`
`@@ -306,12 +319,12 @@ private IEnumerable<Declaration> FindMatchingTypes(string identifier)`
`306`	`319`	`.ToList();`
`307`	`320`	`}`
`308`	`321`
`309`		`- private Declaration ResolveInScopeType(string identifier, Declaration scope)`
	`322`	`+ private void ResolveInScopeType(string identifier, Declaration scope)`
`310`	`323`	`{`
`311`	`324`	`var matches = FindMatchingTypes(identifier).ToList();`
`312`	`325`	`if (matches.Count == 1)`
`313`	`326`	`{`
`314`		`- return matches.Single();`
	`327`	`+ return;`
`315`	`328`	`}`
`316`	`329`
`317`	`330`	`// more than one matching identifiers found.`
`@@ -324,12 +337,12 @@ private Declaration ResolveInScopeType(string identifier, Declaration scope)`
`324`	`337`
`325`	`338`	`if (sameScopeUdt.Count == 1)`
`326`	`339`	`{`
`327`		`- return sameScopeUdt.Single();`
	`340`	`+ return;`
`328`	`341`	`}`
`329`	`342`
`330`	`343`	`// todo: try to resolve identifier using referenced projects`
`331`	`344`
`332`		`- return null; // match is ambiguous or unknown, return null`
	`345`	`+ return;`
`333`	`346`	`}`
`334`	`347`
`335`	`348`
`@@ -709,6 +722,13 @@ public void Resolve(VBAParser.ICS_S_MembersCallContext context)`
`709`	`722`	`return;`
`710`	`723`	`}`
`711`	`724`
	`725`	`+ if (context.Parent.Parent.Parent is VBAParser.VsNewContext)`
	`726`	`+ {`
	`727`	`+ // if we're in a ValueStatement/New context, we're actually resolving for a type:`
	`728`	`+ ResolveType(context);`
	`729`	`+ return;`
	`730`	`+ }`
	`731`	`+`
`712`	`732`	`Declaration parent;`
`713`	`733`	`if (_withBlockQualifiers.Any())`
`714`	`734`	`{`
`@@ -721,7 +741,7 @@ public void Resolve(VBAParser.ICS_S_MembersCallContext context)`
`721`	`741`	`else`
`722`	`742`	`{`
`723`	`743`	`parent = ResolveInternal(context.iCS_S_ProcedureOrArrayCall(), _currentScope)`
`724`		`- ?? ResolveInternal(context.iCS_S_VariableOrProcedureCall(), _currentScope);`
	`744`	`+ ?? ResolveInternal(context.iCS_S_VariableOrProcedureCall(), _currentScope);`
`725`	`745`	`parent = ResolveType(parent);`
`726`	`746`	`}`
`727`	`747`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,22 @@ public ParserStateEventArgs(ParserState state)`
`28`	`28`	`public ParserState State { get {return _state; } }`
`29`	`29`	`}`
`30`	`30`
	`31`	`+ public class ParseRequestEventArgs : EventArgs`
	`32`	`+ {`
	`33`	`+ private readonly VBComponent _component;`
	`34`	`+`
	`35`	`+ public ParseRequestEventArgs(VBComponent component)`
	`36`	`+ {`
	`37`	`+ _component = component;`
	`38`	`+ }`
	`39`	`+`
	`40`	`+ public VBComponent Component { get { return _component; } }`
	`41`	`+ public bool IsFullReparseRequest { get { return _component == null; } }`
	`42`	`+ }`
	`43`	`+`
`31`	`44`	`public sealed class RubberduckParserState`
`32`	`45`	`{`
`33`		`- public event EventHandler ParseRequest;`
	`46`	`+ public event EventHandler<ParseRequestEventArgs> ParseRequest;`
`34`	`47`
`35`	`48`	`// keys are the declarations; values indicate whether a declaration is resolved.`
`36`	`49`	`private readonly ConcurrentDictionary<Declaration, ResolutionState> _declarations =`
`@@ -291,12 +304,18 @@ public void AddBuiltInDeclarations(IHostApplication hostApplication)`
`291`	`304`	`}`
`292`	`305`	`}`
`293`	`306`
`294`		`- public void OnParseRequested()`
	`307`	`+ /// <summary>`
	`308`	`+ /// Requests reparse for specified component.`
	`309`	`+ /// Omit parameter to request a full reparse.`
	`310`	`+ /// </summary>`
	`311`	`+ /// <param name="component">The component to reparse.</param>`
	`312`	`+ public void OnParseRequested(VBComponent component = null)`
`295`	`313`	`{`
`296`	`314`	`var handler = ParseRequest;`
`297`	`315`	`if (handler != null)`
`298`	`316`	`{`
`299`		`- handler.Invoke(this, EventArgs.Empty);`
	`317`	`+ var args = new ParseRequestEventArgs(component);`
	`318`	`+ handler.Invoke(this, args);`
`300`	`319`	`}`
`301`	`320`	`}`
`302`	`321`	`}`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,8 @@ public void OpenWorkingDir_WhenUserConfirms_RepoIsAddedToConfig()`
`411`	`411`
`412`	`412`	`//assert`
`413`	`413`	`_configService.Verify(c => c.SaveConfiguration(It.IsAny<SourceControlConfiguration>()), Times.Once);`
`414`		`- } [TestMethod]`
	`414`	`+ }`
	`415`	`+ [TestMethod]`
`415`	`416`	`public void InitRepository_WhenUserConfirms_StatusIsOnline()`
`416`	`417`	`{`
`417`	`418`	`//arrange`
`@@ -706,12 +707,12 @@ public void UnsyncedPresenter_AfterLogin_NewPresenterIsCreatedWithCredentials()`
`706`	`707`	`private SourceControlConfiguration GetDummyConfig()`
`707`	`708`	`{`
`708`	`709`	`return new SourceControlConfiguration()`
`709`		`- {`
`710`		`- Repositories = new List<Repository>()`
	`710`	`+ {`
	`711`	`+ Repositories = new List<Repository>()`
`711`	`712`	`{`
`712`	`713`	`(Repository)GetDummyRepo()`
`713`	`714`	`}`
`714`		`- };`
	`715`	`+ };`
`715`	`716`	`}`
`716`	`717`
`717`	`718`	`private static IRepository GetDummyRepo()`
`@@ -724,4 +725,4 @@ private static IRepository GetDummyRepo()`
`724`	`725`	`);`
`725`	`726`	`}`
`726`	`727`	`}`
`727`		`-}`
	`728`	`+}`