Ticket #176: lit-collections-dynamic.patch

Source/Expr.cobra

@@ -2810 +2810 @@
                 for i in 1 : exprs.count
                     exprs[i].bindImp
                     type = exprs[i].type.greatestCommonDenominatorWith(type)
+                if type.isSystemObjectClass # make dynamic if heterogenous and all non Object
+                    allObj = all for expr in exprs get expr.type.isSystemObjectClass
+                    if not allObj, type = .compiler.dynamicType 
             if type inherits NilType, type = .compiler.defaultType
             _type = _makeTypeWith(type)
 
@@ -2968 +2971 @@
                 keyType   = entries[0][0].type to !
                 valueType = entries[0][1].type to !
                 i = 1
+                keysAllSysObject = valuesAllSysObject = true
                 while i < entries.count
                     keyType   = entries[i][0].type.greatestCommonDenominatorWith(keyType)
+                    if not entries[i][0].type.isSystemObjectClass, keysAllSysObject = false
                     valueType = entries[i][1].type.greatestCommonDenominatorWith(valueType)
+                    if not entries[i][1].type.isSystemObjectClass, valuesAllSysObject = false 
                     i += 1
+                # make types dynamic if heterogenous and all non Object
+                if keyType.isSystemObjectClass and not keysAllSysObject
+                    keyType = .compiler.dynamicType 
+                if valueType.isSystemObjectClass and not valuesAllSysObject
+                    valueType = .compiler.dynamicType 
             if keyType inherits NilType, keyType = .compiler.defaultType
             if valueType inherits NilType, valueType = .compiler.defaultType
             _type = .compiler.dictionaryOfType.constructedTypeFor([keyType, valueType])

Tests/240-generics/500-misc/800-streams.cobra

@@ -37 +37 @@
         assert count == 0
 
         # work with the stream object var
-        _stuff = [1, 'x']
+        _stuff = [1, 'x'] to List<of Object>
         count = 0
         for x in _stuff
             assert x in {1, 'x'}

Tests/300-type-inference/900-literals/505-lit-collections-errors.cobra

@@ +1 @@
+# List, Array, Set, Dict  literals not dynamic if all are explict Object type
+# Ticket 176
+class X
+    def main 
+        a = 'aoeu' to Object 
+        b = 5 to Object 
+        #List
+        l = [a, b]  # List<of Object>
+        x = l[0]
+        y = l[1]
+        assert x.length == 4 # .error. type is "Object"     
+        assert y*2 == 10     # .error. Cannot apply STAR to Object and int
+        
+        #array
+        l2 = @[a, b]    # List<of Object>
+        x1 = l2[0] 
+        y1 = l2[1] 
+        assert x1.length == 4   # .error. type is "Object"      
+        assert y1*2 == 10       # .error. Cannot apply STAR to Object and int
+        
+        # dict
+        d = {0:a, 1:b}  # Dict<of int,Object>
+        x2 = d[0] 
+        y2 = d[1] 
+        assert x2.length == 4 # .error. type is "Object"        
+        assert y2 * 2 == 10   # .error. Cannot apply STAR to Object and int
+        

Tests/300-type-inference/900-literals/500-lit-collections-dynamic.cobra

@@ +1 @@
+# List, Array, Set, Dict literals dynamic if heterogenous type and not object
+# ticket 176
+class DynLitSeq
+    def main 
+        .testList
+        .testArray
+        .testSet
+        .testDict
+        .testStream
+        
+    def testList    
+        a = 'aoeu' to Object 
+        b = 5 to Object 
+        l = [a to String, b to int]     # List<of HeterogenousObject>
+    
+        x = l[0] 
+        y = l[1] 
+        assert x.length == 4 
+        assert y * 2 == 10
+        
+        l1 = ['ae', 'aeiaei' ] # List<of String>
+        x1=l1[0]
+        assert x1.length == 2
+        assert l1[1].length == 6
+    
+    def testArray   
+        a = 'aoeu' to Object 
+        b = 5 to Object 
+        l = @[a to String, b to int]    # Array<of HeterogenousObject>
+    
+        x = l[0] 
+        y = l[1] 
+        assert x.length == 4 
+        assert y * 2 == 10
+    
+    def testSet
+        a = 'aoeu' to Object 
+        b = 5 to Object 
+        s = {a to String, b to int}     # Set<of HeterogenousObject>
+        
+        assert a in s
+        assert b in s
+        assert a to String in s
+        assert b to int in s
+        assert 'z' not in s
+        
+        l = s.toList
+        x = l[0] 
+        y = l[1] 
+        assert x.length == 4 
+        assert y * 2 == 10
+    
+    def testDict    
+        a = 'aoeu' to Object 
+        b = 5 to Object 
+        #l as Dictionary<of int,dynamic> = {0:a to String, 1:b to int} 
+        l = {0:a to String, 1:b to int}     # Dict<of int,HeterogenousObject>
+        
+        x = l[0] 
+        y = l[1] 
+        assert x.length == 4 
+        assert y * 2 == 10
+        
+    def testStream
+        stuff as dynamic*
+        stuff = [1, 'x']
+        count = 0
+        for x in stuff
+            assert x in {1, 'x'}
+            count += 1
+        assert count == 2
+
+        objStm as Object*
+        objStm = [1, 'x'] to List<of Object> # Heterogeneous lists are List<of dynamic> now
+        #objStm = [1 to Object, 'x' to Object] # also OK
+        count = 0
+        for x in objStm
+            assert x in {1, 'x'}
+            count += 1
+        assert count == 2
+        
+        
+        

Developer/IntermediateReleaseNotes.text

@@ -414 +414 @@
 * Fixed: `a += b` does not work if `a` is dynamically typed and referring to a string.
 
 * Fixed: Partial class merge problem re: inheritance. ticket:67
+
+* Fixed: Heterogeneous collection literals are inferred as <of Object> instead of <of dynamic>. ticket:176