Merge branch 'next' into Issue1434

Hosch250 · web-flow · commit 83c4c5dd83cb · 2016-07-15T21:15:48.000-05:00
diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
+using Antlr4.Runtime;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
@@ -27,10 +29,46 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 .SelectMany(declaration => declaration.References)
                 .Where(usage => !usage.IsInspectionDisabled(AnnotationName));
 
+            var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.Len");
+            var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.LenB");
+
             foreach (var issue in usages)
             {
-                yield return new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedModuleName, issue.Declaration);
+                if (DeclarationReferencesContainsReference(lenFunction, issue) ||
+                    DeclarationReferencesContainsReference(lenbFunction, issue))
+                {
+                    continue;
+                }
+
+                yield return
+                    new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedModuleName,
+                        issue.Declaration);
+            }
+        }
+
+        private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, IdentifierReference issue)
+        {
+            if (parentDeclaration == null)
+            {
+                return false;
+            }
+
+            var lenUsesIssue = false;
+            foreach (var reference in parentDeclaration.References)
+            {
+                var context = (ParserRuleContext) reference.Context.Parent;
+                if (context.GetSelection().Contains(issue.Selection))
+                {
+                    lenUsesIssue = true;
+                    break;
+                }
+            }
+
+            if (lenUsesIssue)
+            {
+                return true;
             }
+            return false;
         }
     }
 }
diff --git a/RetailCoder.VBE/NLog.dll.nlog b/RetailCoder.VBE/NLog.dll.nlog
@@ -6,9 +6,9 @@
     <target 
       xsi:type="File" 
       name="file"
-      fileName="${specialfolder:folder=ApplicationData}/Rubberduck/logs/rubberduck.log"
+      fileName="${specialfolder:folder=ApplicationData}/Rubberduck/Logs/RubberduckLog.txt"
       layout="${longdate};${uppercase:${level}};${logger};${message};${exception:format=tostring}"
-      archiveFileName="${specialfolder:folder=ApplicationData}/Rubberduck/logs/archives/rubberduck.{#}.log"
+      archiveFileName="${specialfolder:folder=ApplicationData}/Rubberduck/Logs/archives/RubberduckLog.{#}.txt"
       archiveAboveSize="5242880"
       archiveNumbering="Sequence"
       concurrentWrites="true"
diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs
@@ -228,9 +228,9 @@ public ObservableCollection<CodeExplorerItemViewModel> Projects
             get { return _projects; }
             set
             {
+                ReorderChildNodes(value);
                 _projects = new ObservableCollection<CodeExplorerItemViewModel>(value.OrderBy(o => o.NameWithSignature));
-
-                ReorderChildNodes(_projects);
+                
                 OnPropertyChanged();
             }
         }
