Removed GetContenHash from QualifiedModuleName, since it is basically always stale.

MDoerner · MDoerner · commit 940c3cf71923 · 2018-01-28T16:48:06.000+01:00
diff --git a/Rubberduck.Parsing/VBA/ParseRunnerBase.cs b/Rubberduck.Parsing/VBA/ParseRunnerBase.cs
@@ -103,10 +103,11 @@ private void ProcessComponentParseResults(QualifiedModuleName module, Task<Compo
                 var result = finishedParseTask.Result;
                 lock (_state)
                 {
-                    _state.SetModuleAttributes(module, result.Attributes);
+                    token.ThrowIfCancellationRequested();
+                    _state.SetModuleAttributes(module, result.Attributes);  //This has to come first because it creates the module state if not present.
+                    _state.AddTokenStream(module, result.Tokens);
                     _state.AddParseTree(module, result.ParseTree);
                     _state.AddParseTree(module, result.AttributesTree, ParsePass.AttributesPass);
-                    _state.AddTokenStream(module, result.Tokens);
                     _state.SetModuleComments(module, result.Comments);
                     _state.SetModuleAnnotations(module, result.Annotations);
                     _state.AddAttributesRewriter(module, result.AttributesRewriter);
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -746,13 +746,13 @@ private bool RemoveKeysFromCollections(IEnumerable<QualifiedModuleName> keys)
         public void AddTokenStream(QualifiedModuleName module, ITokenStream stream)
         {
             _moduleStates[module].SetTokenStream(ProjectsProvider.CodeModule(module), stream);
+            _moduleStates[module].SetModuleContentHashCode(GetModuleContentHash(module));
         }
 
         public void AddParseTree(QualifiedModuleName module, IParseTree parseTree, ParsePass pass = ParsePass.CodePanePass)
         {
             var key = module;
             _moduleStates[key].SetParseTree(parseTree, pass);
-            _moduleStates[key].SetModuleContentHashCode(key.ContentHashCode);
         }
 
         public IParseTree GetParseTree(QualifiedModuleName module, ParsePass pass = ParsePass.CodePanePass)
@@ -896,13 +896,21 @@ public bool IsNewOrModified(QualifiedModuleName key)
             if (_moduleStates.TryGetValue(key, out var moduleState))
             {
                 // existing/modified
-                return moduleState.IsNew || key.ContentHashCode != moduleState.ModuleContentHashCode;
+                return moduleState.IsNew || GetModuleContentHash(key) != moduleState.ModuleContentHashCode;
             }
 
             // new
             return true;
         }
 
+        private int GetModuleContentHash(QualifiedModuleName module)
+        {
+            var codeModule = ProjectsProvider.CodeModule(module);
+            return codeModule != null && codeModule.CountOfLines > 0
+                    ? codeModule.GetLines(1, codeModule.CountOfLines).GetHashCode()
+                    : 0;
+        }
+
         public Declaration FindSelectedDeclaration(ICodePane activeCodePane)
         {
             return DeclarationFinder?.FindSelectedDeclaration(activeCodePane);
@@ -936,7 +944,6 @@ public void AddAttributesRewriter(QualifiedModuleName module, IModuleRewriter at
         {
             var key = module;
             _moduleStates[key].SetAttributesRewriter(attributesRewriter);
-            _moduleStates[key].SetModuleContentHashCode(key.ContentHashCode);
         }
 
         private bool _isDisposed;
diff --git a/Rubberduck.VBEEditor/QualifiedModuleName.cs b/Rubberduck.VBEEditor/QualifiedModuleName.cs
@@ -40,25 +40,13 @@ public QualifiedModuleName(IVBProject project)
             _projectName = project.Name;
             ProjectPath = string.Empty;
             ProjectId = GetProjectId(project);           
-            ContentHashCode = 0;
         }
 
         public QualifiedModuleName(IVBComponent component)
         {
             ComponentType = component.Type;
             _componentName = component.IsWrappingNullReference ? string.Empty : component.Name;
 
-            ContentHashCode = 0;
-            if (!component.IsWrappingNullReference)
-            {
-                using (var module = component.CodeModule)
-                {
-                    ContentHashCode = module.CountOfLines > 0
-                        ? module.GetLines(1, module.CountOfLines).GetHashCode()
-                        : 0;
-                }
-            }
-
             using (var components = component.Collection)
             {
                 using (var project = components.Parent)
@@ -81,7 +69,6 @@ public QualifiedModuleName(string projectName, string projectPath, string compon
             ProjectId = $"{_projectName};{ProjectPath}".GetHashCode().ToString(CultureInfo.InvariantCulture);
             _componentName = componentName;
             ComponentType = ComponentType.ComComponent;
-            ContentHashCode = 0;
         }
 
         public QualifiedMemberName QualifyMemberName(string member)
@@ -91,8 +78,6 @@ public QualifiedMemberName QualifyMemberName(string member)
 
         public ComponentType ComponentType { get; }
 
-        public int ContentHashCode { get; }
-
         public string ProjectId { get; }
 
         private readonly string _componentName;
diff --git a/RubberduckTests/VBEditor/ProjectsRepositoryTests.cs b/RubberduckTests/VBEditor/ProjectsRepositoryTests.cs
@@ -1661,11 +1661,9 @@ public void CodeModulesGetDisposedOnDisposal()
             var repository = TestRepository(vbe);
             repository.Dispose();
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.
             foreach (var mock in mockCodeModules.Concat(otherMockCodeModules))
             {
-                mock.Verify(m => m.Dispose(), Times.Exactly(2));
+                mock.Verify(m => m.Dispose(), Times.Once);
             }
         }
 
@@ -1918,12 +1916,9 @@ public void CodeModulesGetDisposedOnRefresh()
             var repository = TestRepository(vbe);
             repository.Refresh();
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 2 additional disposals are expected 
-            //for loading the repository twice (initial + refresh).
             foreach (var mock in mockCodeModules.Concat(otherMockCodeModules))
             {
-                mock.Verify(m => m.Dispose(), Times.Exactly(3));    
+                mock.Verify(m => m.Dispose(), Times.Once);    
             }
         }
 
@@ -1948,12 +1943,9 @@ public void CodeModulesInProjectWithMatchingProjectIdGetDisposedOnRefreshForProj
             var repository = TestRepository(vbe);
             repository.Refresh(project.ProjectId);
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 2 additional disposals are expected 
-            //for loading the repository twice (initial + refresh).
             foreach (var mock in mockCodeModules)
             {
-                mock.Verify(m => m.Dispose(), Times.Exactly(3));
+                mock.Verify(m => m.Dispose(), Times.Once);
             }
         }
 
@@ -1978,11 +1970,9 @@ public void CodeModulesInProjectWithOtherProjectIdDoNotGetDisposedOnRefreshForPr
             var repository = TestRepository(vbe);
             repository.Refresh(project.ProjectId);
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.
             foreach (var mock in otherMockCodeModules)
             {
-                mock.Verify(m => m.Dispose(), Times.Once);
+                mock.Verify(m => m.Dispose(), Times.Never);
             }
         }
 
