Merge branch 'next' of https://github.com/rubberduck-vba/Rubberduck into next

ThunderFrame · ThunderFrame · commit 9137c48dfa30 · 2016-06-04T13:44:35.000+10:00
diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs
@@ -150,7 +150,7 @@ public void Startup()
             _appMenus.Initialize();
             _hooks.HookHotkeys(); // need to hook hotkeys before we localize menus, to correctly display ShortcutTexts
             _appMenus.Localize();
-            Task.Delay(1000).ContinueWith(t => UiDispatcher.Invoke(() => _parser.State.OnParseRequested(this))).ConfigureAwait(false);
+            Task.Delay(1000).ContinueWith(t => UiDispatcher.Invoke(() => _parser.State.OnParseRequested(this)));
             UpdateLoggingLevel();
         }
 
diff --git a/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs b/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs
@@ -4,13 +4,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.UI;
 
 namespace Rubberduck.Inspections
 {
     public class FunctionReturnValueNotUsedInspectionResult : InspectionResultBase
     {
         private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;
-        private QualifiedMemberName _memberName;
 
         public FunctionReturnValueNotUsedInspectionResult(
             IInspection inspection,
@@ -49,5 +49,10 @@ public override string Description
                 return string.Format(InspectionsUI.FunctionReturnValueNotUsedInspectionResultFormat, Target.IdentifierName);
             }
         }
+
+        public override NavigateCodeEventArgs GetNavigationArgs()
+        {
+            return new NavigateCodeEventArgs(Target);
+        }
     }
 }
diff --git a/RetailCoder.VBE/Inspections/IdentifierNotUsedInspectionResult.cs b/RetailCoder.VBE/Inspections/IdentifierNotUsedInspectionResult.cs
@@ -2,20 +2,19 @@
 using Antlr4.Runtime;
 using Rubberduck.Common;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.UI;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections
 {
     public class IdentifierNotUsedInspectionResult : InspectionResultBase
     {
-        private readonly Declaration _target;
         private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;
 
         public IdentifierNotUsedInspectionResult(IInspection inspection, Declaration target,
             ParserRuleContext context, QualifiedModuleName qualifiedName)
-            : base(inspection, qualifiedName, context)
+            : base(inspection, qualifiedName, context, target)
         {
-            _target = target;
             _quickFixes = new CodeInspectionQuickFix[]
             {
                 new RemoveUnusedDeclarationQuickFix(context, QualifiedSelection), 
@@ -28,9 +27,14 @@ public override string Description
         {
             get
             {
-                return string.Format(InspectionsUI.IdentifierNotUsedInspectionResultFormat, _target.DeclarationType.ToLocalizedString(), _target.IdentifierName);
+                return string.Format(InspectionsUI.IdentifierNotUsedInspectionResultFormat, Target.DeclarationType.ToLocalizedString(), Target.IdentifierName);
             }
         }
+
+        public override NavigateCodeEventArgs GetNavigationArgs()
+        {
+            return new NavigateCodeEventArgs(Target);
+        }
     }
 
     /// <summary>
diff --git a/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspectionResult.cs b/RetailCoder.VBE/Inspections/ImplicitPublicMemberInspectionResult.cs
@@ -3,6 +3,7 @@
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.UI;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections
@@ -30,6 +31,11 @@ public override string Description
                 return string.Format(InspectionsUI.ImplicitPublicMemberInspectionResultFormat, Target.IdentifierName);
             }
         }
+
+        public override NavigateCodeEventArgs GetNavigationArgs()
+        {
+            return new NavigateCodeEventArgs(Target);
+        }
     }
 
     public class SpecifyExplicitPublicModifierQuickFix : CodeInspectionQuickFix
diff --git a/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs b/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs
@@ -32,7 +32,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                                 && ProcedureTypes.Contains(item.DeclarationType)
                                 && !item.IsTypeSpecified
                                let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}
-                               select new ImplicitVariantReturnTypeInspectionResult(this, issue.Declaration.IdentifierName, issue.QualifiedContext);
+                               select new ImplicitVariantReturnTypeInspectionResult(this, issue.Declaration.IdentifierName, issue.QualifiedContext, item);
             return issues;
         }
     }
diff --git a/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspectionResult.cs b/RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspectionResult.cs
@@ -2,7 +2,9 @@
 using Antlr4.Runtime;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA.Nodes;
