Ticket #74: ticket74.patch

Source/Members.cobra

@@ -1435 +1435 @@
         for member in _members
             member.unNilReturnType
 
+    def computeBestOverload(args as List<of Expr>, genericArgTypes as List<of IType>?, strictBindChecking as bool) as BoxMember
+        # References:
+        # http://blogs.msdn.com/ericlippert/archive/2007/11/05/c-3-0-return-type-inference-does-not-work-on-member-groups.aspx
+
+        # I cooked up the algorithm below as a quick way to fix some bugs caused by the previous 
+        # implementation of um, doing nothing.
+        # But this likely needs to be rewritten.
+        candidates = []
+        # handle generic arguments to the method        
+        if genericArgTypes and genericArgTypes.count
+            members = List<of BoxMember>()
+            for member as BoxMember? in .members
+                if member inherits Method
+                    if member.containsGenericParameters
+                        if member.genericParams.count == genericArgTypes.count
+                            member = member.constructedMethodWith(genericArgTypes to !)
+                        else
+                            member = nil
+                if member, members.add(member)
+        else
+            members = .members
+
+        for member in members
+            score = -1000
+            if member.params.count == args.count
+                score = 0
+                if member inherits Method and (member to Method).genericParams.count > 0, score += 1
+                for i, param in member.params.numbered
+                    arg = args[i]
+                    if strictBindChecking and not arg.didBindImp
+                        trace arg
+                        trace arg.hasError
+                    if strictBindChecking and (arg.type == param.type or arg.type == param.type.nonNil)
+                        score += 20
+                    else if strictBindChecking and arg.canBeAssignedTo(param.type)
+                        score += 10
+                    else if strictBindChecking and arg.type.nonNil.isAssignableTo(param.type) 
+                        # Cobra's code and data flow analysis sometimes leaves us with a nilable type that's not actually nil anymore
+                        # due to an assignment, possibly wrapped in an if statement. Eventually this will be corrected, but for now
+                        # compensate here.
+                        score += 1
+                    else if not strictBindChecking
+                        if arg.type is not nil
+                            if arg.type == param.type
+                                score += 20
+                            else if arg.type.isDynamic
+                                score += 10
+                        else
+                            score -= 100
+                    else
+                        score -= 100
+            # print 'candidate:', score, member.name, member.serialNum, Utils.join(', ', (for param in member.params get param.type.name))
+            candidates.add([score, member])
+            
+        maxScore = -10_000
+        winner = nil to BoxMember?
+        for pair in candidates
+            if false, print pair[0], (pair[1] to BoxMember).idString
+            if pair[0] to int > maxScore
+                maxScore = pair[0] to int
+                winner = pair[1] to BoxMember
+
+        if false
+            # detect overload invocation ambiguity
+            # TODO: not ready for this yet
+            count = 0
+            for pair in candidates
+                if pair[0] to int == maxScore
+                    count += 1
+            if count > 1
+                # TODO: do this for indexing too
+                msg = 'The call is ambiguous between these methods: '
+                sep = ''
+                for pair in candidates
+                    if pair[0] to int == maxScore
+                        msg += sep + (pair[1] to AbstractMethod).cobraSourceSignature(false)
+                        sep = ', '
+                .throwError(msg)
+
+        if false
+            print
+            trace .token.fileName
+            trace maxScore, _name
+            trace .token.toTechString
+            trace winner
+            print 'args:'
+            for arg in args
+                print '   [arg]'
+            print 'params:'
+            for param in winner.params
+                print '   [param]'
+            print 'overloads:'
+            for member in .members
+                print '   [member]'
+        # print 'winner:', score, winner
+        assert winner
+        return winner to !
+    
     def _bindInt is override
         base._bindInt
         # sanity check that members all have the right name

Source/Expr.cobra

@@ -590 +590 @@
                             # http://www.google.com/search?hl=en&q=C%23+overloaded+method+resolution
                             # TODO: handle type inference for generic members. See the C# spec for details.
                         
-                            winner = _computeBestOverload(definition, args)
+                            winner = definition.computeBestOverload(.args, .genericArgTypes, true)
                             sharp'definition = winner'
                             type = winner.resultType
                         else
@@ -695 +695 @@
                 .compiler.recordError(ne)
             num += 1
 