@@ -2010,10 +2000,7 @@ public void RemovedCodeModulesGetDisposedOnRefresh()
             project.VBComponents.Remove(component2);
             repository.Refresh();
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 2 additional disposals are expected 
-            //for loading the repository (initial).
-            codeModule2Mock.Verify(m => m.Dispose(), Times.Exactly(2));
+            codeModule2Mock.Verify(m => m.Dispose(), Times.Once);
         }
 
         [Test()]
@@ -2041,10 +2028,7 @@ public void RemovedCodeModulesGetDisposedOnRefreshForProjectIdOfFormerlyContaini
             project.VBComponents.Remove(component2);
             repository.Refresh(project.ProjectId);
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 2 additional disposals are expected 
-            //for loading the repository (initial).
-            codeModule2Mock.Verify(m => m.Dispose(), Times.Exactly(2));
+            codeModule2Mock.Verify(m => m.Dispose(), Times.Once);
         }
 
         [Test()]
@@ -2073,9 +2057,7 @@ public void RemovedCodeModulesDoNotGetDisposedOnRefreshForOtherProjectId()
             project.VBComponents.Remove(component2);
             repository.Refresh(otherProject.ProjectId);
 
-            //Generating a qmn from a component disposes the code module returned to get the content hash.
-            //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.
-            codeModule2Mock.Verify(m => m.Dispose(), Times.Once);
+            codeModule2Mock.Verify(m => m.Dispose(), Times.Never);
         }
 
         [Test()]