+using Rubberduck.UI;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections
@@ -12,8 +14,8 @@ public sealed class ImplicitVariantReturnTypeInspectionResult : InspectionResult
         private readonly string _identifierName;
         private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;
 
-        public ImplicitVariantReturnTypeInspectionResult(IInspection inspection, string identifierName, QualifiedContext<ParserRuleContext> qualifiedContext)
-            : base(inspection, qualifiedContext.ModuleName, qualifiedContext.Context)
+        public ImplicitVariantReturnTypeInspectionResult(IInspection inspection, string identifierName, QualifiedContext<ParserRuleContext> qualifiedContext, Declaration target)
+            : base(inspection, qualifiedContext.ModuleName, qualifiedContext.Context, target)
         {
             _identifierName = identifierName;
             _quickFixes = new CodeInspectionQuickFix[]
@@ -33,6 +35,11 @@ public override string Description
                     _identifierName);
             }
         }
+
+        public override NavigateCodeEventArgs GetNavigationArgs()
+        {
+            return new NavigateCodeEventArgs(Target);
+        }
     }
 
     public class SetExplicitVariantReturnTypeQuickFix : CodeInspectionQuickFix
diff --git a/RetailCoder.VBE/Inspections/InspectionResultBase.cs b/RetailCoder.VBE/Inspections/InspectionResultBase.cs
@@ -108,7 +108,7 @@ public override string ToString()
                 QualifiedSelection.Selection.StartLine);
         }
 
-        public NavigateCodeEventArgs GetNavigationArgs()
+        public virtual NavigateCodeEventArgs GetNavigationArgs()
         {
             return new NavigateCodeEventArgs(QualifiedSelection);
         }
diff --git a/RetailCoder.VBE/Inspections/Inspector.cs b/RetailCoder.VBE/Inspections/Inspector.cs
@@ -55,11 +55,8 @@ public async Task<IEnumerable<ICodeInspectionResult>> FindIssuesAsync(Rubberduck
                     return new ICodeInspectionResult[] { };
                 }
 
-                await Task.Yield();
-
                 state.OnStatusMessageUpdate(RubberduckUI.CodeInspections_Inspecting);
                 UpdateInspectionSeverity();
-                //OnReset();
 
                 var allIssues = new ConcurrentBag<ICodeInspectionResult>();
 
@@ -72,31 +69,23 @@ public async Task<IEnumerable<ICodeInspectionResult>> FindIssuesAsync(Rubberduck
 
                 var inspections = _inspections.Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow)
                     .Select(inspection =>
-                        new Task(() =>
+                        Task.Run(() =>
                         {
                             token.ThrowIfCancellationRequested();
                             var inspectionResults = inspection.GetInspectionResults();
                             var results = inspectionResults as IEnumerable<InspectionResultBase> ?? inspectionResults;
 
                             if (results.Any())
                             {
-                                //OnIssuesFound(results);
-
                                 foreach (var inspectionResult in results)
                                 {
                                     allIssues.Add(inspectionResult);
                                 }
                             }
-                        })).ToArray();
-
-                foreach (var inspection in inspections)
-                {
-                    inspection.Start();
-                }
+                        })).ToList();
 
-                Task.WaitAll(inspections);
+                await Task.WhenAll(inspections);
                 state.OnStatusMessageUpdate(RubberduckUI.ResourceManager.GetString("ParserState_" + state.Status)); // should be "Ready"
-
                 return allIssues;
             }
 
diff --git a/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs b/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs
@@ -2,6 +2,7 @@
 using Antlr4.Runtime;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.UI;
 
 namespace Rubberduck.Inspections
 {
@@ -33,5 +34,10 @@ public override string Description
                 return string.Format(InspectionsUI.NonReturningFunctionInspectionResultFormat, Target.IdentifierName);
             }
         }
+
+        public override NavigateCodeEventArgs GetNavigationArgs()
+        {
+            return new NavigateCodeEventArgs(Target);
+        }
     }
 }
diff --git a/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodSelectionValidation.cs b/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodSelectionValidation.cs
@@ -15,7 +15,7 @@ public class ExtractMethodSelectionValidation : IExtractMethodSelectionValidatio
         private IEnumerable<Declaration> _declarations;
 
 
