Ticket #230: assign-empty-type-lits.patch

Source/Expr.cobra

@@ -2761 +2761 @@
 class CompositeLiteral
     inherits Literal
 
+    var _typeInferred = false
+
     cue init(token as IToken)
         base.init(token)
 
+    get isTentativelyTyped as bool
+        return false
 
 class SequenceLit
     is abstract, partial
     inherits CompositeLiteral
 
     var _exprs as List<of Expr>
-
+    var _typeNode as ITypeProxy?
+    
     cue init(token as IToken, exprs as List<of Expr>)
         base.init(token)
         _exprs = exprs
@@ -2789 +2794 @@
     get willChangeVar as bool is override
         for expr in _exprs, if expr.willChangeVar, return true
         return false
-
+        
+    get isTentativelyTyped as bool is override
+        # empty sequence and type not explicitly set
+        assert .didBindImp
+        return _exprs.count == 0 and _typeInferred == true
+    
     def _bindImp is override
         base._bindImp
         exceptions = List<of NodeException>()
@@ -2800 +2810 @@
                 exceptions.add(ne)
         if exceptions.count
             throw NodeMultiException(exceptions)
+        if _typeNode    # optional explicit type
+            _type = _convertTypeNode #_typeNode.realType
+            assert _type, _typeNode
+        seqType = _genExprsType
         if _type is nil
-            exprs = _exprs
-            if exprs.count == 0
-                type = .compiler.defaultType
-            else
-                type = exprs[0].type to !
-                for i in 1 : exprs.count
-                    exprs[i].bindImp
-                    type = exprs[i].type.greatestCommonDenominatorWith(type)
+            _type = seqType
+            _typeInferred = true
+        else if _exprs.count > 0   # type set from [...] as List<of TYPE>
+            if not seqType.isAssignableTo(_type to !)
+                .throwError('The common type of the sequence of expressions is [seqType.name] which is not assignable to the explicitly declared type [_type.name].')
+                
+    def _genExprsType as IType          
+        exprs = _exprs
+        if exprs.count == 0
+            type = .compiler.defaultType
+        else
+            type = exprs[0].type to !
+            for i in 1 : exprs.count
+                #exprs[i].bindImp   # is this necessary - done earlier in bindImp?
+                assert exprs[i].didBindImp
+                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)
-
+        if type inherits NilType, type = .compiler.defaultType
+        type = _makeTypeWith(type)
+        return type 
+    
+    def _convertTypeNode as IType
+        return _typeNode.realType   
+            
     def _makeTypeWith(type as IType) as IType is abstract
 
     get brackets as List<of String> is abstract
@@ -2834 +2860 @@
 class ListLit
     is partial
     inherits SequenceLit
-
+    
     # CC: should just inherit this because no initializers are defined
     cue init(token as IToken, exprs as List<of Expr>)
         base.init(token, exprs)
 
+    cue init(token as IToken, exprs as List<of Expr>, typeNode as ITypeProxy?)
+        base.init(token, exprs)
+        _typeNode = typeNode
+    
+    def _convertTypeNode as IType is override
+        type = _typeNode.realType   
+        if not type.isGenericListLike
+            sugg = ' Perhaps you meant "IList or List<of [type.name]>".'
+            .throwError('An explicit list literal type must be of form "List<of someType>" not "[type.name]".[sugg]')
+        return type
+        
     def _makeTypeWith(type as IType) as IType is override
         return .compiler.listOfType.constructedTypeFor([type])
 
     get brackets as List<of String> is override
         return [r'[', ']']
+        
 
-
 class ArrayLit inherits SequenceLit is partial
 
     # CC: should just inherit this because no initializers are defined
     cue init(token as IToken, exprs as List<of Expr>)
         base.init(token, exprs)
 
+    cue init(token as IToken, exprs as List<of Expr>, typeNode as ITypeProxy?)
+        base.init(token, exprs)
+        _typeNode = typeNode
+        
+    def _convertTypeNode as IType is override
+        if not _typeNode inherits ArrayTypeIdentifier
+            name = (_typeNode to AbstractTypeIdentifier).name
+            sugg = ' Perhaps you meant "[name]\[]".'
+            .throwError('An explicitly declared array type must be of form "someType\[]" not "[name]".[sugg]')
+        return _typeNode.realType   
+        
     def _makeTypeWith(type as IType) as IType is override
         return .typeProvider.arrayType(type)
 
