sync with main repo

RetailCoder.VBE/API/ParserState.cs

@@ -63,12 +63,12 @@ public void Initialize(VBE vbe)
                 throw new InvalidOperationException("ParserState is already initialized.");
             }
 
-            _state = new RubberduckParserState(vbe, new Sinks(vbe));
+            _state = new RubberduckParserState(new Sinks(vbe));
             _state.StateChanged += _state_StateChanged;
 
             Func<IVBAPreprocessor> preprocessorFactory = () => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture));
             _attributeParser = new AttributeParser(new ModuleExporter(), preprocessorFactory);
-            _parser = new RubberduckParser(_state, _attributeParser, preprocessorFactory,
+            _parser = new RubberduckParser(vbe, _state, _attributeParser, preprocessorFactory,
                 new List<ICustomDeclarationLoader> { new DebugDeclarations(_state), new FormEventDeclarations(_state), new AliasDeclarations(_state) });
         }
 

RetailCoder.VBE/App.cs

@@ -205,6 +205,7 @@ public void Dispose()
             {
                 _parser.State.StateChanged -= Parser_StateChanged;
                 _parser.State.StatusMessageUpdate -= State_StatusMessageUpdate;
+                _parser.State.Dispose();
                 _parser.Dispose();
                 // I won't set this to null because other components may try to release things
             }

RetailCoder.VBE/Inspections/ConvertToProcedureQuickFix.cs

@@ -6,24 +6,18 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
-using Microsoft.Vbe.Interop;
 using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections
 {
     public class ConvertToProcedureQuickFix : CodeInspectionQuickFix
     {
-        private readonly IEnumerable<string> _returnStatements;
+        private readonly Declaration _target;
 
-        public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection)
-            : this(context, selection, new List<string>())
-        {
-        }
-
-        public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection, IEnumerable<string> returnStatements)
+        public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target)
             : base(context, selection, InspectionsUI.ConvertFunctionToProcedureQuickFix)
         {
-            _returnStatements = returnStatements;
+            _target = target;
         }
 
         public override void Fix()
@@ -37,47 +31,53 @@ public override void Fix()
                 throw new InvalidOperationException(string.Format(InspectionsUI.InvalidContextTypeInspectionFix, Context.GetType(), GetType()));
             }
 
+            var functionName = Context is VBAParser.FunctionStmtContext
+                ? ((VBAParser.FunctionStmtContext) Context).functionName()
+                : ((VBAParser.PropertyGetStmtContext) Context).functionName();
 
-            VBAParser.FunctionNameContext functionName = null;
-            if (Context is VBAParser.FunctionStmtContext)
-            {
-                functionName = ((VBAParser.FunctionStmtContext)Context).functionName();
-            }
-            else
-            {
-                functionName = ((VBAParser.PropertyGetStmtContext)Context).functionName();
-            }
-
-            string token = functionContext != null
+            var token = functionContext != null
                 ? Tokens.Function
                 : Tokens.Property + ' ' + Tokens.Get;
-            string endToken = token == Tokens.Function
+            var endToken = token == Tokens.Function
                 ? token
                 : Tokens.Property;
 
             string visibility = context.visibility() == null ? string.Empty : context.visibility().GetText() + ' ';
-            string name = ' ' + Identifier.GetName(functionName.identifier());
-            bool hasTypeHint = Identifier.GetTypeHintValue(functionName.identifier()) != null;
+            var name = ' ' + Identifier.GetName(functionName.identifier());
+            var hasTypeHint = Identifier.GetTypeHintValue(functionName.identifier()) != null;
 
             string args = context.argList().GetText();
             string asType = context.asTypeClause() == null ? string.Empty : ' ' + context.asTypeClause().GetText();
 
-            string oldSignature = visibility + token + name + (hasTypeHint ? Identifier.GetTypeHintValue(functionName.identifier()) : string.Empty) + args + asType;
-            string newSignature = visibility + Tokens.Sub + name + args;
+            var oldSignature = visibility + token + name + (hasTypeHint ? Identifier.GetTypeHintValue(functionName.identifier()) : string.Empty) + args + asType;
+            var newSignature = visibility + Tokens.Sub + name + args;
 