-        
+
         public ExtractMethodSelectionValidation(IEnumerable<Declaration> declarations)
         {
             _declarations = declarations;
@@ -56,10 +56,15 @@ public bool withinSingleProcedure(QualifiedSelection qualifiedSelection)
             {
                 procStartContext = procStart.Context as VBAParser.SubStmtContext;
             }
+            // TOOD: Doesn't support properties.
+            if (procStartContext == null)
+            {
+                return false;
+            }
             var procEndOfSignature = procStartContext.endOfStatement() as VBAParser.EndOfStatementContext;
             var procSignatureLastLine = procEndOfSignature.Start.Line;
 
-            return (procEnd as Declaration).QualifiedSelection.Equals((procStart as Declaration).QualifiedSelection) 
+            return (procEnd as Declaration).QualifiedSelection.Equals((procStart as Declaration).QualifiedSelection)
                 && (procSignatureLastLine < startLine);
 
         }
diff --git a/RetailCoder.VBE/UI/Inspections/InspectionImageSourceConverter.cs b/RetailCoder.VBE/UI/Inspections/InspectionImageSourceConverter.cs
@@ -21,7 +21,8 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            throw new NotImplementedException();
+            var converter = new InspectionSeverityImageSourceConverter();
+            return converter.ConvertBack(value, targetType, parameter, culture);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Inspections/InspectionResultsControl.xaml b/RetailCoder.VBE/UI/Inspections/InspectionResultsControl.xaml
@@ -554,7 +554,7 @@
                                ItemsSource="{Binding Source={StaticResource ResultsByInspectionType}}"
                                Visibility="{Binding IsChecked, ElementName=GroupByInspectionType, Converter={StaticResource BoolToVisibility}}">
             <DataGrid.Columns>
-                <DataGridTemplateColumn Header="{Resx ResxName=Rubberduck.UI.RubberduckUI, Key=CodeInspectionResults_Type}">
+                <DataGridTemplateColumn Header="{Resx ResxName=Rubberduck.UI.RubberduckUI, Key=CodeInspectionResults_Type}" SortDirection="Descending">
                     <DataGridTemplateColumn.CellTemplate>
                         <DataTemplate DataType="inspections:ICodeInspectionResult">
                             <Image Source="{Binding Inspection, Converter={StaticResource InspectionIconConverter}}" Height="16" />
diff --git a/RetailCoder.VBE/UI/Inspections/InspectionSeverityImageSourceConverter.cs b/RetailCoder.VBE/UI/Inspections/InspectionSeverityImageSourceConverter.cs
@@ -3,6 +3,7 @@
 using System.Drawing;
 using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Windows.Data;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
@@ -15,7 +16,6 @@ public class InspectionSeverityImageSourceConverter : IValueConverter
         private static readonly IDictionary<CodeInspectionSeverity,ImageSource> Icons = 
             new Dictionary<CodeInspectionSeverity, ImageSource>
             {
-                { CodeInspectionSeverity.DoNotShow, null },
                 { CodeInspectionSeverity.Hint, ToImageSource(Properties.Resources.information_white) },
                 { CodeInspectionSeverity.Suggestion, ToImageSource(Properties.Resources.information) },
                 { CodeInspectionSeverity.Warning, ToImageSource(Properties.Resources.exclamation) },
@@ -35,7 +35,7 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            throw new NotImplementedException();
+            return Icons.First(f => f.Value == value).Key;
         }
 
         private static ImageSource ToImageSource(Image source)
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -45,6 +45,7 @@
     <Reference Include="Antlr4.Runtime.net45">
       <HintPath>..\packages\Antlr4.Runtime.4.3.0\lib\net45\Antlr4.Runtime.net45.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.Build.Tasks.v4.0" />
     <Reference Include="Microsoft.Vbe.Interop, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c">
       <SpecificVersion>False</SpecificVersion>
       <EmbedInteropTypes>False</EmbedInteropTypes>
@@ -126,6 +127,8 @@
     <Compile Include="Preprocessing\VBAConditionalCompilationParserBaseVisitor.cs" />
     <Compile Include="Preprocessing\VBAConditionalCompilationParserListener.cs" />
     <Compile Include="Preprocessing\VBAConditionalCompilationParserVisitor.cs" />
+    <Compile Include="Symbols\ComInformation.cs" />
+    <Compile Include="Symbols\ComParameter.cs" />
     <Compile Include="Symbols\Identifier.cs" />
     <Compile Include="Binding\IBindingContext.cs" />
     <Compile Include="Binding\IBoundExpression.cs" />