@@ -2876 +2924 @@
     cue init(token as IToken, exprs as List<of Expr>)
         base.init(token, exprs)
 
+    cue init(token as IToken, exprs as List<of Expr>, typeNode as ITypeProxy?)
+        base.init(token, exprs)
+        _typeNode = typeNode
+        
+    def _convertTypeNode as IType is override
+        type = _typeNode.realType   
+        if not type.isSetLike
+            sugg = ' Perhaps you meant "Set<of [type.name]>".'
+            .throwError('An explicit set literal type must be of form "Set<of someType>" not "[type.name]".[sugg]')
+        return type
+
     def _makeTypeWith(type as IType) as IType is override
         return .compiler.setOfType.constructedTypeFor([type])
 
@@ -2900 +2959 @@
 class DictLit inherits CompositeLiteral is partial
 
     var _entries as List<of List<of Expr>>
+    var _typeNode as ITypeProxy?
 
     cue init(token as IToken, entries as List<of List<of Expr>>)
         base.init(token)
@@ -2908 +2968 @@
                 assert entry.count == 2
         _entries = entries
 
+    cue init(token as IToken, entries as List<of List<of Expr>>, typeNode as ITypeProxy?)
+        .init(token, entries)
+        _typeNode = typeNode
+        
     def addSubFields is override
         base.addSubFields
         .addField('entries', _entries)
@@ -2924 +2988 @@
         return false
 
     get entries from var
+    
+    get isTentativelyTyped as bool is override
+        # empty DictLit and type not explicitly set
+        assert .didBindImp
+        return _entries.count == 0 and _typeInferred == true
 
     def replaceChild(find as INode, replace as INode) as bool
         didReplace = base.replaceChild(find, replace)
@@ -2953 +3022 @@
                 hadError = true
         if hadError
             return
+        if _typeNode    # optional explicit type
+            type = _typeNode.realType
+            if not type.isDictionaryLike
+                .throwError('An explicit dict literal type must be of form "Dictionary<of keyType,valueType>" not "[type.name]".')
+            _type = type
+        entType = _genEntriesType
         if .type is nil
-            entries = _entries
-            if _entries.count == 0
-                keyType = valueType = .compiler.defaultType
-            else
-                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])
+            _type = entType
+            _typeInferred = true
+        else if _entries.count > 0   # type set from {...} as Dictionary<of TYPE,TYPE>
+            if not entType.isAssignableTo(_type to !)
+                .throwError('The common type of the dictionary literal expressions is [entType.name] which is not assignable to the explicitly declared type [_type.name].')
+        
+    def _genEntriesType as IType        
+        entries = _entries
+        if _entries.count == 0
+            keyType = valueType = .compiler.defaultType
+        else
+            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
+        entType = .compiler.dictionaryOfType.constructedTypeFor([keyType, valueType])
+        return entType
 
-
 class ToNilableOrNotExpr
     is abstract, partial
     inherits Expr

Source/Types.cobra

@@ -1869 +1869 @@
             return true
         return false
 
