Ticket #257: infer-out-param.patch

Source/Expr.cobra

@@ -561 +561 @@
                 _transformToEnumDecl(dotNode, enumDefi)
                 return
 
-        hasErrors = _bindImpArgs
+        needInferOutArgs = false
+        hasErrors = _bindImpArgs(out needInferOutArgs)
         definition as IMember?
         type as IType?
 
@@ -586 +587 @@
                     if not .hasError and not hasErrors
                         args = _args
                         if definition inherits MemberOverload
+                            #TODO: Correct this dependency; Need args bindImp done to calc bestOverload, 
+                            # but need best overload to infer (undefined out) variable type
+                            if needInferOutArgs 
+                                moDefn = definition.members[0] # not guaranteed to have the best param list 
+                                if moDefn.hasParams
+                                    params = moDefn.params
+                                    _inferOutArgs(args, params, true)   
+                                    
                             # Note that overloads can have different return types (even if more than just the return type is needed to distinguish them). Example: Math.
                             # Plenty of info here:
                             # http://www.google.com/search?hl=en&q=C%23+overloaded+method+resolution
@@ -602 +611 @@
                                 else
                                     params = definition.params
                                     if _checkParamsCount(definition, args, params)
+                                        if needInferOutArgs, _inferOutArgs(args, params, false) 
                                         _checkArgsAssignable(definition, args, params)
                         _checkInOutArguments
                 else
@@ -681 +691 @@
         _type = postCall.type
         transformTarget._transformTo(postCall)
 
-    def _bindImpArgs as bool
+    def _undefinedOutArg(arg as Expr) as bool
+        if arg.direction == Direction.Out  
+            if arg inherits IdentifierExpr
+                if not arg.findDefinition 
+                    return true
+        return false
+                
+    #do bindImp on callExprs args. 
+    #Defer binding on undefined out args but flag that inference needed (later see _bindImp)
+    def _bindImpArgs(needInferOutArgs as out bool) as bool
         hasErrors = false
+        needInferOutArgs = false
         num = 1
         for arg in List<of Expr>(_args)
             try
                 if arg inherits AssignExpr
                     arg.right.bindImp  # 'x=y' has special treatment in arguments
                 else
-                    boundArg = arg.bindImp
-                    if boundArg is not arg  # transformation
-                        _args[num-1] = boundArg
-                    assert boundArg.didBindImp
+                    if needInferOutArgs == false  and _undefinedOutArg(arg)
+                        #print 'No explicit prior definition for out-arg [arg.name]'    
+                        needInferOutArgs = true
+                        continue
+                    _bindImpArg(num, arg)
             catch ne as NodeException
                 ne.prefixMessage('For "[_name]" arg [num]: ')
                 .compiler.recordError(ne)
@@ -700 +721 @@
             num += 1
         return hasErrors
 
+    def _bindImpArg(num as int, arg as Expr)
+        boundArg = arg.bindImp
+        if boundArg is not arg  # transformation
+            _args[num-1] = boundArg
+        assert boundArg.didBindImp
+
     def _didVariArgs(definition as BoxMember) as bool
         hasVari = false
         for param in definition.params
@@ -729 +756 @@
                 .throwError('The method "[definition.name]" is expecting [params.count] argument[Utils.plural(params)], but [args.count] are being supplied in this call.')
         return true
                 
+    def _inferOutArgs(args as IList<of Expr>, params as IList<of Param>, warn as bool) 
+        num = 0
+        for arg in args
+            if _undefinedOutArg(arg)
+                #inferredType = .compiler.nilableType(params[num].type) # always nilable? (e.g. dict.tryGetValue)
+                inferredType = params[num].type  
+                newDefn = LocalVar(arg.token, inferredType).bindAll to LocalVar 
+                .compiler.codeMemberStack.peek.addLocal(newDefn)
+                (arg to IdentifierExpr).setDefinition(newDefn)
+                arg.type = newDefn.type
+                _bindImpArg(num, arg)
+                # the warning below is temporary till we sort out arg.bindImp vs calculating Best overload
+                if warn 
+                    sugg = 'You may want to disambiguate this by declaring the variable explicitly.'
+                    .compiler.warning(this, 'Cobra has implicitly declared a variable "[newDefn.name] as [newDefn.type.name]" for an undefined out parameter variable but the type inferred may not be correct as the method called is overloaded. [sugg]')
+                    
+            num += 1    
+            
     def _checkArgsAssignable(definition as BoxMember, args as IList<of Expr>, params as IList<of Param>) 
         for i in args.count
             arg = args[i]
