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

Conflicts takes the HEAD, rather than MERGE_HEAD in order to compare with Vogel's changes.

# Conflicts:
#	Rubberduck.CodeAnalysis/QuickFixes/EncapsulateFieldQuickFix.cs
#	Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs
#	Rubberduck.CodeAnalysis/QuickFixes/RenameDeclarationQuickFix.cs
#	Rubberduck.Core/UI/CodeExplorer/Commands/RenameCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/ProjectExplorerRefactorRenameCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs
#	Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs
#	Rubberduck.Core/UI/Refactorings/EncapsulateField/EncapsulateFieldPresenter.cs
#	Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs
#	Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs
#	Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs
#	Rubberduck.Refactorings/Rename/RenameRefactoring.cs
#	Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs
#	RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs
#	RubberduckTests/Refactoring/RenameTests.cs

Author: bclothier

CONTRIBUTING.md

@@ -61,15 +61,15 @@ Our Ducky has come quite the long way and is intimidatingly large for a first-ti
 To make it easier to find something you can do, all issues with that label are additionally labelled with a difficulty.
 That difficulty level is a best-guess by the dev-team how complex or evil an issue will be.
 
-If you're new to C#, we recommend you start with \[difficulty-01-duckling\]. The next step \[difficulty-02-ducky\] requires some knowledge about C#, but not so much about how Rubberduck works
+If you're new to C#, we recommend you start with \[difficulty-01-duckling\]. The next step \[difficulty-02-ducky\] requires some knowledge about C#, but not so much about how Rubberduck works - 02/ducky issues usually make a good introduction to using Rubberduck's internal API.
 
-Then there's \[difficulty-03-duck\] which requires a good handle on C# and at least an idea of how the components of Rubberduck play toghether.
+Then there's \[difficulty-03-duck\] which requires a good handle on C# and how the components of Rubberduck play toghether.
 And finally there's \[difficulty-04-quackhead\] for when you really want to bang your head against the wall.
-They require both good knowledge of C# and a deep understanding of how Rubberduck works.
+They require both good knowledge of C# and a deep understanding of how not only Rubberduck, but also COM and well, the VBE, works.
 
 In addition to this, a few people have put together some helpful resources about how Rubberduck works internally and help contributors tell left from right in the ~250k Lines of Code.
 
