Ticket #162: array-coVar.patch

Source/Types.cobra

@@ -1665 +1665 @@
         if type inherits ArrayType
             if _wrappedType == type.theWrappedType
                 return true
+            # arrays assignable to arrays if element assignable (covariance)
+            if _wrappedType.isAssignableTo( type.theWrappedType)
+                return true 
         if type inherits StreamType
-            return .isAssignableTo(type.box to !)
+            #trace 'array assignable to streamType'
+            if .isAssignableTo(type.box to !)
+                return true
+            # arrays being IEnumerable assignable to stream/IEnumerable if element assignable   
+            if _wrappedType.isAssignableTo( type.innerType to !)
+                return true 
         return false
 
     def _bindInh

Source/Container.cobra

@@ -247 +247 @@
                 return true
             if type inherits NilableType
                 return .isAssignableTo(type.theWrappedType to passthrough)  # CC: weird cast. bug. has to do with if-inherits and invoking the same method
-            result_ = .isDescendantOf(type) # CC: rename to result
-            return result_
+            result = .isDescendantOf(type)
+            return result
 
     # CC: duplicated from Type
     def isComparableTo(t as IType) as bool

Tests/820-errors/600-other/140-coVariance-not.cobra

@@ +1 @@
+# Assignment from an array (to stream and array) for Types that are unrelated - expected to fail compilation
+class CoVar
+    shared
+        var foo2 as IFoo*
+    
+        var afoo2 as IFoo[]
+        
+        def main
+            #array to stream covariance - - except they are unrelated
+            CoVar.foo2 = @[BarNoFoo(), BarNoFoo()] # .error. cannot assign value of type BarNoFoo[] on the right to IFoo* on the left
+            
+            # array to array covariance - except they are unrelated
+            CoVar.afoo2 = @[BarNoFoo(), BarNoFoo()] # .error. Cannot assign value of type BarNoFoo[] on the right to IFoo[] on the left 
+            
+
+interface IFoo
+    pass
+
+class Bar
+    implements IFoo
+    pass
+    
+interface INoFoo
+    pass
+
+class BarNoFoo
+    implements INoFoo
+    pass
+    

Tests/200-misc/830-coVariance-from-array.cobra

@@ +1 @@
+# Assignment from an array (to stream and array) for element Types that are related 
+# 
+class CoVar
+    shared
+        var fooSingleNil as IFoo?
+        var foo as IFoo*
+        var fooNil as IFoo*?
+    
+        var afoo as IFoo[]
+        var afooNil as IFoo[]?
+        
+        def main
+            CoVar.fooSingleNil = Bar()
+            
+            #array to stream covariance
+            CoVar.foo = @[Bar(), Bar()] 
+            CoVar.fooNil = @[Bar(), Bar()] 
+            
+            # array to array covariance
+            CoVar.afoo = @[Bar(), Bar()] 
+            CoVar.afooNil = @[Bar(), Bar()] 
+        
+            # should stream to stream also be allowed?
+            #CoVar.foo = [Bar(), Bar()]  
+            
+            
+
+interface IFoo
+    pass
+
+class Bar
+    implements IFoo
+    pass
+    
+    

Developer/IntermediateReleaseNotes.text

@@ -42 +42 @@
     def foo(p as Type has Attribute(args))  # attribute applies to parameter
         has return Attribute(args)  # attribute applies to return value due to `return` keyword
 
+* Support array coVariance from arrays to arrays and streams  ticket:162
 
 ================================================================================
 Library