Original file line number	Diff line number	Diff line change
`@@ -746,13 +746,13 @@ private bool RemoveKeysFromCollections(IEnumerable<QualifiedModuleName> keys)`
`746`	`746`	`public void AddTokenStream(QualifiedModuleName module, ITokenStream stream)`
`747`	`747`	`{`
`748`	`748`	`_moduleStates[module].SetTokenStream(ProjectsProvider.CodeModule(module), stream);`
	`749`	`+ _moduleStates[module].SetModuleContentHashCode(GetModuleContentHash(module));`
`749`	`750`	`}`
`750`	`751`
`751`	`752`	`public void AddParseTree(QualifiedModuleName module, IParseTree parseTree, ParsePass pass = ParsePass.CodePanePass)`
`752`	`753`	`{`
`753`	`754`	`var key = module;`
`754`	`755`	`_moduleStates[key].SetParseTree(parseTree, pass);`
`755`		`- _moduleStates[key].SetModuleContentHashCode(key.ContentHashCode);`
`756`	`756`	`}`
`757`	`757`
`758`	`758`	`public IParseTree GetParseTree(QualifiedModuleName module, ParsePass pass = ParsePass.CodePanePass)`
`@@ -896,13 +896,21 @@ public bool IsNewOrModified(QualifiedModuleName key)`
`896`	`896`	`if (_moduleStates.TryGetValue(key, out var moduleState))`
`897`	`897`	`{`
`898`	`898`	`// existing/modified`
`899`		`- return moduleState.IsNew \|\| key.ContentHashCode != moduleState.ModuleContentHashCode;`
	`899`	`+ return moduleState.IsNew \|\| GetModuleContentHash(key) != moduleState.ModuleContentHashCode;`
`900`	`900`	`}`
`901`	`901`
`902`	`902`	`// new`
`903`	`903`	`return true;`
`904`	`904`	`}`
`905`	`905`
	`906`	`+ private int GetModuleContentHash(QualifiedModuleName module)`
	`907`	`+ {`
	`908`	`+ var codeModule = ProjectsProvider.CodeModule(module);`
	`909`	`+ return codeModule != null && codeModule.CountOfLines > 0`
	`910`	`+ ? codeModule.GetLines(1, codeModule.CountOfLines).GetHashCode()`
	`911`	`+ : 0;`
	`912`	`+ }`
	`913`	`+`
`906`	`914`	`public Declaration FindSelectedDeclaration(ICodePane activeCodePane)`
`907`	`915`	`{`
`908`	`916`	`return DeclarationFinder?.FindSelectedDeclaration(activeCodePane);`
`@@ -936,7 +944,6 @@ public void AddAttributesRewriter(QualifiedModuleName module, IModuleRewriter at`
`936`	`944`	`{`
`937`	`945`	`var key = module;`
`938`	`946`	`_moduleStates[key].SetAttributesRewriter(attributesRewriter);`
`939`		`- _moduleStates[key].SetModuleContentHashCode(key.ContentHashCode);`
`940`	`947`	`}`
`941`	`948`
`942`	`949`	`private bool _isDisposed;`
Original file line number	Diff line number	Diff line change
`@@ -1661,11 +1661,9 @@ public void CodeModulesGetDisposedOnDisposal()`
`1661`	`1661`	`var repository = TestRepository(vbe);`
`1662`	`1662`	`repository.Dispose();`
`1663`	`1663`
`1664`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`1665`		`- //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.`
`1666`	`1664`	`foreach (var mock in mockCodeModules.Concat(otherMockCodeModules))`
`1667`	`1665`	`{`
`1668`		`- mock.Verify(m => m.Dispose(), Times.Exactly(2));`
	`1666`	`+ mock.Verify(m => m.Dispose(), Times.Once);`
`1669`	`1667`	`}`
`1670`	`1668`	`}`
`1671`	`1669`
`@@ -1918,12 +1916,9 @@ public void CodeModulesGetDisposedOnRefresh()`
`1918`	`1916`	`var repository = TestRepository(vbe);`
`1919`	`1917`	`repository.Refresh();`
`1920`	`1918`
`1921`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`1922`		`- //Since the mocks always return the same mock, 2 additional disposals are expected`
`1923`		`- //for loading the repository twice (initial + refresh).`
`1924`	`1919`	`foreach (var mock in mockCodeModules.Concat(otherMockCodeModules))`
`1925`	`1920`	`{`
`1926`		`- mock.Verify(m => m.Dispose(), Times.Exactly(3));`
	`1921`	`+ mock.Verify(m => m.Dispose(), Times.Once);`
