Make printStmt in the grammar compatible with unqualified VB6 form print statements

This also includes an amendment to the resolver to deal with these statements.

Author: MDoerner

Rubberduck.Parsing/Binding/Bindings/ObjectPrintDefaultBinding.cs

@@ -5,24 +5,24 @@ namespace Rubberduck.Parsing.Binding
     public sealed class ObjectPrintDefaultBinding : IExpressionBinding
     {
         private readonly ParserRuleContext _context;
-        private readonly IExpressionBinding _memberAccessBinding;
+        private readonly IExpressionBinding _printMethodBinding;
         private readonly IExpressionBinding _outputListBinding;
 
         public ObjectPrintDefaultBinding(
             ParserRuleContext context,
-            IExpressionBinding memberAccessBinding,
+            IExpressionBinding printMethodBinding,
             IExpressionBinding outputListBinding)
         {
             _context = context;
-            _memberAccessBinding = memberAccessBinding;
+            _printMethodBinding = printMethodBinding;
             _outputListBinding = outputListBinding;
         }
 
         public IBoundExpression Resolve()
         {
-            var memberAccessExpression = _memberAccessBinding.Resolve();
+            var printMethodExpression = _printMethodBinding.Resolve();
             var outputListExpression = _outputListBinding.Resolve();
-            return new ObjectPrintExpression(_context, memberAccessExpression, outputListExpression);
+            return new ObjectPrintExpression(_context, printMethodExpression, outputListExpression);
         }
     }
 }

Rubberduck.Parsing/Binding/DefaultBindingContext.cs

@@ -73,6 +73,8 @@ public IExpressionBinding Visit(Declaration module, Declaration parent, IParseTr
                     return Visit(module, parent, integerExpressionContext, withBlockVariable);
                 case VBAParser.OutputListContext outputListContext:
                     return Visit(module, parent, outputListContext, withBlockVariable);
+                case VBAParser.PrintStmtContext printStmtContext:
+                    return Visit(module, parent, printStmtContext, withBlockVariable);
                 default:
                     throw new NotSupportedException($"Unexpected context type {expression.GetType()}");
             }
@@ -264,6 +266,25 @@ private IExpressionBinding Visit(Declaration module, Declaration parent, VBAPars
             return new ObjectPrintDefaultBinding(expression, memberAccessBinding, outputListBinding);
         }
 
+        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.PrintStmtContext expression, IBoundExpression withBlockVariable)
+        {
+            var printMethodContext = expression.printMethod();
+            var simpleNameBinding = new SimpleNameDefaultBinding(
+                _declarationFinder,
+                Declaration.GetProjectParent(parent),
+                module,
+                parent,
+                printMethodContext,
+                printMethodContext.GetText(),
+                StatementResolutionContext.Undefined);
+            var outputListBinding = Visit(
+                module,
+                parent,
+                expression.outputList(),
+                withBlockVariable);
+            return new ObjectPrintDefaultBinding(expression, simpleNameBinding, outputListBinding);
+        }
+
         private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.IndexExprContext expression, IBoundExpression withBlockVariable)
         {
             var lExpression = expression.lExpression();

Rubberduck.Parsing/Binding/Expressions/ObjectPrintExpression.cs

@@ -6,15 +6,15 @@ public sealed class ObjectPrintExpression : BoundExpression
     {
         public ObjectPrintExpression(
             ParserRuleContext context,
-            IBoundExpression memberAccessExpression,
+            IBoundExpression printMethodExpression,
             IBoundExpression outputListBoundExpression)
             : base(null, ExpressionClassification.Subroutine, context)
         {
-            MemberAccessExpressions = memberAccessExpression;
+            PrintMethodExpressions = printMethodExpression;
             OutputListExpression = outputListBoundExpression;
         }
 
-        public IBoundExpression MemberAccessExpressions { get; }
+        public IBoundExpression PrintMethodExpressions { get; }
         public IBoundExpression OutputListExpression { get; }
     }
 }

Rubberduck.Parsing/Grammar/VBAParser.g4

@@ -257,8 +257,10 @@ lineWidth : expression;
 
 
 // 5.4.5.8   Print Statement
+//We make the part regarding the file handle optional to support VB6's print statement in forms.
+//It is an invocation of the Print member of the enclosing form, which also takes an output list as argument.
 printMethod : PRINT;