diff --git a/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs b/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs
@@ -110,7 +110,7 @@ private void MoveCloserToUsage()
 
         private void _state_StateChanged(object sender, ParserStateEventArgs e)
         {
-            if (e.State != ParserState.ResolvedDeclarations) { return; }
+            if (e.State != ParserState.Ready) { return; }
 
             var newTarget = _state.AllUserDeclarations.FirstOrDefault(
                     item => item.ComponentName == _target.ComponentName &&
@@ -121,7 +121,7 @@ private void _state_StateChanged(object sender, ParserStateEventArgs e)
 
             if (newTarget != null)
             {
-                UpdateCallsToOtherModule(newTarget.References);
+                UpdateCallsToOtherModule(newTarget.References.ToList());
                 RemoveField(newTarget);
             }
 
@@ -273,20 +273,28 @@ private string RemoveExtraComma(string str, int numParams, int indexRemoved)
             return str.Remove(str.NthIndexOf(',', commaToRemove), 1);
         }
 
-        private void UpdateCallsToOtherModule(IEnumerable<IdentifierReference> references)
+        private void UpdateCallsToOtherModule(List<IdentifierReference> references)
         {
-            var identifierReferences = references.ToList();
+            if (!references.Any())
+            {
+                return;
+            }
 
-            var module = identifierReferences[0].QualifiedModuleName.Component.CodeModule;
+            var module = references[0].QualifiedModuleName.Component.CodeModule;
 
-            foreach (var reference in identifierReferences.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(t => t.Selection.StartColumn))
+            foreach (var reference in references.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(t => t.Selection.StartColumn))
             {
                 var parent = reference.Context.Parent;
-                while (!(parent is VBAParser.MemberAccessExprContext))
+                while (!(parent is VBAParser.MemberAccessExprContext) && parent.Parent != null)
                 {
                     parent = parent.Parent;
                 }
 
+                if (!(parent is VBAParser.MemberAccessExprContext))
+                {
+                    continue;
+                }
+
                 var parentSelection = ((VBAParser.MemberAccessExprContext)parent).GetSelection();
 
                 var oldText = module.Lines[parentSelection.StartLine, parentSelection.LineCount];
diff --git a/RetailCoder.VBE/UI/RegexAssistant/RegexAssistant.xaml b/RetailCoder.VBE/UI/RegexAssistant/RegexAssistant.xaml
@@ -70,7 +70,7 @@
                 <TextBox HorizontalAlignment="Stretch"
                             VerticalAlignment="Top" Height="23"
                             VerticalContentAlignment="Center" Margin="5" 
-                            Text="{Binding Pattern}"/>
+                            Text="{Binding Pattern, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
 
                 <StackPanel Orientation="Horizontal" Margin="5,0,5,0">
                     <CheckBox Content="{Resx ResxName=Rubberduck.UI.RubberduckUI, Key=RegexAssistant_GlobalFlag}" 
diff --git a/RetailCoder.VBE/UI/RubberduckUI.Designer.cs b/RetailCoder.VBE/UI/RubberduckUI.Designer.cs
diff --git a/RetailCoder.VBE/UI/RubberduckUI.resx b/RetailCoder.VBE/UI/RubberduckUI.resx
@@ -1716,7 +1716,7 @@ All our stargazers, likers &amp; followers, for the warm fuzzies
     <value>Publish Existing Repository</value>
   </data>
   <data name="RubberduckFatalError" xml:space="preserve">
-    <value>Rubberduck encountered an error. Please save your work and restart the host program, then upload your log file to our GitHub page.</value>
+    <value>Rubberduck encountered an error. Please save your work and restart the host program, then upload your log file located at "C:\Users\{username}\AppData\Roaming\Rubberduck\Logs\RubberduckLog.txt" to a GitHub issue at "https://github.com/rubberduck-vba/Rubberduck/issues/new".</value>
   </data>
   <data name="TestExplorerMenu_AddExpectedErrorTestMethod" xml:space="preserve">
     <value>Test Method (&amp;Expected Error)</value>
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -32,16 +32,20 @@ private readonly IDictionary<VBComponent, IDictionary<Tuple<string, DeclarationT
         private readonly IEnumerable<ICustomDeclarationLoader> _customDeclarationLoaders;
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
+        private readonly bool _isTestScope;
+
         public RubberduckParser(
             RubberduckParserState state,
             IAttributeParser attributeParser,
             Func<IVBAPreprocessor> preprocessorFactory,
-            IEnumerable<ICustomDeclarationLoader> customDeclarationLoaders)
+            IEnumerable<ICustomDeclarationLoader> customDeclarationLoaders,
+            bool isTestScope = false)
         {
             _state = state;
             _attributeParser = attributeParser;
             _preprocessorFactory = preprocessorFactory;
             _customDeclarationLoaders = customDeclarationLoaders;
+            _isTestScope = isTestScope;
 
             state.ParseRequest += ReparseRequested;
         }
@@ -53,8 +57,15 @@ public RubberduckParser(
 
         private void ReparseRequested(object sender, EventArgs e)
         {
-            Cancel();
-            Task.Run(() => ParseAll(_cancellationTokens[0]));
+            if (!_isTestScope)
+            {
+                Cancel();
+                Task.Run(() => ParseAll(_cancellationTokens[0]));
+            }
+            else
+            {
+                Parse(_cancellationTokens[0]);
+            }
         }
 
         /// <summary>
diff --git a/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs b/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs
@@ -277,43 +277,43 @@ Public Sub Foo()
             Assert.AreEqual(expectedCode, module.Lines());
         }
 
-        //        [TestMethod]
-        //        [TestCategory("Inspections")]
-        //        public void MoveFieldCloserToUsage_QuickFixWorks()
-        //        {
-        //            const string inputCode =
-        //@"Private bar As String
-        //Public Sub Foo()
-        //    bar = ""test""
-        //End Sub";
-
-        //            const string expectedCode =
-        //@"Public Sub Foo()
-
-        //    Dim bar As String
-        //    bar = ""test""
-        //End Sub";
-
-        //            //Arrange
-        //            var builder = new MockVbeBuilder();
-        //            VBComponent component;
-        //            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
-        //            var project = vbe.Object.VBProjects.Item(0);
-        //            var module = project.VBComponents.Item(0).CodeModule;
-        //            var mockHost = new Mock<IHostApplication>();
-        //            mockHost.SetupAllProperties();
-        //            var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
-
-        //            parser.Parse(new CancellationTokenSource());
-        //            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
-
-        //            var inspection = new MoveFieldCloserToUsageInspection(parser.State);
-        //            var inspectionResults = inspection.GetInspectionResults();
-
-        //            inspectionResults.First().QuickFixes.First().Fix();
-
-        //            Assert.AreEqual(expectedCode, module.Lines());
-        //        }
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void MoveFieldCloserToUsage_QuickFixWorks()
+        {
+            const string inputCode =
+@"Private bar As String
+Public Sub Foo()
+    bar = ""test""
+End Sub";
+
+            const string expectedCode =
+@"Public Sub Foo()
+
+    Dim bar As String
+    bar = ""test""
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var project = vbe.Object.VBProjects.Item(0);
+            var module = project.VBComponents.Item(0).CodeModule;
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new MoveFieldCloserToUsageInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.First().Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
 
         [TestMethod]
         [TestCategory("Inspections")]
diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs
@@ -6,13 +6,12 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
-using RubberduckTests.Mocks;
 using Rubberduck.Parsing.Preprocessing;
 using System.Globalization;
 using System.Threading;
 using Rubberduck.Parsing;
 
-namespace RubberduckTests
+namespace RubberduckTests.Mocks
 {
     public static class MockParser
     {
@@ -24,7 +23,7 @@ public static void ParseString(string inputCode, out QualifiedModuleName qualifi
             VBComponent component;
             var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
             qualifiedModuleName = new QualifiedModuleName(component);
-            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+            var parser = Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
 
             parser.Parse(new CancellationTokenSource());
             if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
@@ -43,7 +42,7 @@ public static RubberduckParser Create(VBE vbe, RubberduckParserState state, IAtt
         {
             return new RubberduckParser(state, attributeParser,
                 () => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture)),
-                new List<ICustomDeclarationLoader> {new DebugDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state)});
+                new List<ICustomDeclarationLoader> {new DebugDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state)}, true);
         }
     }
 }
