Ticket #146: VariStreamOverload.patch

Source/Expr.cobra

@@ -661 +661 @@
                     if arg.type == param.type
                         score += 20
                     else if arg.canBeAssignedTo(param.type)
-                        score += 10
+                        if param.type inherits VariType   # Rational: T[] -> vari T should be preferred over T[] -> T*, 
+                            score += 15                   # although both satisfy the "assignability" condition
+                        else
+                            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

Source/Types.cobra

@@ -1651 +1651 @@
     def isAssignableTo(type as IType) as bool is override
         if base.isAssignableTo(type)
             return true
+        if type inherits VariType  
+            # A[] is assignable to "vari B" if A assignable to B
+            if _wrappedType.isAssignableTo(type.trueInner) 
+                return true       # TODO: wouldn't it be faster to make "return _wrappedType.isAssignableTo(type.trueInner)" ??
         if type inherits ArrayType
             if _wrappedType == type.theWrappedType
-                return true
+                return true       # TODO: wouldn't it be faster to make "return _wrappedType == type.theWrappedType" ??
         if type inherits StreamType
             return .isAssignableTo(type.box to !)
         return false
@@ -1677 +1681 @@
         return member
 
 
+# TODO: Why all the indirections? Vari[Nilable[Array[T]]]? 
+# Can't we just inherit Vari from Array?
 class VariType
     is partial
     inherits ArrayType
@@ -1696 +1702 @@
 
     get innerType as IType? is override
         return _wrappedType
+        
+    get trueInner as IType          
+        # TODO: this does not seem especially fast: cache it
+        inner1 = .theWrappedType
+        assert inner1.getType == NilableType
+        if inner1 inherits NilableType
+            inner2 = inner1.theWrappedType
+            assert inner2.getType == ArrayType
+            if inner2 inherits ArrayType
+                return inner2.theWrappedType
+        throw FallThroughException(this) 
 
     def isEquatableTo(t as IType) as bool is override
         # vari type inherits IList<of>

Tests/120-classes/115-overload-stream.cobra

@@ +1 @@
+class X
+    
+    # this tests one aspect of the overload resolution algorithm
+    # namely, that the vari overload  is preferred 
+    # over the stream overlad when passing an array
+    # (see Expr.cobra, method _computeBestOverload)
+    
+    def foo(stream as int*) is shared
+        assert false
+ 
+    def foo(v as vari int) is shared
+        pass
+
+    # just in case, test it as well with a non-primitive
+    # type and instance methods
+    
+    def bar(stream as String*)
+        assert false
+ 
+    def bar(v as vari String)
+        pass
+
+    def main is shared
+        
+        X.foo(@[1, 2, 3])
+        X().bar(@['hi', 'there'])
+        
+        
+        
+    
+