-            string procedure = Context.GetText();
-            string noReturnStatements = procedure;
-            _returnStatements.ToList().ForEach(returnStatement =>
+            var procedure = Context.GetText();
+            var noReturnStatements = procedure;
+
+            GetReturnStatements(_target).ToList().ForEach(returnStatement =>
                 noReturnStatements = Regex.Replace(noReturnStatements, @"[ \t\f]*" + returnStatement + @"[ \t\f]*\r?\n?", ""));
-            string result = noReturnStatements.Replace(oldSignature, newSignature)
+            var result = noReturnStatements.Replace(oldSignature, newSignature)
                 .Replace(Tokens.End + ' ' + endToken, Tokens.End + ' ' + Tokens.Sub)
                 .Replace(Tokens.Exit + ' ' + endToken, Tokens.Exit + ' ' + Tokens.Sub);
 
-            CodeModule module = Selection.QualifiedName.Component.CodeModule;
-            Selection selection = Context.GetSelection();
+            var module = Selection.QualifiedName.Component.CodeModule;
+            var selection = Context.GetSelection();
 
             module.DeleteLines(selection.StartLine, selection.LineCount);
             module.InsertLines(selection.StartLine, result);
         }
+
+        private IEnumerable<string> GetReturnStatements(Declaration declaration)
+        {
+            return declaration.References
+                .Where(usage => IsReturnStatement(declaration, usage))
+                .Select(usage => usage.Context.Parent.GetText());
+        }
+
+        private bool IsReturnStatement(Declaration declaration, IdentifierReference assignment)
+        {
+            return assignment.ParentScoping.Equals(declaration) && assignment.Declaration.Equals(declaration);
+        }
     }
 }

RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspection.cs

@@ -5,11 +5,16 @@
 
 namespace Rubberduck.Inspections
 {
+    using SmartIndenter;
+
     public sealed class EncapsulatePublicFieldInspection : InspectionBase
     {
-        public EncapsulatePublicFieldInspection(RubberduckParserState state)
+        private readonly IIndenter _indenter;
+
+        public EncapsulatePublicFieldInspection(RubberduckParserState state, IIndenter indenter)
             : base(state, CodeInspectionSeverity.Suggestion)
         {
+            _indenter = indenter;
         }
 
         public override string Meta { get { return InspectionsUI.EncapsulatePublicFieldInspectionMeta; } }
@@ -21,7 +26,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             var issues = UserDeclarations
                             .Where(declaration => declaration.DeclarationType == DeclarationType.Variable
                                                 && declaration.Accessibility == Accessibility.Public)
-                            .Select(issue => new EncapsulatePublicFieldInspectionResult(this, issue, State))
+                            .Select(issue => new EncapsulatePublicFieldInspectionResult(this, issue, State, _indenter))
                             .ToList();
 
             return issues;

RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs

@@ -9,16 +9,18 @@
 
 namespace Rubberduck.Inspections
 {
+    using SmartIndenter;
+
     public class EncapsulatePublicFieldInspectionResult : InspectionResultBase
     {
         private readonly IEnumerable<CodeInspectionQuickFix> _quickFixes;
 
-        public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state)
+        public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state, IIndenter indenter)
             : base(inspection, target)
         {
             _quickFixes = new CodeInspectionQuickFix[]
             {
-                new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state),
+                new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state, indenter),
                 new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
@@ -38,22 +40,24 @@ public class EncapsulateFieldQuickFix : CodeInspectionQuickFix
     {
         private readonly Declaration _target;
         private readonly RubberduckParserState _state;
+        private readonly IIndenter _indenter;
 
-        public EncapsulateFieldQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState state)
+        public EncapsulateFieldQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState state, IIndenter indenter)
             : base(context, selection, string.Format(InspectionsUI.EncapsulatePublicFieldInspectionQuickFix, target.IdentifierName))
         {
             _target = target;
             _state = state;
+            _indenter = indenter;
         }
 
         public override void Fix()
         {
             var vbe = Selection.QualifiedName.Project.VBE;
 
-            using (var view = new EncapsulateFieldDialog())
+            using (var view = new EncapsulateFieldDialog(_state, _indenter))
             {
                 var factory = new EncapsulateFieldPresenterFactory(vbe, _state, view);
-                var refactoring = new EncapsulateFieldRefactoring(vbe, factory);
+                var refactoring = new EncapsulateFieldRefactoring(vbe, _indenter, factory);
                 refactoring.Refactor(_target);
                 IsCancelled = view.DialogResult != DialogResult.OK;
             }

RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs

@@ -46,11 +46,10 @@ private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetInterfaceMemb
                            implementationMember =>
                                Tuple.Create(implementationMember.Context,
                                    new QualifiedSelection(implementationMember.QualifiedName.QualifiedModuleName,
-                                       implementationMember.Selection), GetReturnStatements(implementationMember)))
+                                       implementationMember.Selection), implementationMember))
                    select
                        new FunctionReturnValueNotUsedInspectionResult(this, interfaceMember.Context,
-                           interfaceMember.QualifiedName, GetReturnStatements(interfaceMember),
-                           implementationMemberIssues, interfaceMember);
+                           interfaceMember.QualifiedName, implementationMemberIssues, interfaceMember);
         }
 
         private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetNonInterfaceIssues(IEnumerable<Declaration> nonInterfaceFunctions)