-printStmt : PRINT whiteSpace markedFileNumber whiteSpace? COMMA (whiteSpace? outputList)?;
+printStmt : printMethod (whiteSpace markedFileNumber whiteSpace? COMMA)? (whiteSpace? outputList)?;
 
 // 5.4.5.8.1 Output Lists
 outputList : outputItem (whiteSpace? outputItem)*;

Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs

@@ -186,7 +186,7 @@ private void Visit(
             Declaration parent)
         {
             Visit(expression.OutputListExpression, module, scope, parent);
-            Visit(expression.MemberAccessExpressions, module, scope, parent);
+            Visit(expression.PrintMethodExpressions, module, scope, parent);
         }
 
         private void Visit(

Rubberduck.Parsing/VBA/ReferenceManagement/FailedResolutionVisitor.cs

@@ -116,7 +116,7 @@ private void Visit(MemberAccessExpression expression, Declaration parent, IBound
         private void Visit(ObjectPrintExpression expression, Declaration parent, IBoundExpression withExpression)
         {
             Visit(expression.OutputListExpression, parent, withExpression);
-            Visit(expression.MemberAccessExpressions, parent, withExpression);
+            Visit(expression.PrintMethodExpressions, parent, withExpression);
         }
 
         private void Visit(OutputListExpression expression, Declaration parent, IBoundExpression withExpression)

Rubberduck.Parsing/VBA/ReferenceManagement/IdentifierReferenceResolver.cs

@@ -500,6 +500,19 @@ public void Resolve(VBAParser.WidthStmtContext context)
         }
 
         public void Resolve(VBAParser.PrintStmtContext context)
+        {
+            if (context.markedFileNumber() != null)
+            {
+                ResolvePrintStatement(context);
+            }
+            else
+            {
+                //Since there is no file handle, this must be an unqualified print member call in a VB6 form.  
+                ResolveDefault(context);
+            }
+        }
+
+        public void ResolvePrintStatement(VBAParser.PrintStmtContext context)
         {
             ResolveDefault(context.markedFileNumber().expression(), true);
             ResolveOutputList(context.outputList());

RubberduckTests/Grammar/ResolverTests.cs

@@ -2244,14 +2244,49 @@ Dim referenced As String
 End Sub";
             using (var state = Resolve(code))
             {
-
                 var declaration = state.AllUserDeclarations.Single(item =>
                     item.DeclarationType == DeclarationType.Variable && item.IdentifierName == "referenced");
 
                 Assert.AreEqual(7, declaration.References.Count());
             }
         }
 
+        [Category("Grammar")]
+        [Category("Resolver")]
+        [Test]
+        //This form is legal inside VB6 forms and other classes implementing the IVBPrint COM interface.
+        //To simplify the test we use a dummy Sub in the class instead, which cannot be defined in regular VBA.
+        public void UnqualifiedObjectPrintExpr_IsReferencePrintOnContainingModule()
+        {
+            var code = @"
+Sub Test()
+    Dim obj As Object
+    Dim referenced As String
+    Print referenced;referenced, referenced , referenced ;
+End Sub
+
+Public Sub Print()
+End Sub
+";
+            using (var state = Resolve(code, false, ComponentType.ClassModule))
+            {
+                var referencedDeclaration = state.DeclarationFinder
+                    .UserDeclarations(DeclarationType.Variable)
+                    .Single(item => item.IdentifierName == "referenced");
+                var printDeclaration = state.DeclarationFinder
+                    .UserDeclarations(DeclarationType.Procedure)
+                    .Single(item => item.IdentifierName == "Print");
+                var printReference = printDeclaration.References.Single();
+
+                var module = state.DeclarationFinder.AllModules.Single(qmn => qmn.ComponentType == ComponentType.ClassModule);
+                var expectedPrintSelection = new QualifiedSelection(module, new Selection(5, 5,5, 10));
+                var actualPrintSelection = new QualifiedSelection(printReference.QualifiedModuleName, printReference.Selection);
+
+                Assert.AreEqual(4, referencedDeclaration.References.Count());
+                Assert.AreEqual(expectedPrintSelection, actualPrintSelection);
+            }
+        }
+
         [Category("Grammar")]
         [Category("Resolver")]
         [Test]