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

Author: ThunderFrame

RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs

@@ -32,16 +32,14 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             var nonInterfaceFunctions = functions.Except(interfaceMembers.Union(interfaceImplementationMembers));
             var nonInterfaceIssues = GetNonInterfaceIssues(nonInterfaceFunctions);
             return interfaceMemberIssues.Union(nonInterfaceIssues);
-            //// Temporarily disabled until fix for lack of context because of new resolver is found...
-            //return new List<InspectionResultBase>();
         }
 
         private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetInterfaceMemberIssues(IEnumerable<Declaration> interfaceMembers)
         {
             return from interfaceMember in interfaceMembers
                    let implementationMembers =
                        UserDeclarations.FindInterfaceImplementationMembers(interfaceMember.IdentifierName).ToList()
-                   where
+                   where interfaceMember.DeclarationType == DeclarationType.Function &&
                        !IsReturnValueUsed(interfaceMember) &&
                        implementationMembers.All(member => !IsReturnValueUsed(member))
                    let implementationMemberIssues =
@@ -58,7 +56,7 @@ private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetInterfaceMemb
 
         private IEnumerable<FunctionReturnValueNotUsedInspectionResult> GetNonInterfaceIssues(IEnumerable<Declaration> nonInterfaceFunctions)
         {
-            var returnValueNotUsedFunctions = nonInterfaceFunctions.Where(function => !IsReturnValueUsed(function));
+            var returnValueNotUsedFunctions = nonInterfaceFunctions.Where(function => function.DeclarationType == DeclarationType.Function && !IsReturnValueUsed(function));
             var nonInterfaceIssues = returnValueNotUsedFunctions
                 .Select(function =>
                         new FunctionReturnValueNotUsedInspectionResult(

RetailCoder.VBE/UI/RubberduckUI.de.resx

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -1586,9 +1586,9 @@ Allen Sternguckern, Likern &amp; Followern, für das warme Kribbeln
     <value />
   </data>
   <data name="CodeExplorer_CopyToolTip">
-    <value />
+    <value>In Zwischenablage kopieren</value>
   </data>
   <data name="cross_circle">
     <value />
   </data>
-</root>
+</root>

Rubberduck.Parsing/Binding/BindingService.cs

@@ -1,4 +1,6 @@
-using Antlr4.Runtime;
+using System.Diagnostics;
+using Antlr4.Runtime;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Parsing.Binding
@@ -39,7 +41,13 @@ public IBoundExpression ResolveDefault(Declaration module, Declaration parent, P
 
         public IBoundExpression ResolveType(Declaration module, Declaration parent, ParserRuleContext expression)
         {
-            return _typedBindingContext.Resolve(module, parent, expression, null, StatementResolutionContext.Undefined);
+            var context = expression;
+            var opContext = expression as VBAParser.RelationalOpContext;
+            if (opContext != null && opContext.Parent is VBAParser.ComplexTypeContext)
+            {
+                context = opContext.GetChild<VBAParser.LExprContext>(0);
+            }
+            return _typedBindingContext.Resolve(module, parent, context, null, StatementResolutionContext.Undefined);
         }
 
         public IBoundExpression ResolveProcedurePointer(Declaration module, Declaration parent, ParserRuleContext expression)

Rubberduck.Parsing/Binding/StatementResolutionContext.cs

@@ -4,6 +4,7 @@ public enum StatementResolutionContext
     {
         Undefined,
         SetStatement,
-        LetStatement
+        LetStatement,
+        DefaultParamValue,
     }
 }

Rubberduck.Parsing/Symbols/DeclarationSymbolsListener.cs

@@ -185,6 +185,16 @@ private Declaration CreateDeclaration(
             {
                 var argContext = (VBAParser.ArgContext)context;
                 var isOptional = argContext.OPTIONAL() != null;
+                if (isOptional)
+                {
+                    // if parameter is optional, asTypeName may contain the default value
+                    var complexType = asTypeContext.type().complexType();
+                    if (complexType != null && complexType.expression() is VBAParser.RelationalOpContext)
+                    {
+                        asTypeName = complexType.expression().GetChild(0).GetText();
+                    }
+                }
+
                 var isByRef = argContext.BYREF() != null;
                 var isParamArray = argContext.PARAMARRAY() != null;
                 result = new ParameterDeclaration(

Rubberduck.Parsing/VBA/RubberduckParser.cs

@@ -56,13 +56,8 @@ public RubberduckParser(
             _comReflector = new ReferencedDeclarationsCollector(_state);
 
             state.ParseRequest += ReparseRequested;
-            state.StateChanged += StateOnStateChanged;
         }
 
-        private void StateOnStateChanged(object sender, EventArgs e)
-        {
-            Logger.Debug("RubberduckParser handles OnStateChanged ({0})", _state.Status);
-        }
 
         private void ReparseRequested(object sender, ParseRequestEventArgs e)
         {
@@ -466,6 +461,7 @@ private void ParseAsyncInternal(VBComponent component, CancellationToken token,
 
         private void Resolve(CancellationToken token)
         {
+            State.SetStatusAndFireStateChanged(ParserState.Resolving);
             var sharedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_resolverTokenSource.Token, token);
             // tests expect this to be synchronous :/
             //Task.Run(() => ResolveInternal(sharedTokenSource.Token));
@@ -599,8 +595,6 @@ private void ResolveReferences(DeclarationFinder finder, VBComponent component,
         public void Dispose()
         {
             State.ParseRequest -= ReparseRequested;
-            State.StateChanged -= StateOnStateChanged;
-
             if (_resolverTokenSource != null)
             {
                 _resolverTokenSource.Dispose();