@@ -62,18 +61,10 @@ private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetNonInterfaceI
                             this,
                             function.Context,
                             function.QualifiedName,
-                            GetReturnStatements(function),
                             function));
             return nonInterfaceIssues;
         }
 
-        private IEnumerable<string> GetReturnStatements(Declaration function)
-        {
-            return function.References
-                .Where(usage => IsReturnStatement(function, usage))
-                .Select(usage => usage.Context.Parent.Parent.Parent.GetText());
-        }
-
         private bool IsReturnValueUsed(Declaration function)
         {
             foreach (var usage in function.References)

RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs

@@ -16,22 +16,20 @@ public FunctionReturnValueNotUsedInspectionResult(
             IInspection inspection,
             ParserRuleContext context,
             QualifiedMemberName qualifiedName,
-            IEnumerable<string> returnStatements,
             Declaration target)
-            : this(inspection, context, qualifiedName, returnStatements, new List<Tuple<ParserRuleContext, QualifiedSelection, IEnumerable<string>>>(), target)
+            : this(inspection, context, qualifiedName, new List<Tuple<ParserRuleContext, QualifiedSelection, Declaration>>(), target)
         {
         }
 
         public FunctionReturnValueNotUsedInspectionResult(
             IInspection inspection,
             ParserRuleContext context,
             QualifiedMemberName qualifiedName,
-            IEnumerable<string> returnStatements,
-            IEnumerable<Tuple<ParserRuleContext, QualifiedSelection, IEnumerable<string>>> children,
+            IEnumerable<Tuple<ParserRuleContext, QualifiedSelection, Declaration>> children,
             Declaration target)
             : base(inspection, qualifiedName.QualifiedModuleName, context, target)
         {
-            var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, returnStatements);
+            var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, target);
             var compositeFix = new CompositeCodeInspectionFix(root);
             children.ToList().ForEach(child => compositeFix.AddChild(new ConvertToProcedureQuickFix(child.Item1, child.Item2, child.Item3)));
             _quickFixes = new CodeInspectionQuickFix[]

RetailCoder.VBE/Inspections/IInspector.cs

@@ -6,7 +6,7 @@
 
 namespace Rubberduck.Inspections
 {
-    public interface IInspector
+    public interface IInspector : IDisposable
     {
         Task<IEnumerable<ICodeInspectionResult>> FindIssuesAsync(RubberduckParserState state, CancellationToken token);
     }

RetailCoder.VBE/Inspections/IParseTreeInspection.cs

@@ -25,6 +25,6 @@ public ParseTreeResults()
         public IEnumerable<QualifiedContext> ObsoleteLetContexts;
         public IEnumerable<QualifiedContext> ArgListsWithOneByRefParam;
         public IEnumerable<QualifiedContext> EmptyStringLiterals;
-        public IEnumerable<QualifiedContext<VBAParser.AnnotationContext>> MalformedAnnotations;
+        public IEnumerable<QualifiedContext> MalformedAnnotations;
     }
 }

RetailCoder.VBE/Inspections/InspectionsUI.de.resx

@@ -304,7 +304,8 @@
     <value>Variable wird genutzt ohne das ihr ein Wert zugewiesen wurde.</value>
   </data>
   <data name="UntypedFunctionUsageInspectionMeta" xml:space="preserve">
-    <value>Eine gibt eine Funktion, die einen String Äquivalnet zurückgibt. Diese sollte bevorzugt genutzt werden, um implitizite Typumwandlungen zu vermeiden.</value>
+    <value>Eine gibt eine Funktion, die einen String Äquivalent zurückgibt. Diese sollte bevorzugt genutzt werden, um implitizite Typumwandlungen zu vermeiden.
+Falls der Parameter 'null' sein kann, bitte dieses Auftreten ignorieren. 'null' an die Funktion zu übergeben, die einen String erwartet würde zu einem "Type Mismatch"-Laufzeitfehler führen.</value>
   </data>
   <data name="UntypedFunctionUsageInspectionName" xml:space="preserve">
     <value>Nutzung einer Funktion, die einen 'String Variant' zurückgibt.</value>
@@ -554,4 +555,13 @@
   <data name="MultipleDeclarationsInspectionResultFormat" xml:space="preserve">
     <value>Instruktion enthält Mehrfachdeklaration</value>
   </data>
+  <data name="MalformedAnnotationInspectionName">
+    <value>Unlesbare Annotation</value>
+  </data>
+  <data name="MalformedAnnotationInspectionResultFormat">
+    <value>Annotation '{0}' ist nicht lesbar</value>
+  </data>
+  <data name="MalformedAnnotationInspectionMeta">
+    <value>Eine Annotation in einem Kommentar konnte nicht gelesen werden.</value>
+  </data>
 </root>