+    def isGenericListLike as bool
+        """
+        Returns true if the receiver is like a generic List, such as being an actual generic List type or a nilable version thereof.
+        The dynamic type will also return true because at compile-time, dynamic is considered to be like everything.
+        Requires Node.getCompiler
+        """
+        type = this
+        if type inherits NilableType
+            return type.nonNil.isGenericListLike
+        tp = Node.getCompiler  # 'tp' for 'type provider' 
+        genericList = tp.listOfType
+        if type.isDescendantOf(genericList)
+            return true
+        if type inherits Box
+            if type.genericDef is genericList
+                return true
+        genericIList = tp.ilistOfType
+        if type.isDescendantOf(genericIList)
+            return true
+        if type inherits Box
+            if type.genericDef is genericIList
+                return true
+        if type.isDynamic
+            return true
+        return false
+    
+    def isSetLike as bool
+        """
+        Returns true if the receiver is like a Set, such as being an actual Set type or a nilable version thereof.
+        The dynamic type will also return true because at compile-time, dynamic is considered to be like everything.
+        Requires Node.getCompiler
+        """
+        type = this
+        if type inherits NilableType
+            return type.nonNil.isSetLike
+        tp = Node.getCompiler  # 'tp' for 'type provider' 
+        genericSet = tp.setOfType
+        if type.isDescendantOf(genericSet)
+            return true
+        if type inherits Box
+            if type.genericDef is genericSet
+                return true
+        # probably should also check/test for ISet as well, provide accessor in Compiler        
+        if type.isDynamic
+            return true
+        return false
+        
     def isDictionaryLike as bool
         """
         Returns true if the receiver is like a dictionary, such as being an actual dictionary type or a nilable version thereof.

Source/CobraTokenizer.cobra

@@ -881 +881 @@
                 on 'skip', pass
                 on 'warning', pass
                 on 'warning-lax', pass
-                else, .throwError('Unrecognized compiler directive "[name]".')
+                else, .throwError('Unrecognized compiler directive "[name]". Known directives: "no-warnings" "args"')
             return true
         return false
 

Source/BinaryOpExpr.cobra

@@ -222 +222 @@
             left = _left
             if left inherits IdentifierExpr
                 if left.definition is nil
-                    definition = LocalVar(left.token, .compiler.passThroughType).bindAll to LocalVar  # CC: axe cast when supporting 'as this'
-                    .compiler.codeMemberStack.peek.addLocal(definition)
-                    left.setDefinition(definition)
-                    left.type = definition.type
+                    _inferVariableType(left, .compiler.passThroughType)
             if _type is nil
                 _type = .compiler.passThroughType
             throw
@@ -242 +239 @@
                     if right.hasError
                         # for a type inference situation, create a var of type passthrough for the left hand side
                         # to prevent superfluous errors in subsequent statements
-                        definition = LocalVar(left.token, .compiler.passThroughType).bindAll to LocalVar  # CC: axe cast when supporting 'as this'
-                        .compiler.codeMemberStack.peek.addLocal(definition)
-                        left.setDefinition(definition)
-                        left.type = definition.type
+                        _inferVariableType(left, .compiler.passThroughType)
                         _type = left.type
                         return
                     else
@@ -253 +247 @@
                 if left.name.startsWith('_')
                     .throwError('No class variable named "[left.name]" exists and local variable declarations cannot start with an underscore (_).')
                 inferredType = if(right.type inherits NilType, .compiler.nilableDynamicType, right.type)  # `x = nil` for a new local var `x` is inferred as `dynamic?`
-                definition = LocalVar(left.token, inferredType).bindAll to LocalVar  # CC: axe cast when supporting 'as this'
-                .compiler.codeMemberStack.peek.addLocal(definition)
-                left.setDefinition(definition)
-                left.type = definition.type
+                _inferVariableType(left, inferredType to !)
             if left.definition is nil
                 left.throwUnknownIdError
         if not right.canBeAssignedTo(left.type to !)
@@ -268 +259 @@
                         okay = true
             if not okay
                 .throwError('Incompatible types. Cannot assign value of type [right.type.name] on the right to [left.type.name] on the left.')
+                
+        # Retype the emptyLit expression to allow 
+        #   var as TYPE? ... var = emptyLit   and
+        #   var as TYPE = emptyLit
+        # emptyLit is one of [], @[], {}, {:}, {,}
+        if left inherits IdentifierExpr or left inherits AsExpr
+            if right inherits CompositeLiteral
+                if right.isTentativelyTyped 
+                    right.type = left.type.nonNil
+                
         _type = left.type
         right.contextType = _type
 
+    # define a local var of the name of the Identifier Expr with the given type
+    def _inferVariableType(left as IdentifierExpr, type as IType)
+        definition = LocalVar(left.token, type).bindAll to LocalVar  # CC: axe cast when supporting 'as this'
+        .compiler.codeMemberStack.peek.addLocal(definition)
+        left.setDefinition(definition)
+        left.type = definition.type
+
     def checkAfterBindImp
         base.checkAfterBindImp
         if not .hasError and _left.definition inherits Param

Source/CobraParser.cobra

@@ -3211 +3211 @@
     def literalList as ListLit
         token = .expect('LBRACKET')
         exprs = .commaSepExprs('RBRACKET.', true)
-        return ListLit(token, exprs)
+        if .peek.which=='AS'  # [] as List<of TYPE>
+            .grab
+            listType = .typeId
+        return  ListLit(token, exprs, listType)
 
     def literalArray as ArrayLit
         token = .expect('ARRAY_OPEN')
         exprs = .commaSepExprs('RBRACKET.', true)
-        return ArrayLit(token, exprs)
+        if .peek.which=='AS'  # @[] as TYPE[]
+            .grab
+            type = .typeId
+        return ArrayLit(token, exprs, type)
 
     def literalDictOrSet as CompositeLiteral
         token = .expect('LCURLY')
@@ -3230 +3236 @@
             on 'RCURLY'
                 .grab
                 _warning('Assuming empty dictionary, but please use "{:}" for empty dictionary or "{,}" for empty set')
-                return DictLit(token, List<of List<of Expr>>())
+                if .optional('AS')  # {:} as Dictionary<of TYPE,TYPE>
+                    type = .typeId
+                return DictLit(token, List<of List<of Expr>>(), type)
         expr = .expression
         _spaceAgnostic
         branch .peek.which
@@ -3261 +3269 @@
                 _spaceAgnostic
                 if .optional('RCURLY')
                     break
-            return SetLit(token, exprs)
         else
             .expect('COMMA')
             _spaceAgnostic
             .expect('RCURLY')
-            return SetLit(token, List<of Expr>())
+            exprs = List<of Expr>()
 
+        if .optional('AS')  # {,} as Set<of TYPE>
+            type = .typeId
+        return SetLit(token, exprs, type)
+
     def _literalDict(token as IToken, expr as Expr?) as DictLit
+        entries = List<of List<of Expr>>()
         if expr
             expectComma = false
-            entries = List<of List<of Expr>>()
             first = true
             while true
                 if first
@@ -3296 +3307 @@
                 value = .expression
                 entries.add([key, value])
                 expectComma = true
-            return DictLit(token, entries)
+            #return DictLit(token, entries)
         else
             .expect('COLON')
             _spaceAgnostic
             .expect('RCURLY')
-            return DictLit(token, List<of List<of Expr>>())
+
+        if .peek.which=='AS'  # {:} as Dictionary<of TYPE,TYPE>
+            .grab
+            type = .typeId
+        return DictLit(token, entries, type)
         
     def nameExpr as NameExpr
         nameToken = .expect('ID')

Tests/820-errors/400-declarations/600-typed-literals/102-list-literal-error-assign1.cobra

@@ +1 @@
+# List literal explicit typing mismatch declared type and later assignment
+class ListLitAs
+    def main is shared
+        l = [] as List<of MyClass>
+        l = ['hi'] # .error. Incompatible types. Cannot assign
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/200-array-literal-typed-error-type.cobra

@@ +1 @@
+# tests for explicit typing of Array literals
+class ListLitAs
+    def main is shared
+        cerr = @[] as String # .error. array type must be of form "someType[]"
+        CobraCore.noOp(cerr)

Tests/820-errors/400-declarations/600-typed-literals/203-array-literal-typed-assign1.cobra

@@ +1 @@
+# tests for explicit typing of Array literals
+class ListLitAs
+    def main is shared
+        l = @[] as MyClass[]
+        l = @['hi'] # .error. Incompatible types. Cannot assign value of type String[] on the right to MyClass[] on the left
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass
+

Tests/820-errors/400-declarations/600-typed-literals/101-list-literal-error-assignable.cobra

@@ +1 @@
+# List literal explicit typing mismatch expression types and declared type
+class ListLitAs
+    def main is shared
+        d = [1,2,3] as List<of String> # .error. List<of int> which is not assignable to the explicitly declared type List<of String>
+        CobraCore.noOp(d)

Tests/820-errors/400-declarations/600-typed-literals/304-set-literal-typed-error-assign2.cobra

@@ +1 @@
+# tests for explicit typing of Set literals
+class SetLitAs
+    def main is shared
+        l = {'hi',} as Set<of MyClass> # .error. The common type of the sequence of expressions is Set<of String> which is not assignable to the explicitly declared type Set<of MyClass>
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass
+

Tests/820-errors/400-declarations/600-typed-literals/400-dict-literal-typed-error-type.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {:} as String # .error. dict literal type must be of form "Dictionary<of keyType,valueType>"
+        CobraCore.noOp(d)
+

Tests/820-errors/400-declarations/600-typed-literals/204-array-literal-types-error-assign2.cobra

@@ +1 @@
+# tests for explicit typing of Array literals expr list type mismatch to declared User type
+class ListLitAs
+    def main is shared
+        l = @['hi'] as MyClass[] # .error. String[] which is not assignable to the explicitly declared type MyClass[]
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass
+

Tests/820-errors/400-declarations/600-typed-literals/100-list-literal-error-type.cobra

@@ +1 @@
+# List literal explicit typing unreasonable declared type
+class ListLitAs
+    def main is shared
+        cerr = [] as String # .error.  An explicit list literal type must be of form "List<of someType>" not "String"
+        CobraCore.noOp(cerr)

Tests/820-errors/400-declarations/600-typed-literals/402-dict-literal-typed-error-assign.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {1:1, 2:1, 3:1} as Dictionary<of int,String> # .error. not assignable 
+        CobraCore.noOp(d)
+

Tests/820-errors/400-declarations/600-typed-literals/403-dict-literal-typed-error-assign.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {:} as Dictionary<of int, MyClass>
+        d = { 'hi':MyClass() }  #.error. Incompatible types. Cannot assign value of type Dictionary<of String,MyClass> on the right to Dictionary<of int,MyClass> on the left
+        CobraCore.noOp(d)
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/404-dict-literal-typed-error-assign.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {'hi':10} as Dictionary<of int,MyClass> #.error. Dictionary<of String,int> which is not assignable to the explicitly declared type Dictionary<of int,MyClass>.
+        CobraCore.noOp(d)
+        #l1 = {'hi':10} as Dictionary<of String,MyClass>
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/300-set-literal-typed-error-type.cobra

@@ +1 @@
+# tests for explicit typing of Set literals
+class SetLitAs
+    def main is shared
+        c = {,} as String # .error. set literal type must be of form "Set<of someType>"
+        CobraCore.noOp(c)
+

Tests/820-errors/400-declarations/600-typed-literals/405-dict-literal-typed-error-assign.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {'hi':10} as Dictionary<of String,MyClass> # .error. The common type of the dictionary literal expressions is Dictionary<of String,int> which is not assignable to the explicitly declared type Dictionary<of String,MyClass>
+        CobraCore.noOp(d)
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/103-list-literal-error-assign.cobra

@@ +1 @@
+# List literal explicit typing mismatch expression and declared User type 
+class ListLitAs
+    def main is shared
+        l = ['hi'] as List<of MyClass> #.error. not assignable
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/301-set-literal-typed-assignable.cobra

@@ +1 @@
+# tests for explicit typing of Set literals
+class SetLitAs
+    def main is shared
+        d = {1,2,3} as Set<of String> # .error. not assignable
+        CobraCore.noOp(d)

Tests/820-errors/400-declarations/600-typed-literals/303-set-literal-types-error-assign1.cobra

@@ +1 @@
+# tests for explicit typing of Set literals
+class SetLitAs
+    def main is shared
+        l = {,} as Set<of MyClass>
+        l = {'hi'}  # .error. Cannot assign value of type Set<of String> on the right to Set<of MyClass> on the left
+        CobraCore.noOp(l)
+        
+class MyClass
+    pass

Tests/820-errors/400-declarations/600-typed-literals/201-array-literal-typed-error-assignable.cobra

@@ +1 @@
+# tests for explicit typing of Array literals
+class ListLitAs
+    def main is shared
+        d = @[1,2,3] as String[] # .error. not assignable to the explicitly declared type
+        CobraCore.noOp(d)

Tests/820-errors/400-declarations/600-typed-literals/401-dict-literal-typed-error-type1.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        d = {:} as List<of int> # .error. dict literal type must be of form "Dictionary<of keyType,valueType>"
+        CobraCore.noOp(d)

Tests/700-command-line/900-check-complier-message-format/200-check-compiler-message-format.cobra

@@ -19 +19 @@
         .check('120-bind-error.cobra')
 
     def check(sourceName as String)
-        re = Regex(r"[A-Za-z\.]+cobra\(\d+\): (error|warning): [^\(]+$", RegexOptions(Compiled, CultureInvariant))
+        re = Regex(r"[A-Za-z\.]+cobra\(\d+(,\d+)?\): (error|warning): [^\(]+$", RegexOptions(Compiled, CultureInvariant))
         # example output for regex ta match:
         # bind-error.cobra(4): error: Cannot find "y". There is a member named ".getType" with a similar name.
 

Tests/300-type-inference/900-literals/600-explicitly-typed/200-array-literal-typed.cobra

@@ +1 @@
+# tests for explicit typing of Array literals
+class ListLitAs
+    def main is shared
+        # below array typenames specific to .Net family
+        elObject = r'System.Object[]'
+        elString = r'System.String[]'
+        elInt    = r'System.Int32[]'
+        elMyClass= r'MyClass[]'
+        
+        a = @[]
+        #print a.typeOf
+        assert elObject in a.typeOf.toString
+        assert a.length ==0
+        
+        b = @[] as int[]
+        #print b.typeOf
+        assert elInt in b.typeOf.toString
+        assert b.length ==0
+        b = @[3,4]
+        assert b == @[3,4]
+        
+        c = @[] as String[]
+        assert elString in c.typeOf.toString
+        c = @['My']
+        assert c == @['My']
+        c = @['a', 'b']
+        assert c == @['a', 'b']
+        
+        l = @[] as MyClass[]
+        assert elMyClass in l.typeOf.toString
+        l = @[MyClass(), MyClass()]
+        assert l.length == 2
+    
+        lf = @[FunkClass()] as MyClass[]
+        assert elMyClass in lf.typeOf.toString
+        assert lf.length == 1
+        assert 'FunkClass' in lf[0].typeOf.toString
+    
+class MyClass
+    pass
+
+class FunkClass inherits MyClass
+    def wotAmI
+        print "I'm a funkyClass"
+

Tests/300-type-inference/900-literals/600-explicitly-typed/400-dict-literal-typed.cobra

@@ +1 @@
+# tests for explicit typing of Dict literals
+class DictLitAs
+    def main is shared
+        # below element typenames specific to .Net family
+        elObject = r'[System.Object,System.Object]'
+        elString = r'[System.String,System.Int32]'
+        elInt    = r'[System.Int32,System.String]'
+        elMyClass= r'[System.String,MyClass]'
+        
+        a = {:}
+        #print a.typeOf
+        assert elObject in a.typeOf.toString
+        assert a.count ==0
+        
+        b0 = {} as Dictionary<of int,String> #.warning. Assuming empty dictionary
+        #print b0.typeOf
+        assert elInt in b0.typeOf.toString
+        assert b0.count ==0
+        b0 = {3:'x0',4:'y0'}
+        assert b0.count == 2
+        assert b0[3] == 'x0' and b0[4] == 'y0'
+        
+        b = {:} as Dictionary<of int,String>
+        #print b.typeOf
+        assert elInt in b.typeOf.toString
+        assert b.count ==0
+        b = {3:'x',4:'y'}
+        assert b.count == 2
+        assert b[3] == 'x' and b[4] == 'y'
+
+        c = {:} as Dictionary<of String, int>
+        assert elString in c.typeOf.toString
+        c['My'] = 1
+        assert c.count ==1
+        assert c['My'] == 1
+        c = {'a':1, 'b':2}
+        assert c.count == 2
+        assert c['a'] == 1 and c['b'] == 2
+        
+        c1 = {'aa':1, 'bb':2} as Dictionary<of String, int>
+        assert elString in c1.typeOf.toString
+        assert c1.count == 2
+        assert c1['aa'] == 1 and c1['bb'] == 2
+        
+        l = {:} as Dictionary<of String, MyClass>
+        assert elMyClass in l.typeOf.toString
+        l = {'cl0':MyClass(), 'cl1':MyClass()}
+        assert l.count == 2
+    
+        fcls = FunkClass()
+        lf = {'mc':fcls} as Dictionary<of String, MyClass>
+        assert elMyClass in lf.typeOf.toString
+        assert lf.count == 1
+        assert lf['mc'] is fcls
+        #print 'done'
+        
+class MyClass
+    pass
+
+class FunkClass inherits MyClass
+    def wotAmI
+        print "I'm a funkyClass"
+

Tests/300-type-inference/900-literals/600-explicitly-typed/100-list-literal-typed.cobra

@@ +1 @@
+# tests for explicit typing of List literals
+class ListLitAs
+    def main is shared
+        # below element typenames specific to .Net family
+        elObject = r'[System.Object]'
+        elString = r'[System.String]'
+        elInt    = r'[System.Int32]'
+        elMyClass= r'[MyClass]'
+        
+        a = []
+        assert elObject in a.typeOf.toString
+        assert a.count ==0
+        
+        b = [] as List<of int>
+        #print b.typeOf
+        assert elInt in b.typeOf.toString
+        assert b.count ==0
+        b = [3,4]
+        assert b == [3,4]
+        
+        c = [] as List<of String>
+        assert elString in c.typeOf.toString
+        c.add('My')
+        assert c == ['My']
+        c = ['a', 'b']
+        assert c == ['a', 'b']
+        
+        l = [] as List<of MyClass>
+        assert elMyClass in l.typeOf.toString
+        l = [MyClass(), MyClass()]
+        assert l.count == 2
+    
+        lf = [FunkClass()] as List<of MyClass>
+        assert elMyClass in lf.typeOf.toString
+        assert lf.count == 1
+        assert 'FunkClass' in lf[0].typeOf.toString
+    
+        #TODO: IList
+        #ib = [] as IList<of >
+        
+class MyClass
+    pass
+
+class FunkClass inherits MyClass
+    def wotAmI
+        print "I'm a funkyClass"
+

Tests/300-type-inference/900-literals/600-explicitly-typed/300-set-literal-typed.cobra

@@ +1 @@
+# tests for explicit typing of Set literals
+class SetLitAs
+    def main is shared
+        # below element typenames specific to .Net family
+        elObject = r'[System.Object]'
+        elString = r'[System.String]'
+        elInt    = r'[System.Int32]'
+        elMyClass= r'[MyClass]'
+        
+        a = {,}
+        assert elObject in a.typeOf.toString
+        assert a.count ==0
+        
+        b = {,} as Set<of int>
+        #print b.typeOf
+        assert elInt in b.typeOf.toString
+        assert b.count ==0
+        b = {3,4}
+        assert b == {3,4}
+        
+        c = {,} as Set<of String>
+        assert elString in c.typeOf.toString
+        c.add('My')
+        assert c == {'My',}
+        c = {'a', 'b'}
+        assert c == {'a', 'b'}
+        
+        l = {,} as Set<of MyClass>
+        assert elMyClass in l.typeOf.toString
+        l = {MyClass(), MyClass()}
+        assert l.count == 2
+    
+        fcls = FunkClass()
+        lf = {fcls,} as Set<of MyClass>
+        assert elMyClass in lf.typeOf.toString
+        assert lf.count == 1
+        assert lf.contains(fcls)
+    
+class MyClass
+    pass
+
+class FunkClass inherits MyClass
+    def wotAmI
+        print "I'm a funkyClass"
+

Tests/300-type-inference/900-literals/600-explicitly-typed/500-assign-empty-lit.cobra

@@ +1 @@
+# Allow untyped empty literals to be assigned to explicitly typed variable - ticket 230
+use System.Text.RegularExpressions
+
+class DotNet_RETypes
+    # Regexp strings to match Types specific to .Net family
+    var reListOfInt         = r'List.*\[[A-Za-z.]*Int32\]'
+    var reSetOfInt          = r'Set.*\[[A-Za-z.]*Int32\]'
+    var reArrayOfInt        = r'Int32\[\]'
+    var reDictOfStringInt   = r'Dictionary.*\[[A-Za-z.]*String,.*Int32\]'
+    var reDictOfStringString= r'Dictionary.*\[[A-Za-z.]*String,.*String\]'
+        
+class AssignEmptyList
+    
+    def main 
+        .dclLaterAssignEmpty
+        .dclAndAssign
+        
+    def dclLaterAssignEmpty
+    
+        #if CobraCore.compileTarget =='.Net'
+        m = DotNet_RETypes()
+        #else if CobraCore.compileTarget =='Java'
+        #   m = Java_RETypes()
+        #...
+        
+        # List
+        alist as List<of int>?
+        alist = []
+        .chkPrintMatch(alist.typeOf, m.reListOfInt)
+        #print alist
+        #print alist.typeOf
+            
+        # set
+        aset as Set<of int>?
+        aset = {,}
+        .chkPrintMatch(aset.typeOf, m.reSetOfInt)
+        #print aset
+        #print aset.typeOf
+    
+        # array
+        arr as int[]?
+        arr = @[]
+        .chkPrintMatch(arr.typeOf, m.reArrayOfInt)
+        #print arr
+        #print arr.typeOf
+    
+        # dict
+        ad as Dictionary<of String, int>? 
+        ad = {} #.no-warnings.
+        .chkPrintMatch(ad.typeOf, m.reDictOfStringInt)
+        #print ad
+        #print ad.typeOf
+
+        ad1 as Dictionary<of String, String>? 
+        ad1 = {:}
+        #print ad1
+        #print ad1.typeOf
+        .chkPrintMatch(ad1.typeOf, m.reDictOfStringString)
+        
+        
+    def dclAndAssign
+        #if CobraCore.compileTarget =='.Net'
+        m = DotNet_RETypes()
+        #else ...
+        
+        alist as List<of int> = []
+        .chkPrintMatch(alist.typeOf, m.reListOfInt)
+        #print alist
+        #print alist.typeOf
+        
+        # set
+        aset as Set<of int> = {,}
+        .chkPrintMatch(aset.typeOf, m.reSetOfInt)
+        #print aset
+        #print aset.typeOf
+    
+        # array
+        arr as int[] = @[]
+        .chkPrintMatch(arr.typeOf, m.reArrayOfInt)
+        #print arr
+        #print arr.typeOf
+        #arr=@[1,2]
+        #print arr
+    
+        # dict
+        ad as Dictionary<of String, int> = {} #.no-warnings.
+        .chkPrintMatch(ad.typeOf, m.reDictOfStringInt)
+        #print ad
+        #print ad.typeOf
+
+        ad1 as Dictionary<of String, String> = {:}
+        .chkPrintMatch(ad1.typeOf, m.reDictOfStringString)
+        #print ad1
+        #print ad1.typeOf
+        
+        
+    def chkPrintMatch(t, ptn as String)
+        using sw = StringWriter()
+            print to sw
+                print t
+            assert Regex.isMatch(sw.toString, ptn)
+        

Developer/IntermediateReleaseNotes.text

@@ -65 +65 @@
 * Generate warning on use of deprecated `$sharp('...')` syntax in favor of newer alternate sharp-string-literal form: `sharp'...'` and `sharp"..."`.
 
 
+* Fixed: Make "a = []" do the right thing when a is of a known type: ticket:230
+  Includes allowing explicit typing of Composite Literals
+  e.g avar = [] as List<of RedBugs>   
+      avar as List<of RedBugs> = []
+
+      shapes = {} as Set<of Shapes>
+      shapes as Set<of Shapes> = {}
+      shapes = {Circle()} as Set<of Shapes> # otherwise infer as Set<of Circle>
+
+      iArr = @[] as int[]
+      iArr as int[] = @[]
+
+      d = {:} as Dictionary<of String, int>
+      d as Dictionary<of String, int> = {:}
+
 ================================================================================
 Library
 ================================================================================