diff --git a/Rubberduck.Parsing/Symbols/ComInformation.cs b/Rubberduck.Parsing/Symbols/ComInformation.cs
@@ -0,0 +1,33 @@
+﻿using System.Runtime.InteropServices.ComTypes;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Parsing.Symbols
+{
+    public class ComInformation
+    {
+        public ComInformation(TYPEATTR typeAttributes, IMPLTYPEFLAGS implTypeFlags, ITypeInfo typeInfo, string typeName, QualifiedModuleName typeModuleName, Declaration moduleDeclaration, DeclarationType typeDeclarationType)
+        {
+            TypeAttributes = typeAttributes;
+            ImplTypeFlags = implTypeFlags;
+            TypeInfo = typeInfo;
+            TypeName = typeName;
+            TypeQualifiedModuleName = typeModuleName;
+            ModuleDeclaration = moduleDeclaration;
+            TypeDeclarationType = typeDeclarationType;
+        }
+
+        public TYPEATTR TypeAttributes { get; internal set; }
+        public IMPLTYPEFLAGS ImplTypeFlags { get; internal set; }
+        public ITypeInfo TypeInfo { get; internal set; }
+
+        public string TypeName { get; internal set; }
+        public QualifiedModuleName TypeQualifiedModuleName { get; internal set; }
+        public Declaration ModuleDeclaration { get; internal set; }
+        public DeclarationType TypeDeclarationType { get; internal set; }
+
+        public override string ToString()
+        {
+            return ModuleDeclaration.IdentifierName;
+        }
+    }
+}
diff --git a/Rubberduck.Parsing/Symbols/ComParameter.cs b/Rubberduck.Parsing/Symbols/ComParameter.cs
@@ -0,0 +1,21 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Rubberduck.Parsing.Symbols
+{
+    public class ComParameter
+    {
+        public bool IsArray { get; set; }
+        public bool IsByRef { get; set;}
+        public string Name { get; set;}
+
+        public ComParameter(string name, bool byRef)
+        {
+            Name = name;
+            IsByRef = byRef;
+        }
+    }
+}
diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs
diff --git a/Rubberduck.Parsing/Symbols/ParameterDeclaration.cs b/Rubberduck.Parsing/Symbols/ParameterDeclaration.cs
diff --git a/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs b/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs
diff --git a/Rubberduck.Parsing/VBA/AttributeParser.cs b/Rubberduck.Parsing/VBA/AttributeParser.cs
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
diff --git a/RubberduckTests/Grammar/ResolverTests.cs b/RubberduckTests/Grammar/ResolverTests.cs
diff --git a/RubberduckTests/Settings/IndenterSettingsTests.cs b/RubberduckTests/Settings/IndenterSettingsTests.cs

Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ public void Startup()`
`150`	`150`	`_appMenus.Initialize();`
`151`	`151`	`_hooks.HookHotkeys(); // need to hook hotkeys before we localize menus, to correctly display ShortcutTexts`
`152`	`152`	`_appMenus.Localize();`
`153`		`- Task.Delay(1000).ContinueWith(t => UiDispatcher.Invoke(() => _parser.State.OnParseRequested(this))).ConfigureAwait(false);`
	`153`	`+ Task.Delay(1000).ContinueWith(t => UiDispatcher.Invoke(() => _parser.State.OnParseRequested(this)));`
`154`	`154`	`UpdateLoggingLevel();`
`155`	`155`	`}`
`156`	`156`
Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,13 @@`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Linq;`
`6`	`6`	`using Rubberduck.Parsing.Symbols;`
	`7`	`+using Rubberduck.UI;`
`7`	`8`
`8`	`9`	`namespace Rubberduck.Inspections`
`9`	`10`	`{`
`10`	`11`	`public class FunctionReturnValueNotUsedInspectionResult : InspectionResultBase`
`11`	`12`	`{`
`12`	`13`	`private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;`
`13`		`- private QualifiedMemberName _memberName;`
`14`	`14`
`15`	`15`	`public FunctionReturnValueNotUsedInspectionResult(`
`16`	`16`	`IInspection inspection,`
`@@ -49,5 +49,10 @@ public override string Description`
`49`	`49`	`return string.Format(InspectionsUI.FunctionReturnValueNotUsedInspectionResultFormat, Target.IdentifierName);`
`50`	`50`	`}`
`51`	`51`	`}`
	`52`	`+`
	`53`	`+ public override NavigateCodeEventArgs GetNavigationArgs()`
	`54`	`+ {`
	`55`	`+ return new NavigateCodeEventArgs(Target);`
	`56`	`+ }`