-    def _computeBestOverload(definition as MemberOverload, args as List<of Expr>) as BoxMember
-        # References:
-        # http://blogs.msdn.com/ericlippert/archive/2007/11/05/c-3-0-return-type-inference-does-not-work-on-member-groups.aspx
-
-        # I cooked up the algorithm below as a quick way to fix some bugs caused by the previous 
-        # implementation of um, doing nothing.
-        # But this likely needs to be rewritten.
-        candidates = []
-        # handle generic arguments to the method
-        genericArgTypes = .genericArgTypes
-        if genericArgTypes and genericArgTypes.count
-            members = List<of BoxMember>()
-            for member as BoxMember? in definition.members
-                if member inherits Method
-                    if member.containsGenericParameters
-                        if member.genericParams.count == genericArgTypes.count
-                            member = member.constructedMethodWith(genericArgTypes to !)
-                        else
-                            member = nil
-                if member, members.add(member)
-        else
-            members = definition.members
-
-        for member in members
-            score = -1000
-            if member.params.count == args.count
-                score = 0
-                if member inherits Method and (member to Method).genericParams.count > 0, score += 1
-                for i, param in member.params.numbered
-                    arg = args[i]
-                    if not arg.didBindImp
-                        trace arg
-                        trace arg.hasError
-                    if arg.type == param.type or arg.type == param.type.nonNil
-                        score += 20
-                    else if arg.canBeAssignedTo(param.type)
-                        score += 10
-                    else if arg.type.nonNil.isAssignableTo(param.type) 
-                        # Cobra's code and data flow analysis sometimes leaves us with a nilable type that's not actually nil anymore
-                        # due to an assignment, possibly wrapped in an if statement. Eventually this will be corrected, but for now
-                        # compensate here.
-                        score += 1
-                    else
-                        score -= 100
-            # print 'candidate:', score, member.name, member.serialNum, Utils.join(', ', (for param in member.params get param.type.name))
-            candidates.add([score, member])
-            
-        maxScore = -10_000
-        winner = nil to BoxMember?
-        for pair in candidates
-            if false, print pair[0], (pair[1] to BoxMember).idString
-            if pair[0] to int > maxScore
-                maxScore = pair[0] to int
-                winner = pair[1] to BoxMember
-
-        if false
-            # detect overload invocation ambiguity
-            # TODO: not ready for this yet
-            count = 0
-            for pair in candidates
-                if pair[0] to int == maxScore
-                    count += 1
-            if count > 1
-                # TODO: do this for indexing too
-                msg = 'The call is ambiguous between these methods: '
-                sep = ''
-                for pair in candidates
-                    if pair[0] to int == maxScore
-                        msg += sep + (pair[1] to AbstractMethod).cobraSourceSignature(false)
-                        sep = ', '
-                .throwError(msg)
-
-        if false
-            print
-            trace .token.fileName
-            trace maxScore, _name
-            trace .token.toTechString
-            trace winner
-            print 'args:'
-            for arg in args
-                print '   [arg]'
-            print 'params:'
-            for param in winner.params
-                print '   [param]'
-            print 'overloads:'
-            for member in definition.members
-                print '   [member]'
-        # print 'winner:', score, winner
-        assert winner
-        return winner to !
-
     def _didVariArgs(definition as BoxMember) as bool
         hasVari = false
         for param in definition.params
@@ -1762 +1671 @@
                 _type = .compiler.dynamicType
             else if exprType inherits Box
                 _type = expr.receiverType  # for example, an IdentifierExpr of 'SomeClass' has a .receiverType of that class
+                _handleClassInitializer
             else if exprType.isDynamic
                 _type = .compiler.nilableDynamicType
             else if expr.definition inherits NameSpace
@@ -1846 +1756 @@
         sb.append(')')
         return sb.toString
 
+    def _handleClassInitializer
+        initCall as Initializer?
+        if .args.count > 0
+            theClass = .compiler.symbolForName(.name, true, false, true) to ClassOrStruct?
+            if theClass is not nil
+                possibleCalls = theClass.memberForName("cue.init")
+                if possibleCalls is nil
+                    pass # TODO: determine if this is an error or if support for base class init functions need to be added
+                else if possibleCalls inherits MemberOverload
+                    initCall = possibleCalls.computeBestOverload(.args, nil, false) to Initializer?
+                else if possibleCalls inherits Initializer
+                    initCall = possibleCalls
+                #else
+                    # TODO: determine if this is an error
+        #print initCall
+        if initCall is not nil and .args.count == initCall.params.count
+            i = 0
+            for arg in .args
+                if arg.type is not nil and arg.type.isDynamic
+                    # set context type so that backend can type cast it correctly
+                    arg.contextType = initCall.params[i].type
+                i += 1
+        #else
+            # TODO: warning or error?
 
+
 class RefExpr
     is partial
     inherits Expr

Tests/500-dynamic/310-dynamic-init-params.cobra

@@ +1 @@
+class X
+
+    var _intvar as int
+    var _string1 as String
+    var _string2 as String
+    
+    cue init(i as int)
+        .init(i, '', '')
+        
+    cue init(i as int, s as String)
+        .init(i, s, '')
+        
+    cue init(s as String, i as int)
+        .init(i, s, '')
+        
+    cue init(i as int, s1 as String, s2 as String)
+        base.init
+        _intvar = i
+        _string1 = s1
+        _string2 = s2
+    
+    cue init(s1 as String, i as int, s2 as String)
+        .init(i, s1, s2)
+        
+    cue init(s1 as String, s2 as String, i as int)
+        .init(i, s1, s2)
+
+    def foo
+        print 'foo: [_intvar]; [_string1]; [_string2]'
+
+class F
+
+    def main
+        myint = 5
+        mystr1 = 'mystr1'
+        mystr2 = 'mystr2'
+        dyint = 6 to dynamic
+        dystr1 = 'dystr1' to dynamic
+        dystr2 = 'dystr2' to dynamic
+        
+        x = X(myint)
+        x.foo
+        x = X(dyint)
+        x.foo
+        x = X(myint, mystr1)
+        x.foo
+        x = X(dyint, mystr1)
+        x.foo
+        x = X(myint, dystr1)
+        x.foo
+        x = X(dyint to int, dystr1)
+        x.foo
+        x = X(dyint, dystr1 to String)
+        x.foo
+        x = X(mystr1, myint)
+        x.foo
+        x = X(dystr1, dyint to int)
+        x.foo
+        x = X(dyint to int, dystr1, mystr2)
+        x.foo
+        x = X(mystr1, dyint, mystr2)
+        x.foo
+        x = X(dystr1, dystr2, myint)
+        x.foo