diff --git a/RubberduckTests/Mocks/MockProjectBuilder.cs b/RubberduckTests/Mocks/MockProjectBuilder.cs
@@ -273,7 +273,7 @@ private Mock<CodeModule> CreateCodeModuleMock(string content)
 
             // ReSharper disable once UseIndexedProperty
             codeModule.Setup(m => m.get_Lines(It.IsAny<int>(), It.IsAny<int>()))
-                .Returns<int, int>((start, count) => String.Join(Environment.NewLine, lines.Skip(start - 1).Take(count)));
+                .Returns<int, int>((start, count) => string.Join(Environment.NewLine, lines.Skip(start - 1).Take(count)));
 
             codeModule.Setup(m => m.ReplaceLine(It.IsAny<int>(), It.IsAny<string>()))
                 .Callback<int, string>((index, str) => lines[index - 1] = str);
@@ -286,11 +286,11 @@ private Mock<CodeModule> CreateCodeModuleMock(string content)
                 {
                     if (index - 1 >= lines.Count)
                     {
-                        lines.Add(newLine);
+                        lines.AddRange(newLine.Split(new[] {Environment.NewLine}, StringSplitOptions.None));
                     }
                     else
                     {
-                        lines.Insert(index - 1, newLine);
+                        lines.InsertRange(index - 1, newLine.Split(new[] { Environment.NewLine }, StringSplitOptions.None));
                     }
                 });
 
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodExtractionTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodExtractionTests.cs
@@ -7,6 +7,7 @@
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodeModule;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodModelTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodModelTests.cs
@@ -8,6 +8,7 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodParameterClassificationTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodParameterClassificationTests.cs
@@ -10,6 +10,7 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodSelectionValidationTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodSelectionValidationTests.cs
@@ -2,6 +2,7 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractMethodTests.cs
@@ -5,6 +5,7 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/ExtractMethod/ExtractedMethodRefactoringTests.cs b/RubberduckTests/Refactoring/ExtractMethod/ExtractedMethodRefactoringTests.cs
@@ -6,6 +6,7 @@
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodeModule;
+using RubberduckTests.Mocks;
 
 namespace RubberduckTests.Refactoring.ExtractMethod
 {
diff --git a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs
diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj

Original file line number	Diff line number	Diff line change
`@@ -228,9 +228,9 @@ public ObservableCollection<CodeExplorerItemViewModel> Projects`
`228`	`228`	`get { return _projects; }`
`229`	`229`	`set`
`230`	`230`	`{`
	`231`	`+ ReorderChildNodes(value);`
`231`	`232`	`_projects = new ObservableCollection<CodeExplorerItemViewModel>(value.OrderBy(o => o.NameWithSignature));`
`232`		`-`
`233`		`- ReorderChildNodes(_projects);`
	`233`	`+`
`234`	`234`	`OnPropertyChanged();`
`235`	`235`	`}`
`236`	`236`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ private void MoveCloserToUsage()`
`110`	`110`
`111`	`111`	`private void _state_StateChanged(object sender, ParserStateEventArgs e)`
`112`	`112`	`{`
`113`		`- if (e.State != ParserState.ResolvedDeclarations) { return; }`
	`113`	`+ if (e.State != ParserState.Ready) { return; }`
`114`	`114`
`115`	`115`	`var newTarget = _state.AllUserDeclarations.FirstOrDefault(`
`116`	`116`	`item => item.ComponentName == _target.ComponentName &&`
`@@ -121,7 +121,7 @@ private void _state_StateChanged(object sender, ParserStateEventArgs e)`
`121`	`121`
`122`	`122`	`if (newTarget != null)`
`123`	`123`	`{`
`124`		`- UpdateCallsToOtherModule(newTarget.References);`
	`124`	`+ UpdateCallsToOtherModule(newTarget.References.ToList());`
`125`	`125`	`RemoveField(newTarget);`
`126`	`126`	`}`
`127`	`127`
`@@ -273,20 +273,28 @@ private string RemoveExtraComma(string str, int numParams, int indexRemoved)`
`273`	`273`	`return str.Remove(str.NthIndexOf(',', commaToRemove), 1);`
`274`	`274`	`}`
`275`	`275`
`276`		`- private void UpdateCallsToOtherModule(IEnumerable<IdentifierReference> references)`
	`276`	`+ private void UpdateCallsToOtherModule(List<IdentifierReference> references)`
`277`	`277`	`{`
`278`		`- var identifierReferences = references.ToList();`
	`278`	`+ if (!references.Any())`
	`279`	`+ {`
	`280`	`+ return;`
	`281`	`+ }`
`279`	`282`
`280`		`- var module = identifierReferences[0].QualifiedModuleName.Component.CodeModule;`
	`283`	`+ var module = references[0].QualifiedModuleName.Component.CodeModule;`
`281`	`284`
`282`		`- foreach (var reference in identifierReferences.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(t => t.Selection.StartColumn))`
	`285`	`+ foreach (var reference in references.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(t => t.Selection.StartColumn))`
`283`	`286`	`{`
`284`	`287`	`var parent = reference.Context.Parent;`
`285`		`- while (!(parent is VBAParser.MemberAccessExprContext))`
	`288`	`+ while (!(parent is VBAParser.MemberAccessExprContext) && parent.Parent != null)`
`286`	`289`	`{`
`287`	`290`	`parent = parent.Parent;`
`288`	`291`	`}`
`289`	`292`
	`293`	`+ if (!(parent is VBAParser.MemberAccessExprContext))`
	`294`	`+ {`
	`295`	`+ continue;`
	`296`	`+ }`
	`297`	`+`
`290`	`298`	`var parentSelection = ((VBAParser.MemberAccessExprContext)parent).GetSelection();`
`291`	`299`
`292`	`300`	`var oldText = module.Lines[parentSelection.StartLine, parentSelection.LineCount];`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,12 @@`
`6`	`6`	`using Rubberduck.Parsing.Symbols;`
`7`	`7`	`using Rubberduck.Parsing.VBA;`
`8`	`8`	`using Rubberduck.VBEditor;`
`9`		`-using RubberduckTests.Mocks;`
`10`	`9`	`using Rubberduck.Parsing.Preprocessing;`
`11`	`10`	`using System.Globalization;`
`12`	`11`	`using System.Threading;`
`13`	`12`	`using Rubberduck.Parsing;`
`14`	`13`
`15`		`-namespace RubberduckTests`
	`14`	`+namespace RubberduckTests.Mocks`
`16`	`15`	`{`
`17`	`16`	`public static class MockParser`
`18`	`17`	`{`
`@@ -24,7 +23,7 @@ public static void ParseString(string inputCode, out QualifiedModuleName qualifi`
`24`	`23`	`VBComponent component;`
`25`	`24`	`var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);`
`26`	`25`	`qualifiedModuleName = new QualifiedModuleName(component);`
`27`		`- var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));`
	`26`	`+ var parser = Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));`
`28`	`27`
`29`	`28`	`parser.Parse(new CancellationTokenSource());`
`30`	`29`	`if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }`
`@@ -43,7 +42,7 @@ public static RubberduckParser Create(VBE vbe, RubberduckParserState state, IAtt`
`43`	`42`	`{`
`44`	`43`	`return new RubberduckParser(state, attributeParser,`
`45`	`44`	`() => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture)),`
`46`		`- new List<ICustomDeclarationLoader> {new DebugDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state)});`
	`45`	`+ new List<ICustomDeclarationLoader> {new DebugDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state)}, true);`
`47`	`46`	`}`
`48`	`47`	`}`
`49`	`48`	`}`