`52`	`57`	`}`
`53`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,20 +2,19 @@`
`2`	`2`	`using Antlr4.Runtime;`
`3`	`3`	`using Rubberduck.Common;`
`4`	`4`	`using Rubberduck.Parsing.Symbols;`
	`5`	`+using Rubberduck.UI;`
`5`	`6`	`using Rubberduck.VBEditor;`
`6`	`7`
`7`	`8`	`namespace Rubberduck.Inspections`
`8`	`9`	`{`
`9`	`10`	`public class IdentifierNotUsedInspectionResult : InspectionResultBase`
`10`	`11`	`{`
`11`		`- private readonly Declaration _target;`
`12`	`12`	`private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;`
`13`	`13`
`14`	`14`	`public IdentifierNotUsedInspectionResult(IInspection inspection, Declaration target,`
`15`	`15`	`ParserRuleContext context, QualifiedModuleName qualifiedName)`
`16`		`- : base(inspection, qualifiedName, context)`
	`16`	`+ : base(inspection, qualifiedName, context, target)`
`17`	`17`	`{`
`18`		`- _target = target;`
`19`	`18`	`_quickFixes = new CodeInspectionQuickFix[]`
`20`	`19`	`{`
`21`	`20`	`new RemoveUnusedDeclarationQuickFix(context, QualifiedSelection),`
`@@ -28,9 +27,14 @@ public override string Description`
`28`	`27`	`{`
`29`	`28`	`get`
`30`	`29`	`{`
`31`		`- return string.Format(InspectionsUI.IdentifierNotUsedInspectionResultFormat, _target.DeclarationType.ToLocalizedString(), _target.IdentifierName);`
	`30`	`+ return string.Format(InspectionsUI.IdentifierNotUsedInspectionResultFormat, Target.DeclarationType.ToLocalizedString(), Target.IdentifierName);`
`32`	`31`	`}`
`33`	`32`	`}`
	`33`	`+`
	`34`	`+ public override NavigateCodeEventArgs GetNavigationArgs()`
	`35`	`+ {`
	`36`	`+ return new NavigateCodeEventArgs(Target);`
	`37`	`+ }`
`34`	`38`	`}`
`35`	`39`
`36`	`40`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using Rubberduck.Parsing;`
`4`	`4`	`using Rubberduck.Parsing.Grammar;`
`5`	`5`	`using Rubberduck.Parsing.Symbols;`
	`6`	`+using Rubberduck.UI;`
`6`	`7`	`using Rubberduck.VBEditor;`
`7`	`8`
`8`	`9`	`namespace Rubberduck.Inspections`
`@@ -30,6 +31,11 @@ public override string Description`
`30`	`31`	`return string.Format(InspectionsUI.ImplicitPublicMemberInspectionResultFormat, Target.IdentifierName);`
`31`	`32`	`}`
`32`	`33`	`}`
	`34`	`+`
	`35`	`+ public override NavigateCodeEventArgs GetNavigationArgs()`
	`36`	`+ {`
	`37`	`+ return new NavigateCodeEventArgs(Target);`
	`38`	`+ }`
`33`	`39`	`}`
`34`	`40`
`35`	`41`	`public class SpecifyExplicitPublicModifierQuickFix : CodeInspectionQuickFix`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()`
`32`	`32`	`&& ProcedureTypes.Contains(item.DeclarationType)`
`33`	`33`	`&& !item.IsTypeSpecified`
`34`	`34`	`let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}`
`35`		`- select new ImplicitVariantReturnTypeInspectionResult(this, issue.Declaration.IdentifierName, issue.QualifiedContext);`
	`35`	`+ select new ImplicitVariantReturnTypeInspectionResult(this, issue.Declaration.IdentifierName, issue.QualifiedContext, item);`
`36`	`36`	`return issues;`
`37`	`37`	`}`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public override string ToString()`
`108`	`108`	`QualifiedSelection.Selection.StartLine);`
`109`	`109`	`}`
`110`	`110`
`111`		`- public NavigateCodeEventArgs GetNavigationArgs()`
	`111`	`+ public virtual NavigateCodeEventArgs GetNavigationArgs()`
`112`	`112`	`{`
`113`	`113`	`return new NavigateCodeEventArgs(QualifiedSelection);`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,11 +55,8 @@ public async Task<IEnumerable<ICodeInspectionResult>> FindIssuesAsync(Rubberduck`
`55`	`55`	`return new ICodeInspectionResult[] { };`
`56`	`56`	`}`
`57`	`57`
`58`		`- await Task.Yield();`
`59`		`-`
`60`	`58`	`state.OnStatusMessageUpdate(RubberduckUI.CodeInspections_Inspecting);`
`61`	`59`	`UpdateInspectionSeverity();`
`62`		`- //OnReset();`
`63`	`60`
`64`	`61`	`var allIssues = new ConcurrentBag<ICodeInspectionResult>();`
`65`	`62`
`@@ -72,31 +69,23 @@ public async Task<IEnumerable<ICodeInspectionResult>> FindIssuesAsync(Rubberduck`
`72`	`69`
`73`	`70`	`var inspections = _inspections.Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow)`
`74`	`71`	`.Select(inspection =>`
`75`		`- new Task(() =>`
	`72`	`+ Task.Run(() =>`
`76`	`73`	`{`
`77`	`74`	`token.ThrowIfCancellationRequested();`
`78`	`75`	`var inspectionResults = inspection.GetInspectionResults();`
`79`	`76`	`var results = inspectionResults as IEnumerable<InspectionResultBase> ?? inspectionResults;`
`80`	`77`
`81`	`78`	`if (results.Any())`
`82`	`79`	`{`
`83`		`- //OnIssuesFound(results);`
`84`		`-`
`85`	`80`	`foreach (var inspectionResult in results)`
`86`	`81`	`{`
`87`	`82`	`allIssues.Add(inspectionResult);`
`88`	`83`	`}`
`89`	`84`	`}`
`90`		`- })).ToArray();`
`91`		`-`
`92`		`- foreach (var inspection in inspections)`
`93`		`- {`
`94`		`- inspection.Start();`
`95`		`- }`
	`85`	`+ })).ToList();`
`96`	`86`
`97`		`- Task.WaitAll(inspections);`
	`87`	`+ await Task.WhenAll(inspections);`
`98`	`88`	`state.OnStatusMessageUpdate(RubberduckUI.ResourceManager.GetString("ParserState_" + state.Status)); // should be "Ready"`
`99`		`-`
`100`	`89`	`return allIssues;`
`101`	`90`	`}`
`102`	`91`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using Antlr4.Runtime;`
`3`	`3`	`using Rubberduck.Parsing;`
`4`	`4`	`using Rubberduck.Parsing.Symbols;`
	`5`	`+using Rubberduck.UI;`
`5`	`6`
`6`	`7`	`namespace Rubberduck.Inspections`
`7`	`8`	`{`
`@@ -33,5 +34,10 @@ public override string Description`
`33`	`34`	`return string.Format(InspectionsUI.NonReturningFunctionInspectionResultFormat, Target.IdentifierName);`
`34`	`35`	`}`
`35`	`36`	`}`
	`37`	`+`
	`38`	`+ public override NavigateCodeEventArgs GetNavigationArgs()`
	`39`	`+ {`
	`40`	`+ return new NavigateCodeEventArgs(Target);`
	`41`	`+ }`
`36`	`42`	`}`
`37`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class ExtractMethodSelectionValidation : IExtractMethodSelectionValidatio`
`15`	`15`	`private IEnumerable<Declaration> _declarations;`
`16`	`16`
`17`	`17`
`18`		`-`
	`18`	`+`