@@ -1025 +1070 @@
     def _bindImp is override
         base._bindImp
         if _definition is nil
+            _definition = .findDefinition 
             canBeUndottedMember = _name.canBeUndottedMemberName
-            if canBeUndottedMember
-                # assert .compiler.boxStack.count TODO: identifier expr is being used by PostCallExpr which is used for attribute calls
-                _definition = .compiler.symbolForName(_name, false)
-            else
-                # local var ref: foo
-                if .compiler.codeMemberStack.count  # could be: var _x = y   or: has foo
-                    _definition = .compiler.findLocal(_name)
-                if _definition is nil
-                    _definition  = .compiler.symbolForName(_name, false, true)  # 3rd party DLLs have lowercase class names like iConnection
             if _definition is nil and not canBeUndottedMember
                 if _superNode inherits BinaryOpExpr
                     if _superNode.right is this
@@ -1059 +1096 @@
                     .throwUnknownIdError
                     throw FallThroughException()
 
+    def findDefinition as INamedNode?
+        definition as INamedNode?
+        canBeUndottedMember = _name.canBeUndottedMemberName
+        if canBeUndottedMember
+            # assert .compiler.boxStack.count TODO: identifier expr is being used by PostCallExpr which is used for attribute calls
+            definition = .compiler.symbolForName(_name, false)
+        else
+            # local var ref: foo
+            if .compiler.codeMemberStack.count  # could be: var _x = y   or: has foo
+                definition = .compiler.findLocal(_name)
+            if definition is nil
+                definition  = .compiler.symbolForName(_name, false, true)  # 3rd party DLLs have lowercase class names like iConnection
+        return definition       
+
     def bindImp as dynamic
         base.bindImp
         if _definition and not (.superNode inherits AbstractAssignExpr and .binarySuperNode.left is this)

Tests/300-type-inference/610-out-param.cobra

@@ +1 @@
+# Implicit creation of an undefined out param variable.
+# The warnings generated below are intended to be a temporary situation
+class DefaultOut
+    
+    var _x = ''
+    
+    def main
+        # User method
+        x = .getX( true, out s0)
+        assert x
+        assert s0 == '.BigWalla'
+        x =.getX( false, out s0)
+        assert not x 
+        assert s0 == '.'
+    
+        s1='something Ignored'
+        x = .getX( true, out s1)
+        assert x 
+        assert s1 =='.BigWalla'
+        x =.getX( false, out s1)
+        assert not x 
+        assert s1 == '.'
+    
+        # (nilable) variable in a  system method
+        d= {'a':'A1', 'b':'B2', 'c':'See3'}
+        #result as String?
+        x = d.tryGetValue('b', out result)
+        assert x 
+        assert result =='B2'
+        x = d.tryGetValue('d', out result)
+        assert not x
+        assert not result   #nil
+        result = nil
+    
+        # out to a method Parameter
+        r = ''
+        .testParam(d, r)
+        assert r == ''
+    
+        # out to a field
+        assert _x == ''
+        ok = d.tryGetValue('a', out _x)
+        assert ok
+        assert _x == 'A1'
+        
+        # out in an overloaded method successfully
+        ok = int.tryParse('986', out iVal)  # .warning. implicitly declared a variable
+        assert ok
+        assert iVal == 986
+    
+        # out in an overloaded method unsuccessfully
+        ok = int.tryParse('noway', out iVal1) # .warning. implicitly declared a variable
+        assert not ok
+        assert iVal1 == 0
+    
+        
+    def getX( flag as bool, z as  out String) as bool
+        z='.'
+        if flag
+            z = z + 'BigWalla'
+            return true
+        return false
+        
+    def testParam(d as Dictionary<of String, String>, x as String)
+        ok = d.tryGetValue('a', out x)
+        assert ok
+        assert x == 'A1'
+        

Developer/IntermediateReleaseNotes.text

@@ -66 +66 @@
 
 * Structs have implicit parameterless initializers and do not allow explicit ones to be declared.
 
+* First use of a variable as an out parameter in a method call implicitly declares the variable: ticket 257
 
 ================================================================================
 Library