-You can find their work in the [github wiki](https://github.com/rubberduck-vba/Rubberduck/wiki). If something in there doesn't quite seem to match, it's probably because nobody got around to updating it yet. You're very welcome to **improve** the wiki by adding and correcting information. (see right above)
+You can find their work in the [GitHub wiki](https://github.com/rubberduck-vba/Rubberduck/wiki). If something in there doesn't quite seem to match, it's probably because nobody got around to updating it yet. You're very welcome to **improve** the wiki by adding and correcting information. (see right above)
 
 In case this doesn't quite help you or the information you need hasn't been added to the wiki, you can **always** ask questions.
 Please do so in the ["War room"](https://chat.stackexchange.com/rooms/14929).
@@ -79,21 +79,21 @@ Other than that, you can also open an issue with the label \[support\], but it m
 In that room the core team talks about the duck and whatever else comes up.
 N.B.: The rules of the Stack Exchange Network apply to everything you say in that room. But basically those are the same rules as those in the [CoC](#Code_of_Conduct).
 
-Whether you create an issue or a pull request, please avoid using `[` square brackets `]` in the title, and try to be as descriptive (but succinct) as possible. Square brackets in titles confuse our chat-bot, and end up rendering in weird broken ways in SE chat. Avoid riddles, bad puns and other would-be funny (or NSFW) titles that don't really describe the issue or PR.
+Whether you create an issue or a pull request, please avoid using `[` square brackets `]` in the title, and try to be as descriptive (but succinct) as possible. Square brackets in titles confuse our chat-bot, and end up rendering in weird broken ways in SE chat. Avoid riddles, bad puns and other would-be funny (or NSFW) titles that don't really *describe the issue or PR*.
 
 ### Translations
 
-Rubberduck is Localized in multiple languages.
+Rubberduck is localized in multiple languages.
 All these translations have been provided by volunteers.
 We welcome both new translations as well as improvements to current translations very much.
 
-The resource files are RESX/XML files easily editable in any text editor, but comparing resource keys across languages/translations is much easier done with @Vogel612's [Translation Helper](https://github.com/Vogel612/TranslationHelper) tool, which automatically adds missing keys and highlights entries that need a new translation.
+The resource files are RESX/XML files easily editable in any text editor, but our recommendation goes to the [ResXManager](https://marketplace.visualstudio.com/items?itemName=TomEnglert.ResXManager) Visual Studio plug-in:
 
-If you contribute a translation for a brand new previously unsupported language, keep in touch with the dev team so that new resource keys can be translated when a new release is coming up; abandoned languages/translations will end up getting dropped.
+![ResXManager in Visual Studio](https://user-images.githubusercontent.com/5751684/48683625-1a07f000-eb7c-11e8-914a-10ed80e85e29.png)
+
+If you contribute a translation for a brand new previously unsupported language, please keep in touch with the dev team so that new resource keys can be translated when a new release is coming up; abandoned languages/translations will end up getting dropped.
 
 ## What comes out of it for me?
 
-Well ... the eternal gratitude of all Rubberduck users for one :wink:
+Well... the eternal gratitude of all Rubberduck users for one :wink:
 Aside from that, all contributors are explicitly listed by name (or alias) in the "About Rubberduck" window.
-
-We ran a [fundraiser](https://gofundme.com/rubberduckvba) last summer, and had t-sihrts, mugs, pens, and stickers made - the goods are now unfortunately depleted; we'll probably run another campaign next year!

README.md

@@ -1,5 +1,5 @@
-<img src="https://user-images.githubusercontent.com/5751684/46327997-aeb98d00-c5d2-11e8-9de5-ba6f9cd1eea3.png" />
-
+<img alt="Rubberduck Open-Source VBE Add-In - VBA6 | VBA7 x86/x64 | VB6" src="https://user-images.githubusercontent.com/5751684/48656196-a507af80-e9ef-11e8-9c09-1ce3c619c019.png" />
+    
 <!-- campaign is no longer accepting donations
 ### Donate!
 

Rubberduck.API/Rubberduck.API.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Sunburst.NET.Sdk.WPF/1.0.47">
   <PropertyGroup>
     <Product>Rubberduck.API</Product>
     <Description>Rubberduck Reflection API</Description>

Rubberduck.API/VBA/Parser.cs

@@ -5,13 +5,11 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
-using Rubberduck.Common;
 using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.PreProcessing;
 using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.Symbols.DeclarationLoaders;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.UIContext;
 using Rubberduck.Parsing.VBA.ComReferenceLoading;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
@@ -69,10 +67,10 @@ public interface IParserEvents
     ]
     public sealed class Parser : IParser, IDisposable
     {
-        private RubberduckParserState _state;
-        private SynchronousParseCoordinator _parser;
-        private IVBE _vbe;
-        private IVBEEvents _vbeEvents;
+        private readonly RubberduckParserState _state;
+        private readonly SynchronousParseCoordinator _parser;
+        private readonly IVBE _vbe;
+        private readonly IVBEEvents _vbeEvents;
         private readonly IUiDispatcher _dispatcher;
         private readonly CancellationTokenSource _tokenSource;
 
@@ -98,8 +96,6 @@ internal Parser(object vbe) : this()
             var projectRepository = new ProjectsRepository(_vbe);
             _state = new RubberduckParserState(_vbe, projectRepository, declarationFinderFactory, _vbeEvents);
             _state.StateChanged += _state_StateChanged;
-
-            var sourceFileHandler = _vbe.TempSourceFileHandler;
             var vbeVersion = double.Parse(_vbe.Version, CultureInfo.InvariantCulture);
             var predefinedCompilationConstants = new VBAPredefinedCompilationConstants(vbeVersion);
             var typeLibProvider = new TypeLibWrapperProvider(projectRepository);
@@ -112,7 +108,6 @@ internal Parser(object vbe) : this()
             var mainTokenStreamParser = new VBATokenStreamParser(mainParseErrorListenerFactory, mainParseErrorListenerFactory);
             var tokenStreamProvider = new SimpleVBAModuleTokenStreamProvider();
             var stringParser = new TokenStreamParserStringParserAdapterWithPreprocessing(tokenStreamProvider, mainTokenStreamParser, preprocessor);
-            var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository);
             var projectManager = new RepositoryProjectManager(projectRepository);
             var moduleToModuleReferenceManager = new ModuleToModuleReferenceManager();
             var parserStateManager = new ParserStateManager(_state);
@@ -133,14 +128,12 @@ internal Parser(object vbe) : this()
                     }
                 );
             var codePaneSourceCodeHandler = new CodePaneSourceCodeHandler(projectRepository);
-            var moduleRewriterFactory = new ModuleRewriterFactory(
-                codePaneSourceCodeHandler,
-                attributesSourceCodeHandler);
+            var sourceFileHandler = _vbe.TempSourceFileHandler;
+            var attributesSourceCodeHandler = new SourceFileHandlerSourceCodeHandlerAdapter(sourceFileHandler, projectRepository);
             var moduleParser = new ModuleParser(
                 codePaneSourceCodeHandler,
                 attributesSourceCodeHandler,
-                stringParser,
-                moduleRewriterFactory);
+                stringParser);
             var parseRunner = new ParseRunner(
                 _state,
                 parserStateManager,
@@ -235,6 +228,9 @@ public void Dispose()
             }
 
             _disposed = true;
+            _parser?.Dispose();
+            _vbe?.Dispose();
+            _tokenSource.Dispose();
         }
     }
 }

Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs

@@ -3,8 +3,9 @@
 using System.Linq;
 using NLog;
 using Rubberduck.Parsing.Inspections.Abstract;
-using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.VBA.Extensions;
+using Rubberduck.Parsing.VBA.Parsing;
 
 namespace Rubberduck.Inspections.Abstract
 {
@@ -39,7 +40,9 @@ public void RemoveInspections(params Type[] inspections)
             _supportedInspections = _supportedInspections.Except(inspections).ToHashSet();
         }
 
-        public abstract void Fix(IInspectionResult result);
+        public virtual CodeKind TargetCodeKind => CodeKind.CodePaneCode;
+
+        public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession);
         public abstract string Description(IInspectionResult result);
 
         public abstract bool CanFixInProcedure { get; }

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -7,6 +7,8 @@
 using Rubberduck.Inspections.CodePathAnalysis.Extensions;
 using System.Linq;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -21,7 +23,9 @@ public AssignmentNotUsedInspection(RubberduckParserState state, Walker walker)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var variables = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable);
+            var variables = State.DeclarationFinder
+                    .UserDeclarations(DeclarationType.Variable)
+                    .Where(d => !d.IsArray);
 
             var nodes = new List<IdentifierReference>();
             foreach (var variable in variables)

Rubberduck.CodeAnalysis/Inspections/Concrete/ExcelUdfNameIsValidCellReferenceInspection.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Inspections;
+using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Resources.Inspections;
+
+namespace Rubberduck.Inspections.Inspections.Concrete
+{
+    [RequiredLibrary("Excel")]
+    public class ExcelUdfNameIsValidCellReferenceInspection : InspectionBase
+    {
+        public ExcelUdfNameIsValidCellReferenceInspection(RubberduckParserState state) : base(state) { }
+
+        private static readonly Regex ValidCellIdRegex =
+            new Regex(@"^([a-z]|[a-z]{2}|[a-w][a-z]{2}|x([a-e][a-z]|f[a-d]))(?<Row>\d+)$",
+                RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);
+
+        private static readonly HashSet<Accessibility> VisibleAsUdf = new HashSet<Accessibility> { Accessibility.Public, Accessibility.Implicit };
+
+        private const uint MaximumExcelRows = 1048576;
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            var excel = State.DeclarationFinder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");
+            if (excel == null)
+            {
+                return Enumerable.Empty<IInspectionResult>();
+            }
+
+            var candidates = UserDeclarations.OfType<FunctionDeclaration>().Where(decl =>
+                decl.ParentScopeDeclaration.DeclarationType == DeclarationType.ProceduralModule &&
+                VisibleAsUdf.Contains(decl.Accessibility));
+
+            return (from function in candidates.Where(decl => ValidCellIdRegex.IsMatch(decl.IdentifierName))
+                    let row = Convert.ToUInt32(ValidCellIdRegex.Matches(function.IdentifierName)[0].Groups["Row"].Value)
+                    where row > 0 && row <= MaximumExcelRows && !IsIgnoringInspectionResultFor(function, AnnotationName)
+                    select new DeclarationInspectionResult(this,
+                        string.Format(InspectionResults.ExcelUdfNameIsValidCellReferenceInspection, function.IdentifierName),
+                        function))
+                .Cast<IInspectionResult>().ToList();
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs

@@ -28,7 +28,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var interfaceImplementationMembers = State.DeclarationFinder.FindAllInterfaceImplementingMembers();
             var functions = State.DeclarationFinder
                 .UserDeclarations(DeclarationType.Function)
-                .Where(item => !IsIgnoringInspectionResultFor(item, AnnotationName))
+                .Where(item => !IsIgnoringInspectionResultFor(item, AnnotationName) &&
+                               item.References.Any(r => !IsReturnStatement(item, r) && !r.IsAssignment))
                 .ToList();
             var interfaceMemberIssues = GetInterfaceMemberIssues(interfaceMembers);
             var nonInterfaceFunctions = functions.Except(interfaceMembers.Union(interfaceImplementationMembers));

Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs

@@ -20,18 +20,12 @@ public IllegalAnnotationInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var illegalAnnotations = new List<IAnnotation>();
-
             var userDeclarations = State.DeclarationFinder.AllUserDeclarations.ToList();
             var identifierReferences = State.DeclarationFinder.AllIdentifierReferences().ToList();
             var annotations = State.AllAnnotations;
 
-            illegalAnnotations.AddRange(UnboundAnnotations(annotations, userDeclarations, identifierReferences));
-            illegalAnnotations.AddRange(NonIdentifierAnnotationsOnIdentifiers(identifierReferences));
-            illegalAnnotations.AddRange(NonModuleAnnotationsOnModules(userDeclarations));
-            illegalAnnotations.AddRange(NonMemberAnnotationsOnMembers(userDeclarations));
-            illegalAnnotations.AddRange(NonVariableAnnotationsOnVariables(userDeclarations));
-            illegalAnnotations.AddRange(NonGeneralAnnotationsWhereOnlyGeneralAnnotationsBelong(userDeclarations));
+            var illegalAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
+                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.GeneralAnnotation));
 
             return illegalAnnotations.Select(annotation => 
                 new QualifiedContextInspectionResult(
@@ -50,64 +44,5 @@ private static ICollection<IAnnotation> UnboundAnnotations(IEnumerable<IAnnotati
 
             return annotations.Where(annotation => !boundAnnotationsSelections.Contains(annotation.QualifiedSelection)).ToList();
         }
-
-        private static ICollection<IAnnotation> NonIdentifierAnnotationsOnIdentifiers(IEnumerable<IdentifierReference> identifierReferences)
-        {
-            return identifierReferences
-                .SelectMany(reference => reference.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.IdentifierAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonModuleAnnotationsOnModules(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Module))
-                .SelectMany(moduleDeclaration => moduleDeclaration.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.ModuleAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonMemberAnnotationsOnMembers(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Member))
-                .SelectMany(member => member.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.MemberAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonVariableAnnotationsOnVariables(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => VariableAnnotationDeclarationTypes.Contains(declaration.DeclarationType))
-                .SelectMany(declaration => declaration.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.VariableAnnotation))
-                .ToList();
-        }
-
-        private static readonly HashSet<DeclarationType> VariableAnnotationDeclarationTypes = new HashSet<DeclarationType>()
-        {
-            DeclarationType.Variable,
-            DeclarationType.Control,
-            DeclarationType.Constant,
-            DeclarationType.Enumeration,
-            DeclarationType.EnumerationMember,
-            DeclarationType.UserDefinedType,
-            DeclarationType.UserDefinedType,
-            DeclarationType.UserDefinedTypeMember
-        };
-
-        private static ICollection<IAnnotation> NonGeneralAnnotationsWhereOnlyGeneralAnnotationsBelong(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => !declaration.DeclarationType.HasFlag(DeclarationType.Module) 
-                                      && !declaration.DeclarationType.HasFlag(DeclarationType.Member) 
-                                      && !VariableAnnotationDeclarationTypes.Contains(declaration.DeclarationType) 
-                                      && declaration.DeclarationType != DeclarationType.Project)
-                .SelectMany(member => member.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.GeneralAnnotation))
-                .ToList();
-        }
     }
 }