`19`	`19`	`public ExtractMethodSelectionValidation(IEnumerable<Declaration> declarations)`
`20`	`20`	`{`
`21`	`21`	`_declarations = declarations;`
`@@ -56,10 +56,15 @@ public bool withinSingleProcedure(QualifiedSelection qualifiedSelection)`
`56`	`56`	`{`
`57`	`57`	`procStartContext = procStart.Context as VBAParser.SubStmtContext;`
`58`	`58`	`}`
	`59`	`+ // TOOD: Doesn't support properties.`
	`60`	`+ if (procStartContext == null)`
	`61`	`+ {`
	`62`	`+ return false;`
	`63`	`+ }`
`59`	`64`	`var procEndOfSignature = procStartContext.endOfStatement() as VBAParser.EndOfStatementContext;`
`60`	`65`	`var procSignatureLastLine = procEndOfSignature.Start.Line;`
`61`	`66`
`62`		`- return (procEnd as Declaration).QualifiedSelection.Equals((procStart as Declaration).QualifiedSelection)`
	`67`	`+ return (procEnd as Declaration).QualifiedSelection.Equals((procStart as Declaration).QualifiedSelection)`
`63`	`68`	`&& (procSignatureLastLine < startLine);`
`64`	`69`
`65`	`70`	`}`