`1927`	`1922`	`}`
`1928`	`1923`	`}`
`1929`	`1924`
`@@ -1948,12 +1943,9 @@ public void CodeModulesInProjectWithMatchingProjectIdGetDisposedOnRefreshForProj`
`1948`	`1943`	`var repository = TestRepository(vbe);`
`1949`	`1944`	`repository.Refresh(project.ProjectId);`
`1950`	`1945`
`1951`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`1952`		`- //Since the mocks always return the same mock, 2 additional disposals are expected`
`1953`		`- //for loading the repository twice (initial + refresh).`
`1954`	`1946`	`foreach (var mock in mockCodeModules)`
`1955`	`1947`	`{`
`1956`		`- mock.Verify(m => m.Dispose(), Times.Exactly(3));`
	`1948`	`+ mock.Verify(m => m.Dispose(), Times.Once);`
`1957`	`1949`	`}`
`1958`	`1950`	`}`
`1959`	`1951`
`@@ -1978,11 +1970,9 @@ public void CodeModulesInProjectWithOtherProjectIdDoNotGetDisposedOnRefreshForPr`
`1978`	`1970`	`var repository = TestRepository(vbe);`
`1979`	`1971`	`repository.Refresh(project.ProjectId);`
`1980`	`1972`
`1981`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`1982`		`- //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.`
`1983`	`1973`	`foreach (var mock in otherMockCodeModules)`
`1984`	`1974`	`{`
`1985`		`- mock.Verify(m => m.Dispose(), Times.Once);`
	`1975`	`+ mock.Verify(m => m.Dispose(), Times.Never);`
`1986`	`1976`	`}`
`1987`	`1977`	`}`
`1988`	`1978`
`@@ -2010,10 +2000,7 @@ public void RemovedCodeModulesGetDisposedOnRefresh()`
`2010`	`2000`	`project.VBComponents.Remove(component2);`
`2011`	`2001`	`repository.Refresh();`
`2012`	`2002`
`2013`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`2014`		`- //Since the mocks always return the same mock, 2 additional disposals are expected`
`2015`		`- //for loading the repository (initial).`
`2016`		`- codeModule2Mock.Verify(m => m.Dispose(), Times.Exactly(2));`
	`2003`	`+ codeModule2Mock.Verify(m => m.Dispose(), Times.Once);`
`2017`	`2004`	`}`
`2018`	`2005`
`2019`	`2006`	`[Test()]`
`@@ -2041,10 +2028,7 @@ public void RemovedCodeModulesGetDisposedOnRefreshForProjectIdOfFormerlyContaini`
`2041`	`2028`	`project.VBComponents.Remove(component2);`
`2042`	`2029`	`repository.Refresh(project.ProjectId);`
`2043`	`2030`
`2044`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`2045`		`- //Since the mocks always return the same mock, 2 additional disposals are expected`
`2046`		`- //for loading the repository (initial).`
`2047`		`- codeModule2Mock.Verify(m => m.Dispose(), Times.Exactly(2));`
	`2031`	`+ codeModule2Mock.Verify(m => m.Dispose(), Times.Once);`
`2048`	`2032`	`}`
`2049`	`2033`
`2050`	`2034`	`[Test()]`
`@@ -2073,9 +2057,7 @@ public void RemovedCodeModulesDoNotGetDisposedOnRefreshForOtherProjectId()`
`2073`	`2057`	`project.VBComponents.Remove(component2);`
`2074`	`2058`	`repository.Refresh(otherProject.ProjectId);`
`2075`	`2059`
`2076`		`- //Generating a qmn from a component disposes the code module returned to get the content hash.`
`2077`		`- //Since the mocks always return the same mock, 1 additional disposal is expected for loading the repository.`
`2078`		`- codeModule2Mock.Verify(m => m.Dispose(), Times.Once);`
	`2060`	`+ codeModule2Mock.Verify(m => m.Dispose(), Times.Never);`
`2079`	`2061`	`}`
`2080`	`2062`
`2081`	`2063`	`[Test()]`