Merge branch 'master' of https://github.com/retailcoder/Rubberduck into UnitTesting

Author: rubberduck203

RetailCoder.VBE/Inspections/CodeInspectionResultBase.cs

@@ -39,7 +39,9 @@ public CodeInspectionResultBase(string inspection, Instruction instruction, Code
         /// <summary>
         /// Gets all available "quick fixes" for a code inspection result.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Returns a <c>Dictionary&lt;string&gt;, Action&lt;VBE&gt;</c>
+        /// where the keys are descriptions for each quick fix, and
+        /// each value is a method returning <c>void</c> and taking a <c>VBE</c> parameter.</returns>
         public abstract IDictionary<string, Action<VBE>> GetQuickFixes();
 
         /// <summary>

RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Security.Cryptography.X509Certificates;
 using Rubberduck.VBA.Parser;
 
 namespace Rubberduck.Inspections
@@ -20,7 +21,8 @@ public ImplicitByRefParameterInspection()
         public IEnumerable<CodeInspectionResultBase> GetInspectionResults(SyntaxTreeNode node)
         {
             var procedures = node.FindAllProcedures().Where(procedure => procedure.Parameters.Any(parameter => !string.IsNullOrEmpty(parameter.Instruction.Value)));
-            var targets = procedures.Where(procedure => procedure.Parameters.Any(parameter => parameter.IsImplicitByRef));
+            var targets = procedures.Where(procedure => procedure.Parameters.Any(parameter => parameter.IsImplicitByRef)
+                                                    && !procedure.Instruction.Line.IsMultiline);
 
             return targets.SelectMany(procedure => procedure.Parameters.Where(parameter => parameter.IsImplicitByRef)
                 .Select(parameter => new ImplicitByRefParameterInspectionResult(Name, parameter.Instruction, Severity)));

RetailCoder.VBE/Inspections/ImplicitByRefParameterInspectionResult.cs

@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.InteropServices;
 using Microsoft.Vbe.Interop;
+using Rubberduck.Extensions;
 using Rubberduck.VBA.Parser;
+using Rubberduck.VBA.Parser.Grammar;
 
 namespace Rubberduck.Inspections
 {
@@ -19,20 +22,50 @@ public override IDictionary<string, Action<VBE>> GetQuickFixes()
             return !Handled
                 ? new Dictionary<string, Action<VBE>>
                     {
-                        {"Pass parameter by reference explicitly.", PassParameterByRef},
-                        {"Pass parameter by value.", PassParameterByVal}
+                        {"Pass parameter by value", PassParameterByVal},
+                        {"Pass parameter by reference explicitly", PassParameterByRef}
                     }
                 : new Dictionary<string, Action<VBE>>();
         }
 
         private void PassParameterByRef(VBE vbe)
         {
-            throw new NotImplementedException();
+            if (!Instruction.Line.IsMultiline)
+            {
+                var newContent = string.Concat(ReservedKeywords.ByRef, " ", Instruction.Value);
+                var oldContent = Instruction.Line.Content;
+
+                var result = oldContent.Replace(Instruction.Value, newContent);
+
+                var module = vbe.FindCodeModules(Instruction.Line.ProjectName, Instruction.Line.ComponentName).First();
+                module.ReplaceLine(Instruction.Line.StartLineNumber, result);
+                Handled = true;
+            }
+            else
+            {
+                // todo: implement for multiline
+                throw new NotImplementedException("This method is not [yet] implemented for multiline instructions.");
+            }
         }
 
         private void PassParameterByVal(VBE vbe)
         {
-            throw new NotImplementedException();
+            if (!Instruction.Line.IsMultiline)
+            {
+                var newContent = string.Concat(ReservedKeywords.ByVal, " ", Instruction.Value);
+                var oldContent = Instruction.Line.Content;
+
+                var result = oldContent.Replace(Instruction.Value, newContent);
+
+                var module = vbe.FindCodeModules(Instruction.Line.ProjectName, Instruction.Line.ComponentName).First();
+                module.ReplaceLine(Instruction.Line.StartLineNumber, result);
+                Handled = true;
+            }
+            else
+            {
+                // todo: implement for multiline
+                throw new NotImplementedException("This method is not yet implemented for multiline instructions.");
+            }
         }
     }
 }

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Rubberduck.VBA.Parser;
+using Rubberduck.VBA.Parser.Grammar;
+
+namespace Rubberduck.Inspections
+{
+    [ComVisible(false)]
+    public class ImplicitVariantReturnTypeInspection : IInspection
+    {
+        public ImplicitVariantReturnTypeInspection()
+        {
+            Severity = CodeInspectionSeverity.Suggestion;
+        }
+
+        public string Name { get { return "Function returns an implicit Variant"; } }
+        public CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } }
+        public CodeInspectionSeverity Severity { get; set; }
+
+        public IEnumerable<CodeInspectionResultBase> GetInspectionResults(SyntaxTreeNode node)
+        {
+            var procedures = node.FindAllProcedures().Where(procedure => procedure.HasReturnType);
+            var targets = procedures.Where(procedure => string.IsNullOrEmpty(procedure.SpecifiedReturnType) 
+                && !procedure.Instruction.Content.EndsWith(string.Concat(" ", ReservedKeywords.As, " ", ReservedKeywords.Variant))
+                && !procedure.Instruction.Line.IsMultiline);
+
+            return targets.Select(procedure => new ImplicitVariantReturnTypeInspectionResult(Name, procedure.Instruction, Severity));
+        }
+    }
+}

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspectionResult.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Extensions;
+using Rubberduck.VBA.Parser;
+using Rubberduck.VBA.Parser.Grammar;
+
+namespace Rubberduck.Inspections
+{
+    public class ImplicitVariantReturnTypeInspectionResult : CodeInspectionResultBase
+    {
+        public ImplicitVariantReturnTypeInspectionResult(string name, Instruction instruction, CodeInspectionSeverity severity)
+            : base(name, instruction, severity)
+        {
+        }
+
+        public override IDictionary<string, Action<VBE>> GetQuickFixes()
+        {
+            return !Handled
+                ? new Dictionary<string, Action<VBE>>
+                    {
+                        {"Return explicit Variant", ReturnExplicitVariant}
+                    }
+                : new Dictionary<string, Action<VBE>>();
+        }
+
+        private void ReturnExplicitVariant(VBE vbe)
+        {
+            if (!Instruction.Line.IsMultiline)
+            {
+                var newContent = string.Concat(Instruction.Value, " ", ReservedKeywords.As, " ", ReservedKeywords.Variant);
+                var oldContent = Instruction.Line.Content;
+
+                var result = oldContent.Replace(Instruction.Value, newContent);
+
+                var module = vbe.FindCodeModules(Instruction.Line.ProjectName, Instruction.Line.ComponentName).First();
+                module.ReplaceLine(Instruction.Line.StartLineNumber, result);
+                Handled = true;
+            }
+            else
+            {
+                // todo: implement for multiline
+                throw new NotImplementedException("This method is not [yet] implemented for multiline instructions.");
+            }
+        }
+    }
+}

RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspectionResult.cs

@@ -21,8 +21,8 @@ public override IDictionary<string, Action<VBE>> GetQuickFixes()
             return !Handled
                 ? new Dictionary<string, Action<VBE>>
                     {
-                        {"Replace Rem reserved keyword with single quote.", ReplaceWithSingleQuote},
-                        {"Remove comment.", RemoveComment}
+                        {"Replace Rem reserved keyword with single quote", ReplaceWithSingleQuote},
+                        {"Remove comment", RemoveComment}
                     }
                 : new Dictionary<string, Action<VBE>>();
         }

RetailCoder.VBE/Inspections/OptionExplicitInspectionResult.cs

@@ -21,7 +21,7 @@ public override IDictionary<string, Action<VBE>> GetQuickFixes()
             return !Handled
                 ? new Dictionary<string, Action<VBE>>
                     {
-                        {"Specify Option Explicit.", SpecifyOptionExplicit}
+                        {"Specify Option Explicit", SpecifyOptionExplicit}
                     }
                 : new Dictionary<string, Action<VBE>>();
         }