Ticket #275: java-jvm-7.patch

Source/BackEndObjC/ObjcBackEnd.cobra

@@ -47 +47 @@
             #m = ObjCModule(filename, verbosity)
         return m
 
+    get baseExeName as String is override
+        """Resulting executable file name for compiled file(s) sans extension."""
+        return .compiler.clrBaseExeFileName     
+    
+    get fullExeName as String is override
+        """Resulting full executable file name (pathname+extn) for compiled file(s)."""
+        return .compiler.clrFullExeFileName
+
     def setupRunProcess(baseExe as String, fullExe as String) as Process is override
         p = Process()
-        p.startInfo.fileName = baseExe
+        p.startInfo.fileName = fullExe
         return p
         
     def setDefaultUseDirectives(ns as NameSpace) is override
@@ -130 +138 @@
 
     #def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace is override
 
+    def getEnumeratorMember(box as Box) as IMember? is override
+        """ Find iterator method member in given Box."""
+        return nil  #box.getIteratorMemberObjc
         
+    def getEnumeratorMemberType(box as Box, rt as IType) as IType? is override
+        """Return type from lookup of iterator 'next' field in given Box."""
+        return nil #    box.getIteratorNextTypeObjc(rt)
+    
+    def validatePrintDestType(t as IType, s as Stmt) is override
+        """Validate that the given Type is a valid destination for a print statement redirection."""
+        pass
+        
+        
 class GenerateObjcCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/Compiler.cobra

@@ -55 +55 @@
     Novell
 
 
-class BackEnd is abstract 
-    """
-    Holder for items specific to the backEnd implementation
-    """
-    
-    var _tagToTypeName = Dictionary<of String, String>()
-        """ Map from Typename tags used in compiler to backend specific qualified Type name"""
-    
-    cue init(compiler as Compiler)
-        base.init
-        _name = ''
-        _runTimeLibFileName = 'rtl'
-        _runTimeLibNativeSourceFileName = 'rtlSrc.ext'
-        __compiler = compiler
-
-    get name from var as String
-    
-    get cobraRuntimeLibFileName from _runTimeLibFileName as String 
-        """Name of the Cobra RunTime Library file for this backend."""
-
-    get runTimeLibNativeSourceFileName from _runTimeLibNativeSourceFileName as String
-        """Name of the backEnd source file containing any native code support for Cobra.Core."""
-
-    get compiler from __compiler as Compiler
-    
-    get tagToTypeName from var
-        """ Map from TypeName tags used in compiler to backend specific qualified TypeName"""
-    
-    def resolveTypeTag(qualifiedNameOrTag as String) as String
-        if qualifiedNameOrTag.contains('.')         
-            qualifiedName = qualifiedNameOrTag
-        else    
-            qualifiedName = .tagToTypeName[qualifiedNameOrTag]  # type tag to backend qualifiedName
-        return qualifiedName
-        
-    def makePhases(phases as IList<of Phase>) is abstract
-        """
-        Given a list of core phases for compilation complete it with additions (or even removals and
-        rearrangements if necessary) for this given backend.
-        """
-        
-    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is abstract
-        """
-        If parentNameSpace is the main system namespace and name is a backEnd builtin type 
-        return the Cobra equivalent language type name (or nil). 
-        """
-        
-    def computeOutName as String is abstract
-        """
-        Return the binary file output name for compilation of files for this backend.
-        """
-        
-    def genNativeModule(filename as String, verbosity as int) as Module? is abstract    
-        """
-        Check if a filename is a Native module and if so generate and return the Native module type for it
-        otherwise return nil.
-        """
-    
-    def setupRunProcess(baseExe as String, fullExe as String) as Process is abstract
-        """
-        Create and initialise the process to run the compiled program post compilation
-        setup varies on the backend (.Clr/Jvm) and platform.
-        """
-    
-    def setDefaultUseDirectives(ns as NameSpace) is abstract
-        """
-        Set the default Use directives into the given Namespace (usually topNamespace) for this backend.
-        """
-    
-    def fixLibExtension(libRef as String) as String is abstract
-        """
-        Augment given lib reference string with backend extension if not already have one.
-        """
-
-    def loadLibReference(reference as String) as String? is abstract
-        """
-        Load the given library reference file  using the current backend paradigms. 
-        Returns an error message, or nil if the reference was loaded correctly.
-        """
-    
-    def readSystemTypes is abstract
-        """ Read and Load System Types for backend for Compiler to make available"""
-        
-    def fixMemberSigs is abstract
-        """         
-        Most backends dont natively support nilablility, this marks/fixes the common backend
-        class signatures that should be marked nilable.
-        """
-    
-    def installNativeMethods(box as Box, nativeType as NativeType) is abstract
-        """
-        Setup so that static methods (on Primitives and some others) get installed/treated as normal methods
-        on the instance.
-        """
-            
-    def isRunnableFile( fullExeFileName as String) as bool is abstract
-        """Test if given filename is an executable ( vs a library or something else) """
-
-    # Native Types access
-    def cobraNameForNativeBoxName(name as String) as String is abstract
-        """
-        Returns name from backend library entries converted to cobra naming form.
-        """
-    
-    get objectTypeProxy as AbstractTypeProxy is abstract
-        """BE TypeProxy for root of back end Object hierarchy."""
-
-    get typeTypeProxy as AbstractTypeProxy is abstract
-        """BE TypeProxy for BE notion of a class describing a Type."""
-
-    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is abstract
-        """
-        Return a Proxy placeHolder for a BackEnd Native Type.
-        """
-        
-    def nativeType(type as dynamic) as NativeType is abstract
-        """
-        Return a Native Type wrapped so we can use it without explicitly knowing what it is anywhere
-        else but the providing back end. Used by the backends to generate Types from Libraries.
-        """
-    
-    def nativeTypeByName(qualifiedName as String) as NativeType is abstract
-        """
-        Return a Native Type corresponding to the fully qualified name.
-        Abstract Type Literal tags used in the compiler directly can also be obtained through this
-        otherwise the qualified names are expected to conform to the platform back end naming. 
-        """
-    
-    def prepSystemObjectClass(box as Box) is abstract
-        """Setup additional or convenience members on the System Object class. """
-        
-    def scanGenericArgs(box as Box) is abstract
-        """Scan a loaded Dll (generic) type and translate from native any generic Args."""
-        
-    def scanNativeType(box as Box) is abstract
-        """Scan a loaded Dll type and convert its native Type info to Cobras form """
-        
-    def scanNativeType(edcl as EnumDecl) is abstract
-        """Scan a loaded Dll Enum type and convert its native info to Cobras form """
-        
-    def setUnderlyingType(edcl as EnumDecl)  is abstract
-        """Set underlying Storage Type of the value of an Enum."""
-        
-    def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType
-        """
-        The real extended type is the type of the first argument of any method.
-        Find and make that type from the param list.
-        """
-        throw Exception('Need implementation of determineExtnNativeType for backend to determine type for an extension')
-
-    def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace
-        """ 
-            What to do if a namespace name collides with an existing symbol.
-            Some backends disallow this situation so its an error.
-            Others keep namespace and symbol tables separate so its perfectly
-            allowable.
-        """
-        throw Exception('In [ns.name] there is a already non-namespace declaration named "[name]".')
-    
-
-class FakeBackEnd inherits BackEnd
-    """ Stub BackEnd for tests. """
-    
-    cue init(compiler as Compiler)
-        base.init(compiler)
-        _name = 'c#-clr(basic)'
-        _runTimeLibFileName = 'cobraRTL.libext'
-        _runTimeLibNativeSourceFileName = 'cobraRTL.ext'
-        
-        _tagToTypeName = {
-            'Object': 'System.Object',
-            'Type'  : 'System.Type',
-        }
-        
-    def makePhases(phases as IList<of Phase>) is override
-        pass
-        
-    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override
-        return nil
-
-    def computeOutName as String  is override
-        return 'FakeOut'
-        
-    def genNativeModule(filename as String, verbosity as int) as Module?  is override
-        return nil
-    
-    def setupRunProcess(baseExe as String, fullExe as String) as Process  is override
-        p = Process()
-        p.startInfo.fileName = 'echo' 
-        p.startInfo.arguments = 'basic BackEnd process - [baseExe]'
-        return p        
-    
-    def setDefaultUseDirectives(ns as NameSpace)  is override
-        pass
-    
-    def fixLibExtension(libRef as String) as String is override
-        if not libRef.endsWith('.libext')
-            libRef += '.libext'
-        return libRef   
-    
-    def loadLibReference(reference as String) as String? is override
-        return nil
-    
-    def readSystemTypes is override
-        pass
-    
-    def fixMemberSigs is override
-        pass
-    
-    def installNativeMethods(box as Box, nativeType as NativeType) is override
-        pass
-        
-    def isRunnableFile(fullExeFileName as String) as bool is override
-        return true
-        
-    # Native Type access
-    def cobraNameForNativeBoxName(name as String) as String is override
-        return name + '_BBE'
-    
-    def prepSystemObjectClass(box as Box) is override
-        pass
-        
-    def scanGenericArgs(box as Box) is override
-        pass
-        
-    def scanNativeType(box as Box) is override
-        pass
-        
-    def scanNativeType(edcl as EnumDecl) is override
-        pass
-        
-    def setUnderlyingType(edcl as EnumDecl)  is override
-        pass
-
-    # Types
-    get objectTypeProxy as AbstractTypeProxy is override
-        return ClrTypeProxy(Object) # for testing
-            
-    get typeTypeProxy  as AbstractTypeProxy is override
-        return ClrTypeProxy(Type )# for testing
-
-    def nativeTypeProxy(type as NativeType) as NativeTypeProxy is override
-        return ClrTypeProxy(type) #TODO: fix this to something non BE specific Tmp
-        
-    def nativeType(type) as NativeType is override
-        return ClrNativeType(type) #TODO: fix this to something non BE specific Tmp
-    
-    def nativeTypeByName(qualifiedName as String) as NativeType is override
-        return ClrNativeType(System.Object) #TODO: fix this to something non BE specific Tmp
-
-
 class Compiler implements ITypeProvider, IWarningRecorder, IErrorRecorder, ICompilerForNodes is partial
     """
     General notes:
@@ -346 +95 @@
     var _intermediateFileNames as List<of String>
     var _loadedReferences as List<of String>
 
-
     # caches
     var _primitiveToITypeCache as IDictionary<of dynamic, IType>? # Key is backend type for a Type ( e.g System.Type)
 
@@ -405 +153 @@
         Returns a cache mapping BackEnd types to their corresponding ITypes.
         Populated and used by the backend TypeProxy implementations ( {Clr,Jvm,...}TypeProxy)
         """
+        
     set primitiveCache as IDictionary<of dynamic, IType>
         assert value.count <> 0
         _primitiveToITypeCache = value
@@ -502 +251 @@
     pro linesCompiled from var as int 
     pro nodesCompiled from var as int 
     pro tokensCompiled from var as int 
+    
 
+    get baseExeFileName as String
+        """Returns the executable file name sans extension."""
+        return .backEnd.baseExeName
+
+    get fullExeFileName as String
+        """Returns the executable file name path with extension."""
+        return .backEnd.fullExeName
+    
     def recordError(error as SourceException)
         """
         Node calls this to record errors.
@@ -1335 +1093 @@
 
     def setOfType as Class
         return _libraryClass('Set<of>')
-
+        
+    def keyValuePairOfType as Box
+        return _libraryBox('KeyValuePair<of,>') 
+        
     def libraryType(qualifiedNameOrTag as String) as IType
         """
         Implemented for ITypeProvider, but use the more specific methods such as .stringType instead.
@@ -1366 +1127 @@
         thing as IContainer? = nil
         for name in names
             possible = (thing ? ns).declForName(name)
-            #print name
             # dbg
-            #if not possible
-            #   trace thing ? ns
-            #   ((thing ? ns) to NameSpace).dumpDeclsNameKeys
+            if Utils.isDevMachine and not possible
+                ctnr = (thing ? ns)
+                print 'NAME_LOOKUP_FAILURE: Cannot find "[name]" in namespace/Container "[ctnr.name]"' 
+                trace name, ctnr
+                (ctnr to NameSpace).dumpDeclsNameKeys
             assert possible, name
             if possible inherits IContainer
                 thing = possible
@@ -1409 +1171 @@
     #special type proxies for common Types -  Object and Type
     def objectTypeProxy as AbstractTypeProxy 
         """
-        Type proxy for BE notion of a class for the root of Object hierarchy
+        Type proxy for backEnd notion of a class for the root of Object hierarchy
             e.g. Object in dotNet
         """
-        #return ClrTypeProxy(Object)
         return .backEnd.objectTypeProxy
 
     def typeTypeProxy as AbstractTypeProxy 
         """
-        Type proxy for BE notion of a class for a Type
+        Type proxy for backEnd notion of a class for a Type
             e.g. System.Type in dotNet, java.lang.class in Java
         """
-        #return ClrTypeProxy(Type)
         return .backEnd.typeTypeProxy
         
     def nativeType(qualifiedName as String) as NativeType

Source/Expr.cobra

@@ -1019 +1019 @@
                 else
                     arg.recordError('Cannot find "[arg.name]" in enumeration "[.name]"')
 
+        defn = _type to EnumDecl
+        if _args.count > 1 and not defn.isUsedAsSet
+            defn.isUsedAsSet = true
+            _type = defn
 
 class ForExpr inherits Expr is partial
 

Source/Boxes.cobra

@@ -600 +600 @@
 # TODO: can a for loop go through an IEnumerator<of>?
 #       if .isConstructed and .genericDef is .compiler.enumeratorOfType
 #           return .genericParams[0]
-        getEnum as IMember?
-        if .declForName('getEnumerator') is nil
-            # Comes up for IList<of T> which has multiple 'getEnumerator' methods in ancestor interfaces
-            for member in .allMembersForName('getEnumerator')
-                if member inherits Method and member.parentBox.isGeneric
-                    getEnum = member
-                    break
-        if getEnum is nil
-            getEnum = .symbolForName('getEnumerator', true)
+        getEnum  = .backEnd.getEnumeratorMember(this) # Enumerator/Iterator
         if getEnum
             assert getEnum.didBindInt
+            # CLR specific 
             # can have two getEnumerators -- one generic and the other not. favor the generic one
             if getEnum inherits MemberOverload
                 for member in getEnum.members
@@ -619 +612 @@
                             # implementing IEnumerable<of T> which requires two `getEnumerator` members
                             getEnum = member
                             break
-            rt = getEnum.resultType
+            rt as IType? = getEnum.resultType
             if rt.isDynamicOrPassThrough
                 return rt
             rt = rt.nonNil  # nilable is not a concern; unwrap it
-            if rt inherits Box and (rt to Box).isGeneric
-                # don't take the first argument of the result type -- that won't work for a nested type in a generic class, like ValueCollection, which gets the generic params of its parents
-                rt = rt.memberForName('current').resultType
-                return rt
-            else
-                if rt.isDescendantOf(.compiler.dictEnumeratorType)
-                    return rt.memberForName('entry').resultType
-                if rt.isDescendantOf(.compiler.enumeratorType)
-                    rt = rt.memberForName('current').resultType
-                    if rt.nonNil.isSystemObjectClass
-                        # can we do better with indexer returnType? (e.g. MatchCollection)
-                        indexer = .symbolForName(r'[]', true)
-                        if indexer, rt = indexer.resultType
-                    return rt
-                else
-                    throw FallThroughException({'rt': rt, 'this': this, 'getEnum': getEnum})
+            rt = .backEnd.getEnumeratorMemberType(this, rt to !) # type for method returning enumerator/iterator item
+            return rt
         return nil
-
+            
     def isEquatableTo(t as IType) as bool
         r = base.isEquatableTo(t)
         if not r and t inherits CharType and this is .compiler.stringType  # TODO: hacky? could this be determined by looking for a static == operator overload?
@@ -1103 +1082 @@
         return t
 
     def __constructTypeFor(typeArgs as List<of IType>) as Box
-        """ Creates the constructed type. Does not issue any .bindInh, .bindInt, or _prepFoo. """
+        """ Creates the constructed generic instance type. Does not issue any .bindInh, .bindInt, or _prepFoo. """
         t = .memberwiseClone to Box
         assert t is not this
         argNames = (for type in typeArgs get type.name).join(',')

Source/Container.cobra

@@ -160 +160 @@
                 _declsByNameCI[decl.name.toLower] = decl
             else
                 _declsByNameCI.add(decl.name.toLower, decl)
-
+                
+    def rmDecl(decl as TMember)
+        """
+        Drop an existing Decl.
+        This is for some platforms with different naming/collision rules than C#/.Net.
+        We have detected a collision and choose to handle it by clearing the existing decl  
+        """
+        require
+            decl.name.length
+            .declsInOrder.contains(decl)
+            .declForName(decl.name) is not nil
+        ensure
+            not .declsInOrder.contains(decl)
+            .declForName(decl.name) is nil
+            .declForNameCI(decl.name) is nil
+            .declsInOrder.count == old .declsInOrder.count - 1
+        body
+            _declsInOrder.remove(decl)
+            _declsByName.remove(decl.name)
+            _declsByNameCI.remove(decl.name.toLower)
+        
     def declForName(name as String) as TMember?
         require
             name.length

Source/BinaryOpExpr.cobra

@@ -808 +808 @@
         base._bindImp
         _type = .compiler.boolType
         if not .hasError
-            if .right.type.innerType is nil
+            if not .right.type inherits EnumDecl and .right.type.innerType is nil
                 .recordError('The right-hand expression for "in" is of type "[.right.type.name]" which contains nothing.')
             else if .left.type.nonNil inherits CharType and .right.type is .compiler.stringType
                 # special case because there is no String.contains that takes a char
@@ -852 +852 @@
         if contains inherits Method
             if contains.params.count == 1 and _isAssignableTo(whatType, contains.params[0].type)
                 return true
+        if containerType inherits EnumDecl and _isAssignableTo(whatType, containerType), return true
         return false
 
     def _isAssignableTo(a as IType, b as IType) as bool

Source/Node.cobra

@@ -1226 +1226 @@
     def exceptionType as Class
     def idictionaryType as Box
     def idictionaryOfType as Box
+    def keyValuePairOfType as Box
     def ilistType as Box
     def ilistOfType as Box
     def listOfType as Class

Source/BackEnd.cobra

@@ +1 @@
+"""
+Abstract Base class for defining items that have different implementations
+    for each back end.
+    
+        Used in Compiler, 
+        Backends defined/implemented in BackEnd<BE>/<be>BackEnd 
+            e.g. BackEndJvm/JvmBackEnd.cobra, BackendClr/ClrBackEnd
+    Still subject to change.        
+"""
+
+use System.Diagnostics
+
+class BackEnd is abstract 
+    """
+    Holder for items and actions specific to the backEnd implementation
+    """
+    
+    var _tagToTypeName = Dictionary<of String, String>()
+        """ Map from Typename tags used in compiler to backend specific qualified Type name"""
+    
+    get name from _name as String
+        """Name of this backend: format is 'language-platform' e.g 'c#-clr'.""" 
+
+    get cobraRuntimeLibFileName from _runTimeLibFileName as String 
+        """Name of the Cobra RunTime Library file for this backend."""
+
+    get runTimeLibNativeSourceFileName from _runTimeLibNativeSourceFileName as String
+        """Name of the backEnd source file containing any native code support for Cobra.Core."""
+            
+    get compiler from __compiler as Compiler
+    
+    
+    cue init(compiler as Compiler)
+        base.init
+        _name = ''
+        # these two are unused defaults, overidden in concrete classes
+        _runTimeLibFileName = 'rtl'
+        _runTimeLibNativeSourceFileName = 'rtlSrc.ext'
+        __compiler = compiler
+
+    get tagToTypeName from var
+        """ Map from TypeName tags used in compiler to backend specific qualified TypeName"""
+    
+    def resolveTypeTag(qualifiedNameOrTag as String) as String
+        """Turn qualified type name or a type tag into backEnd className."""
+        if qualifiedNameOrTag.contains('.')         
+            qualifiedName = qualifiedNameOrTag
+        else    
+            qualifiedName = .tagToTypeName[qualifiedNameOrTag]  # type tag to backend qualifiedName
+        return qualifiedName
+        
+    def makePhases(phases as IList<of Phase>) is abstract
+        """
+        Given a list of core phases for compilation complete it with additions (or even removals and
+        rearrangements if necessary) for this given backend.
+        """
+        
+    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is abstract
+        """
+        If parentNameSpace is the main system namespace and name is a backEnd builtin type 
+        return the Cobra equivalent language type name (or nil). 
+        """
+        
+    def computeOutName as String is abstract
+        """
+        Return the binary file output name for compilation of files for this backend.
+        """
+        
+    get baseExeName as String 
+        """Resulting Executable file name for compiled file(s) sans extension."""
+        return ''
+            
+    get fullExeName as String
+        """Resulting executable file name (pathname+extn) for compiled file(s)."""
+        return ''
+        
+    def genNativeModule(filename as String, verbosity as int) as Module? is abstract    
+        """
+        Check if a filename is a Native module and if so generate and return the Native module type
+         for it otherwise return nil.
+        """
+    
+    def setupRunProcess(baseExe as String, fullExe as String) as Process is abstract
+        """
+        Create and initialise the process to run the compiled program post compilation
+        setup varies on the backend (.Clr/Jvm) and platform.
+        """
+    
+    def setDefaultUseDirectives(ns as NameSpace) is abstract
+        """
+        Set the default Use directives into the given Namespace (usually topNamespace) for this backend.
+        """
+    
+    def fixLibExtension(libRef as String) as String is abstract
+        """
+        Augment given lib reference string with backend extension if not already have one.
+        """
+
+    def loadLibReference(reference as String) as String? is abstract
+        """
+        Load the given library reference file using the current backend paradigms. 
+        Returns an error message, or nil if the reference was loaded correctly.
+        """
+    
+    def readSystemTypes is abstract
+        """ Read and Load the System Types for this backend for the compiler to make available."""
+        
+    def fixMemberSigs is abstract
+        """         
+        Most backends dont natively support nilablility, this marks/fixes the common backend
+        class signatures that should be marked nilable.
+        """
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) is abstract
+        """
+        Setup so that static methods (on Primitives and some others) get installed/treated as 
+        normal methods on the instance.
+        """
+            
+    def isRunnableFile( fullExeFileName as String) as bool is abstract
+        """Test if given filename is an executable ( vs a library or something else) """
+
+    # Native Types access
+    def cobraNameForNativeBoxName(name as String) as String is abstract
+        """
+        Returns name from backend library entries converted to cobra naming form.
+        """
+    
+    get objectTypeProxy as AbstractTypeProxy is abstract
+        """Return backEnd TypeProxy for root of back end Object hierarchy."""
+
+    get typeTypeProxy as AbstractTypeProxy is abstract
+        """Return backEnd TypeProxy for BackEnd notion of a class describing a Type."""
+
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is abstract
+        """
+        Return a proxy placeHolder for a BackEnd Native Type.
+        """
+        
+    def nativeType(type as dynamic) as NativeType is abstract
+        """
+        Return a Native Type wrapped so we can use it without explicitly knowing what it is anywhere
+        else but the providing back end. Used by the backends to generate Types from Libraries.
+        """
+    
+    def nativeTypeByName(qualifiedName as String) as NativeType is abstract
+        """
+        Return a Native Type corresponding to the fully qualified name.
+        Abstract Type literal tags used in the compiler directly can also be obtained through this
+        otherwise the qualified names are expected to conform to the platform back end naming. 
+        """
+    
+    def prepSystemObjectClass(box as Box) is abstract
+        """Setup additional or convenience members on the System Object class. """
+        
+    def scanGenericArgs(box as Box) is abstract
+        """Scan a loaded Dll (generic) type and translate from native any generic Args."""
+        
+    def scanNativeType(box as Box) is abstract
+        """Scan a loaded Dll type and convert its native Type info to Cobras form """
+        
+    def scanNativeType(edcl as EnumDecl) is abstract
+        """Scan a loaded Dll Enum type and convert its native info to Cobras form """
+        
+    def setUnderlyingType(edcl as EnumDecl)  is abstract
+        """Set underlying Storage Type of the value of an Enum."""
+        
+    def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType
+        """
+        The real extended type is the type of the first argument of any method.
+        Find and make that type from the param list.
+        """
+        throw Exception('Need implementation of determineExtnNativeType for backend to determine type for an extension')
+
+    def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace
+        """ 
+        What to do if a namespace name collides with an existing symbol.
+        Some backends disallow this situation so its an error.
+        Others keep namespace and symbol tables separate so its perfectly allowable.
+        """
+        throw Exception('In [ns.name] there is a already non-namespace declaration named "[name]".')
+    
+    def getEnumeratorMember(box as Box) as IMember? is abstract
+        """Find enumerator/iterator method member in given Box."""
+        
+    def getEnumeratorMemberType(box as Box, rt as IType) as IType? is abstract
+        """
+        Return the type from lookup of enumerator/iterator 'next-item' field for 
+        provided enumerator/iterator (rt) from iterator for given Box.
+        """
+    
+    def validatePrintDestType(t as IType, s as Stmt) is abstract
+        """
+        Validate the given Type as a valid destination for a print statement redirection.
+        If not record an error message against the stmt node.
+        """
+    
+        
+class FakeBackEnd inherits BackEnd
+    """ Stub BackEnd for tests. """
+    
+    cue init(compiler as Compiler)
+        base.init(compiler)
+        _name = 'c#-clr(test)'
+        _runTimeLibFileName = 'cobraRTL.libext'
+        _runTimeLibNativeSourceFileName = 'cobraRTL.ext'
+        
+        _tagToTypeName = {
+            'Object': 'System.Object',
+            'Type'  : 'System.Type',
+        }
+        
+    def makePhases(phases as IList<of Phase>) is override
+        pass
+        
+    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override
+        return nil
+
+    def computeOutName as String  is override
+        return 'FakeOut'
+        
+    def genNativeModule(filename as String, verbosity as int) as Module?  is override
+        return nil
+    
+    def setupRunProcess(baseExe as String, fullExe as String) as Process  is override
+        p = Process()
+        p.startInfo.fileName = 'echo' 
+        p.startInfo.arguments = 'basic BackEnd process - [fullExe]'
+        return p        
+    
+    def setDefaultUseDirectives(ns as NameSpace)  is override
+        pass
+    
+    def fixLibExtension(libRef as String) as String is override
+        if not libRef.endsWith('.libext')
+            libRef += '.libext'
+        return libRef   
+    
+    def loadLibReference(reference as String) as String? is override
+        return nil
+    
+    def readSystemTypes is override
+        pass
+    
+    def fixMemberSigs is override
+        pass
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) is override
+        pass
+        
+    def isRunnableFile(fullExeFileName as String) as bool is override
+        return true
+        
+    # Native Type access
+    def cobraNameForNativeBoxName(name as String) as String is override
+        return name + '_BBE'
+    
+    def prepSystemObjectClass(box as Box) is override
+        pass
+        
+    def scanGenericArgs(box as Box) is override
+        pass
+        
+    def scanNativeType(box as Box) is override
+        pass
+        
+    def scanNativeType(edcl as EnumDecl) is override
+        pass
+        
+    def setUnderlyingType(edcl as EnumDecl)  is override
+        pass
+
+    # Types
+    get objectTypeProxy as AbstractTypeProxy is override
+        return ClrTypeProxy(Object) # for testing
+            
+    get typeTypeProxy  as AbstractTypeProxy is override
+        return ClrTypeProxy(Type )# for testing
+
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy is override
+        return ClrTypeProxy(type) #TODO: fix this to something non BE specific Tmp
+        
+    def nativeType(type) as NativeType is override
+        return ClrNativeType(type) #TODO: fix this to something non BE specific Tmp
+    
+    def nativeTypeByName(qualifiedName as String) as NativeType is override
+        return ClrNativeType(System.Object) #TODO: fix this to something non BE specific Tmp
+        
+    def getEnumeratorMember(box as Box) as IMember? is override
+        return nil
+        
+    def getEnumeratorMemberType(box as Box, rt as IType) as IType? is override
+        return nil
+        
+    def validatePrintDestType(t as IType, s as Stmt) is override
+        pass

Source/BackEndClr/SharpGenerator.cobra

@@ -10 +10 @@
 
 class Compiler is partial
 
+    # executable filenames
     var _baseExeFileName as String = ''
     var _fullExeFileName as String = ''
 
-
+    get clrBaseExeFileName from _baseExeFileName
+    get clrFullExeFileName from _fullExeFileName
+    
     # The next two properties are set in GenerateSharpCodePhase
     
     pro nativeCompiler from var = ''
@@ -84 +87 @@
 
     var _didWriteSharpInfoClass as bool
 
-    get baseExeFileName from var
-        """
-        Returns the exe file name sans extension.
-        """
-
-    get fullExeFileName from var
-        """
-        Returns the exe file name with extension.
-        """
-
     var _platform as PlatformEnum?
 
     get platform as PlatformEnum
@@ -103 +96 @@
         return _platform to !
 
     def computeOutNameSharp as String
-        ensure result == .fullExeFileName
+        ensure result == _fullExeFileName
         outName = ''
         if .options.boolValue('test')
             outName = _modules.last.sharpFileName
@@ -240 +233 @@
 
             _deleteIntermediateFiles
             
-            _copyCore(outName)
+            _copyCoreClr(outName)
 
-    def _copyCore(outName as String)
+    def _copyCoreClr(outName as String)
         if not .options.boolValue('copy-core'), return
         sourceDir = Path.getDirectoryName(Assembly.getEntryAssembly.location) ? ''
         outDir = Path.getDirectoryName(outName) ? ''
@@ -286 +279 @@
                 throw StopCompilation(this)
         _cobraSharpProxy.reset
 
-        backEndOptions.add('[optChar]out:[.fullExeFileName]')
+        backEndOptions.add('[optChar]out:[_fullExeFileName]')
 
         args = List<of String>(backEndOptions)
         args.addRange(sharpFileNameList)
@@ -318 +311 @@
             pass
         else if File.exists(cscPath+'.exe')
             cscPath += '.exe'
-        backEndOptions += ' "[optChar]out:[.fullExeFileName]"'
+        backEndOptions += ' "[optChar]out:[_fullExeFileName]"'
         p = System.Diagnostics.Process()
         p.startInfo.fileName = cscPath
         sharpFileNames = (for fileName in sharpFileNameList get '"' + fileName + '"').join(' ')
@@ -343 +336 @@
         cp.compilerOptions = backEndOptions
         cp.referencedAssemblies.add('System.dll')
         cp.generateExecutable = .options.getDefault('target', 'exe') in ['exe', 'winexe']
-        cp.outputAssembly = .fullExeFileName
+        cp.outputAssembly = _fullExeFileName
         if _verbosity >= 2
             print 'Code Provider =', provider
             print '    compilerOptions =', backEndOptions
             print '    referencedAssemblies =', cp.referencedAssemblies
             print '    generateExecutable =', cp.generateExecutable
-            print '    outputAssembly =', .fullExeFileName
+            print '    outputAssembly =', _fullExeFileName
             print '    sharpFileNameList =', sharpFileNameList
         cr = provider.compileAssemblyFromFile(cp, sharpFileNameList.toArray)
         if false
@@ -4720 +4713 @@
                     sw.write(')')
                     if v, sw.write('/* A */')
                 else
-                    .writeInCheck(sw, false, v)
+                    .writeInCheckSharp(sw, false, v)
                     if v, sw.write('/* B */')
                 sw.write(')')
             else
@@ -4746 +4739 @@
                     if v, sw.write('/* D */')
                 sw.write(' })')
         else
-            .writeInCheck(sw, parens, v)
+            .writeInCheckSharp(sw, parens, v)
             if v, sw.write('/* E */')
 
-    def writeInCheck(sw as CurlyWriter, parens as bool, v as bool)
+    def writeInCheckSharp(sw as CurlyWriter, parens as bool, v as bool)
         if .containsExpr
             .containsExpr.writeSharpDef(sw, parens)
             if v, sw.write('/* F */')

Source/BackEndClr/ScanClrType.cobra

@@ -457 +457 @@
         meth = Method(TokenFix.empty, TokenFix.empty, this, 'getType', List<of Param>(), .compiler.typeTypeProxy, nil, ['shared'], AttributeList(), 'Returns the Type instance that defines this type.')
         meth.sharedMethodBacking = 'typeof'
         overload.addMember(meth)
-        
+    
+    # Enumeration lookup
+    def getEnumeratorMemberClr as IMember?
+        """
+        Step1 of 2 step lookup for Enumerator type - return getEnumeratorMember for current box 
+        """
+        getEnum as IMember? 
+        if .declForName('getEnumerator') is nil
+            # Comes up for IList<of T> which has multiple 'getEnumerator' methods in ancestor interfaces
+            for member in .allMembersForName('getEnumerator')
+                if member inherits Method and member.parentBox.isGeneric
+                    getEnum = member
+                    break
+        if getEnum is nil
+            getEnum = .symbolForName('getEnumerator', true)
+        if getEnum
+            assert getEnum.didBindInt
+            # can have two getEnumerators -- one generic and the other not. favor the generic one
+            if getEnum inherits MemberOverload
+                for member in getEnum.members
+                    if member inherits Method
+                        if member.resultType <> .compiler.objectType
+                            # implementing IEnumerable<of T> which requires two `getEnumerator` members
+                            getEnum = member
+                            break
+        return getEnum
+            
+    def getEnumeratorMemberTypeClr(rt as IType) as IType?
+        """
+        Step2 of 2 step lookup for Enumerator type - return the type for Enumerator member for current box 
+        rt is the resultType from getEnumerator lookup above - i.e the Enumerator for this Box
+        """
+        if rt inherits Box and (rt to Box).isGeneric
+            # don't take the first argument of the result type -- that won't work for a nested type in a generic class, like ValueCollection, which gets the generic params of its parents
+            return rt.memberForName('current').resultType
+        else
+            if rt.isDescendantOf(.compiler.dictEnumeratorType)
+                return rt.memberForName('entry').resultType
+            if rt.isDescendantOf(.compiler.enumeratorType)
+                rt = rt.memberForName('current').resultType
+                if rt.nonNil.isSystemObjectClass
+                    # can we do better with indexer returnType? (e.g. MatchCollection)
+                    indexer = .symbolForName(r'[]', true)
+                    if indexer, rt = indexer.resultType
+                return rt
+            else
+                throw FallThroughException({'rt': rt, 'this': this })
+        return nil
+    
+    # dll scanning
     def scanNativeTypeClr
         """
         Subclasses should invoke base and then invoke the various _scanFoo methods that are appropriate for them.

Source/BackEndClr/ClrBackEnd.cobra

@@ -36 +36 @@
             'IDictionary':      'System.Collections.IDictionary',
             'IDictionary<of,>': 'System.Collections.Generic.IDictionary<of,>',
             'Dictionary<of,>' : 'System.Collections.Generic.Dictionary<of,>',
+            'KeyValuePair<of,>':'System.Collections.Generic.KeyValuePair<of,>',
             'Set<of>':          'Cobra.Core.Set<of>',
 
             'bool'  :  'System.Boolean',
@@ -86 +87 @@
             m = SharpModule(filename, verbosity)
         return m
     
+    get baseExeName as String is override
+        """Resulting executable file name for compiled file(s) sans extension."""
+        return .compiler.clrBaseExeFileName
+    
+    get fullExeName as String is override
+        """Resulting full executable file name (pathname+extn) for compiled file(s)."""
+        return .compiler.clrFullExeFileName
+            
     def setupRunProcess(baseExe as String, fullExe as String) as Process is override
         p = Process()
         branch .compiler.platform
@@ -114 +123 @@
     
     def fixLibExtension(libRef as String) as String is override
         """
-        Augment given lib reference string with backend extension if not already have one
+        Augment the given library filename reference with backend extension if not already have one.
         """
         or require libRef.length
         and ensure result.endsWith('.dll') or result.endsWith('.exe')
@@ -143 +152 @@
                 .compiler.clrReadAssembly(a)
         else
             # TODO: support targeting a specific CLR version, but not below 2.0
-            #.compiler.readAssembly(Assembly.load('mscorlib.dll') to !)
             .compiler.clrReadAssembly(Assembly.load('mscorlib.dll') to !)
 
             # TODO: .readAssembly(Assembly.loadFrom('System.dll') to !)
             #       gives: Unhandled Exception: System.IO.FileNotFoundException: Could not load file or assembly 'System.dll' or one of its dependencies. The system cannot find the file specified.
 
             t = System.Diagnostics.Process.getType
-            #.compiler.readAssembly(t.assembly) # System.dll
             .compiler.clrReadAssembly(t.assembly) # System.dll
         
     def fixMemberSigs is override
@@ -179 +186 @@
         qualifiedName = .resolveTypeTag(qualifiedNameOrTag)
         return ClrNativeType(.compiler.clrTypeByName(qualifiedName))
         /#
-        These are the type tags used directly by the compiler code.
+        These are the type tags used directly by cobra code.
             
             bool        'System.Boolean'
             char        'System.Char'
@@ -222 +229 @@
         """Clr doesnt allow colliding names."""
         throw Exception('In [ns.name] there is a already non-namespace declaration named "[name]".')
         
-        
-        
+    def getEnumeratorMember(box as Box) as IMember? is override
+        """ Find enumerator method member in given Box."""
+        return box.getEnumeratorMemberClr
+    
+    def getEnumeratorMemberType(box as Box, enumResultType as IType) as IType? is override
+        """Return type from lookup of enumerator 'current' field from in given Box."""
+        return box.getEnumeratorMemberTypeClr(enumResultType)
+    
+    def validatePrintDestType(t as IType, n as Stmt) is override
+        """
+        Check that the given Type is a valid destination for a print statement redirection.
+        If not record an error message
+        """
+        if  not  t.isDescendantOf(.compiler.libraryType('System.IO.TextWriter'))
+            # actually only needs a write/writeLine call
+            n.recordError('Invalid destination of type "[t.name]" for "print". Use a TextWriter or subclass thereof instead.')
+            
 class GenerateSharpCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/files-to-compile.text

@@ -5 +5 @@
 
 CommandLine
 TestifyRunner
+BackEnd
 Compiler
 
 KeywordSpecs

Source/BackEndJvm/JvmJarSig.cobra

@@ -36 +36 @@
             """
             Remap unique virtualised java class name to an actual existing Java class name.
             """
-
+            
+        def reset
+            """Clear all static caches"""
+            JarSig.classByNameCache.clear
+                
         def lookupClassByCobraName(fullCobraName as String) as JavaClassType
             """
             This is intended to be the only way to access the JarSig classCache contents from outside this file.
             """
             assert fullCobraName[0].isUpper
             #fullCobraName = .virtualNameRemaps.get(fullCobraName, fullCobraName)
-            parts = fullCobraName.split('.')
-            for i in 0: parts.length-1
-                parts[i] = parts[i][0].toLower.toString + parts[i][1:]
-            fullName = parts.join('.')
+            fullName = _convertCobraName(fullCobraName)
             #print 'Lookup "[fullCobraName]" as "[fullName]"'
             if not JarSig.classByNameCache.containsKey(fullName) # dbg
                 print 'Class [fullName] not in JarSig ClassName cache'
+                #for k in JarSig.classByNameCache.keys, print k
                 throw Exception('Cannot find class [fullName]')
             return JarSig.classByNameCache[fullName]
+
+        def _convertCobraName(fullCobraName as String) as String
+            #if fullCobraName.contains('<') # genericInstDef  Aaa.Bbb.C<Jjj.Uuu.C>
+            #   genParts = fullCobraName.split('<')
+            #   for i in 0 : genParts.length
+            #       genParts[i] = _xvertName(genParts[i])
+            #   fullName = genParts.join('<') 
+            #else   
+            #   fullName = _xvertName(fullCobraName)
+            #return fullName
+            #
+        #def _xvertName(fullCobraName as String) as String
+            #"""Turn names of form Aaa.Bbb.Class to aaa.bbb.Class. Cobra form to java."""
+            parts = fullCobraName.split('.')
+            for i in 0: parts.length-1
+                parts[i] = parts[i][0].toLower.toString + parts[i][1:]
+            fullName = parts.join('.')
+            return fullName 
                 
         def lookupClass(fullName as String) as JavaClassType
             """ 
@@ -636 +656 @@
             idxrProp =  _genAProp('[.canonicalName]_synthesizedIdxr', getMethod, setMethod, true)
             _props.add(idxrProp)
             _indexer = idxrProp
-            sb = StringBuilder('= ')
-            if getMethod
-                sb.append(getterName)
-                if setMethod, sb.append(',')
-            if setMethod
-                sb.append(setterName)
-            print 'dbg: [.canonicalName] indexerMethods [sb.toString] '
+            #sb = StringBuilder('= ')
+            #if getMethod
+            #   sb.append(getterName)
+            #   if setMethod, sb.append(',')
+            #if setMethod
+            #   sb.append(setterName)
+            #print 'dbg: [.canonicalName] [.getHashCode] indexerMethods [sb.toString] '
         #else
         #   print 'dbg: No IndexerMethods [getterName]/[setterName] on [.canonicalName]'
-                
+        #/
+    
     def _lookForMethods( getterName as String, setterName as String) as List<of JavaMethodInfo?>
         getter as JavaMethodInfo? = nil
         setter as JavaMethodInfo? = nil
@@ -653 +674 @@
             if m.name == getterName, getter = m
             if m.name == setterName, setter = m
         return [getter, setter] 
-                
+    
+    def lookupIndexer as JavaFieldInfo?
+        """
+        Search this class and superclass chain for an indexer. Return first hit or nil.
+        Used to map indexing '[]' cobra code to java method calls.
+        """
+        #depth=0
+        #print depth, .getHashCode, .canonicalName, .superclass
+        idxr = .indexer
+        if idxr
+            return idxr
+        super = .getSuperClass      # otherwise try superclass chain
+        while super
+            idxr = super.indexer
+            if idxr 
+                break
+            super = super.getSuperClass
+        return idxr
         
     cue init(name as String, pkg as String, type as JavaType, super as String, ifcs as List<of String>, modifiers as List<of String> )
         """Create a normal Class or GenericClass Defn.   MyClass or MyClass<T>"""
@@ -880 +918 @@
         #return  JvmNativeType(_type.getSuperClass)
         if JarSig.classByNameCache.containsKey(.superclass)
             return JarSig.lookupClass(.superclass)
+        else if .superclass.contains('`') # isGeneric
+            key = .superclass.before('`')       
+            return JarSig.lookupClass(key)
         else 
             return JarSig.lookupClass('java.lang.Object')
             # e.g. Abstract base classes with default access - java.lang.AbstractStringBuilder  
@@ -1029 +1070 @@
         assert false, 'dump Indexers NYI'
     
 class JavaMemberInfo
+    """Baseclass for java fields and properties, constructors and methods"""
     var name = ''   
     var _attributes as List<of String>?
     var modifiers = List<of String>() # public, default (=protected+pkg), protected, private
@@ -1061 +1103 @@
         return .attributes.contains('Override')
 
     get isNonNullable
+        if .isFinal
+            return true # arbitrarily declare final members non nilable till get attributes working.
         return .attributes.contains('NotNull') or .attributes.contains('NonNull') or .attributes.contains('Nonnull')
         #for name in .attributes # in java these are annotations, - via pkgSig treated as strings
         #   if name.endsWith == 'NotNull' or name.endsWith == 'NonNull'  or name.endsWith == 'Nonnull' 
@@ -1114 +1158 @@
             else if .isReadable, prefix = 'get'
             else if .isWritable, prefix = 'set'
 
-        sb = StringBuilder('[prefix] [.name]')
+        sb = StringBuilder('[prefix].[.name]')
         if .typeName.length, sb.append(' as [.type]')
         if .modifiers.count 
             sb.append(' is ')

Source/BackEndJvm/ScanJvmType.cobra

@@ -44 +44 @@
             if not sigFilePath
                 # eventually may also search CLASSPATH              
                 if rv, print 'Returning false for __jvmLoadReference("[reference]").'
-                return 'to-do: what to put here? sigFilePath not found?' 
+                return 'to-do: what to put here? sigFilePath "[sigFilePath]" not found?' 
 
             if rv, print 'Will read jarsig: [sigFilePath]'
             try
@@ -98 +98 @@
 
     def javaReadJar(jSig as JarSig)
         """
-        Reads the contents of a jar (actually JarSig) file so that they are accessible to the program.
+        Reads the contents of a jar (actually JarSig) file and make the symbols accessible 
+        to the compiler for the program being compiled.
         """
         if jSig.name in _didReadJars, return
         _didReadJars.add(jSig.name)
@@ -113 +114 @@
         try
             _modules.add(module)
             for jvmType in jSig.getExportedTypes
-                if jvmType.isNested #or jvmType.declaringType
+                if jvmType.isNested # or jvmType.declaringType
                     nestedTypes.add(jvmType)
                     continue
                 typeNamespace = jvmType.packageAsCobra  #Capitalized
@@ -183 +184 @@
         
         _fix('Java.Lang.Object', 'toString getClass clone')
             # ^ regarding .toString, not technically true, but common enough and life is too painful when the return type is nilable
-        #_fix('java.lang.System', 'out') #stdout
+        _fix('Java.Lang.System', 'in out err lineSeparator')
         _fix('Java.Lang.String', r'[] length charAt concat remove replace replaceAll replaceFirst substring toLowerCase toUpperCase trim format')
         #_fix('System.Type', 'assembly name toString')
             # namespace can return nil if the Type is a generic parameter
@@ -225 +226 @@
         #_fix('Java.Util.AbstractMap.SimpleEntry<of,>', r'getKey getValue')
         #_fix('Java.Util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue')
         _fix('Java.Util.Properties', r'getProperty')
+        _fix('Java.Util.Calendar', 'getInstance getTimeZone')
         
         #_fix('System.IO.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText')
         _fix('Java.Io.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText getPath getAbsolutePath')
@@ -292 +294 @@
     
     def installJvmNativeMethods(box as Box, nativeType as NativeType) 
         """Install entries for native static methods on box instances."""
-        pass
+        pass  #TODO support native static methods on box instances
         #print '++ TODO scanJvmType.installJvmNativeMethods'
 /#
         meths = List<of Method>()
@@ -352 +354 @@
         #overload.addMember(meth)
         .addDecl(meth)
                 
+        
+    def getIteratorMemberJvm as IMember?
+        """
+        Step1 of 2 step lookup for iterator/enumerator type - return iterator Member for current box 
+        """
+        getEnum as IMember? 
+        if .declForName('iterator') is not nil # Collections
+            getEnum = .symbolForName('iterator', true)
+            return getEnum
+            
+        if .declForName('entrySet') is not nil # Map
+            es = .symbolForName('entrySet', true)
+            est = es.resultType.nonNil to Box
+            getEnum = est.symbolForName('iterator', true)
+        # could look for  Enumerable here also
+        
+        return getEnum
+        
+    def getIteratorNextTypeJvm(rt as IType) as IType?
+        """
+        Step2 of 2 step lookup for iterator/Enumerator type - return the type for iterator.next member for current box 
+        rt is the resultType from iterator lookup above - i.e the Iterator for this Box
+        """
+        if rt inherits Box and (rt to Box).isGeneric
+            rType = rt.memberForName('next').resultType
+        else
+            throw FallThroughException('getEnumeratorMemberType - rt not genericBox [rt]')
+        return rType
+        
     def scanNativeTypeJvm
         """
         Subclasses should invoke base and then invoke the various _scanXXX methods that are appropriate for them.
@@ -550 +581 @@
                         break
             if skip, continue
             name = Utils.cobraNameForNativeMemberName(methInfo.name)
+            other = .declForName(name)
             genericParams = List<of IType>()
             for genArg in methInfo.getGenericArguments
                 genericParams.add(GenericParam(JvmNativeType(genArg)))
@@ -570 +602 @@
                     overload = MemberOverload(other)
                     .registerOverload(overload to !)
                 else
-                    print 'Unexpected overload for name:', name, other
-                    throw FallThroughException([this, method, other])
+                    if not other inherits BoxVar
+                        print 'Unexpected overload (existing named decl) for method "[name]":', other
+                        throw FallThroughException([this, method, other])
+                        
+                    # here we have a field name (BoxVar) shadowing a method name. 
+                    # In java this is unambiguous cos all methods are called with () suffix. 
+                    # In cobra we have to do something else...
+                    # currently will choose to drop ( make inaccessible) the field... 
+                    # ...stupid field begone
+                    print 'DUP field "[name]" is shadowing the method "[name]" on [.name],'
+                    print '    Dropping the field. It will not be accessible from cobra code'
+                    .rmDecl(other)
+                
             if overload
                 overload.addMember(method)
             else
@@ -653 +696 @@
     def _jvmMemberTypeProxy(jvmType as JavaClassType?, notNull as bool) as ITypeProxy       
         """
         Returns a type proxy for a member type such as a parameter type.
-        In Java, reference types are nilable by default, but you can pass `true` for `notNull` to indicate there was a NotNull Annotation in the jar metadata.
+        In Java, reference types are nilable by default, but you can pass `true` for `notNull` to 
+        indicate there was a NotNull Annotation in the jar metadata.
         """
         if jvmType is nil
             return .compiler.voidType
@@ -695 +739 @@
     def _fixNestedNilables
         if .parentBox  # nested
             query = '[.parentBox.qualifiedName].[.name]'
-            print 'fixNest', query
+            #print 'fixNest', query
             memberNames = _nestedUnNil.get(query, '')
             if memberNames.length
                 .parentBox.membersToUnNil = memberNames
@@ -789 +833 @@
     def scanNativeTypeJvm
         # TODO: read attribs
         _needScanNativeType = false
-        _storageType = .compiler.anyIntType # tmp ??
+        _storageType = .compiler.anyIntType # Not relevant ??
+    
+        #TODO fake up support for values() and valueOf() and getValue() synthesized in codegen
+        # - or not - how much of C#/Cobra enum capability to support??
         
         /# Enable when have Enum and JavaEnumType in PkgSig and JarSig
         jvmType = (_nativeType to JvmNativeType).backEndType 
         assert jvmType inherits JavaEnumType # temporary
         for name, value in jvmType.getConstantValues    # list of names and values
-            intValue = value to int
-            member = EnumMember(name, intValue)
+            member = EnumMember(name, value)
             member.enumDecl = this
             .addDecl(member)
         #/
             
-        /#
-        isByte  = Enum.getUnderlyingType(jvmType).name == 'Byte'
-        is64    = Enum.getUnderlyingType(jvmType).name == 'Int64'
-        isU32   = Enum.getUnderlyingType(jvmType).name == 'UInt32'
-        isU64   = Enum.getUnderlyingType(jvmType).name == 'UInt64'
-        values  = Enum.getValues(jvmType)
-        i = 0
-        for name in Enum.getNames(jvmType)
-            value = values.getValue(i)
-            # CC: lameness follows
-            if isByte
-                intValue = int.parse((value to uint8).toString)
-            else if is64
-                try
-                    intValue = int.parse((value to int64).toString)
-                catch OverflowException
-                    intValue = 999  # CC: omg. but probably doesn't affect anything. we're reading the DLL here, not creating one
-            else if isU32
-                try
-                    intValue = int.parse((value to uint32).toString)
-                catch OverflowException
-                    intValue = 2147483647
-            else if isU64
-                try
-                    intValue = int.parse((value to uint64).toString)
-                catch OverflowException
-                    intValue = 2147483647
-            else
-                intValue = value to int
-            member = EnumMember(name, intValue)
-            member.enumDecl = this
-            .addDecl(member)
-            i += 1
 #/      
 
 

Source/BackEndJvm/JvmBackEnd.cobra

@@ -17 +17 @@
             'Object': 'Java.Lang.Object',
             'Type'  : 'Java.Lang.Class<of>',    # java.lang.Type is a marker interface
             'String'    :       'Java.Lang.String',
-            'Exception' :       'Java.Lang.RuntimeException',
+            #'Exception' :      'Java.Lang.RuntimeException',
+            'Exception' :       'Java.Lang.Exception',
 
-            'Delegate'  :       'Cobra.Core.Delegate',
+            'Delegate'  :       'Cobra.Core.DelegateO',
+            #'Delegate<of>' :   'Cobra.Core.Delegate<of>',
             'Attribute' :       'Java.Lang.Annotation.Annotation',
             'ICloneable':       'Java.Lang.Cloneable', 
             'IEnumerable':      'Java.Lang.Iterable',
             'IEnumerator':      'Java.Lang.Iterator',
             'IEnumerable<of>' : 'Java.Lang.Iterable<of>',
             'IEnumerator<of>' : 'Java.Lang.Iterator<of>',
-            'IDictionaryEnumerator' : 'Java.Lang.Iterator',
-            #'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator',
-            'ICollection':      'Java.Util.Collection', # non generic collection interface
+            'IDictionaryEnumerator' : 'Java.Lang.Iterator', # non generic Dictionary enumer interface - Non existant
+            'ICollection':      'Java.Util.Collection',     # non generic collection interface Non existant in java
             'ICollection<of>':  'Java.Util.Collection<of>',
             'IList' :           'Java.Util.List<of Object>',    # non generic List interface
             'IList<of>' :       'Java.Util.List<of>',
             'List<of>':         'Java.Util.ArrayList<of>',
-            'IDictionary':      'Java.Util.Map<of Object,Object>', # Non Generic Map/Dict interface
+            #'IDictionary':     'Java.Util.Map<of Object,Object>', # Non Generic Map/Dict interface
+            'IDictionary':      'Java.Util.Map<of,>', # Non Generic Map/Dict interface 
             'IDictionary<of,>': 'Java.Util.Map<of,>',
             'Dictionary<of,>' : 'Java.Util.HashMap<of,>',
+            'KeyValuePair<of,>':'Java.Util.Map<of,>.Entry<of,>',
             'Set<of>':          'Java.Lang.HashSet<of>',
 
             'bool'  :  'Java.Lang.Boolean',  # boolean
@@ -100 +103 @@
             m = JavaModule(filename, verbosity)
         return m
         
+    get baseExeName as String is override
+        """Resulting Executable file name for compiled file(s) sans extension."""
+        return .compiler.javaMainClass
+    
+    get fullExeName as String is override
+        """Resulting executable file name (pathname+extn) for compiled file(s)."""
+        return .compiler.fullJarFileName
+            
     def setupRunProcess(baseExe as String, fullExe as String) as Process is override
+        """
+        Setup compiled java process to run assuming using an executable jar file.
+        All info needed should be already set in jarfile manifest - i.e main entry point 
+        and any classpath dependencies
+        """
         p = Process()
         p.startInfo.fileName = 'java'
+        # below is same as 
+        #args = ' -jar [.compiler.fullJarFileName]'
+        args = ' -jar [fullExe]'
+    
+        p.startInfo.arguments = args + ' '
+        #print p.startInfo.fileName, p.startInfo.arguments
+        return p        
+    
+    def setupRunProcessClass(baseExe as String, fullExe as String) as Process #is override
+        """
+        Setup running a java class file(s), using CobraCore.jar and assuming jarfiles
+        needed set in CLASSPATH env var ('.')
+        Superseded by setupRunProcess above.    
+        """
+        p = Process()
+        p.startInfo.fileName = 'java'
         clPath = Path.getDirectoryName(CobraCore.exePath) to !
         clPath = Path.combine(clPath, 'CobraCore.jar')
         classpath = Environment.getEnvironmentVariable('CLASSPATH')
@@ -115 +147 @@
         p.startInfo.arguments = args + ' '
         #print p.startInfo.fileName, p.startInfo.arguments
         return p        
-    
+
     def setDefaultUseDirectives(ns as NameSpace) is override
         # java packages available by default
         useToken = Token('(implicit)', 1, 1, 1, 'USE', 'use', nil)
@@ -153 +185 @@
     
     def readSystemTypes is override
         # Initially we will rely on a external java tool to have been run to produce a precis
-        # file in a known place (same as cobra compiler perhaps) containing exported types for
+        # file in a known place (same as cobra compiler) containing exported types for
         # items in a jar file.
         
         # JarSig is a holder for a jarfile or package extended with info on contained classes.
         # javaReadJar loads info on contained classes into Cobra
         # rt.jar is only one we need
+        JarSig.reset
         .compiler.javaReadJar(JarSig('rt.jar'))
     
     def fixMemberSigs is override
@@ -178 +211 @@
 
     # Types
     get objectTypeProxy as AbstractTypeProxy  is override
-        """Type proxy for BE root of Object hierarchy."""
+        """Type proxy for backEnd root of Object hierarchy."""
         if  not _objectTypeProxy
             _objectTypeProxy = JvmTypeProxy(JarSig.lookupClassByCobraName('Java.Lang.Object'))
         return _objectTypeProxy to !
             
     get typeTypeProxy  as AbstractTypeProxy  is override
-        """Type proxy for BE notion of a class describing a Type."""
+        """Type proxy for BackEnd notion of a class describing a Type."""
         if  not _typeTypeProxy
             _typeTypeProxy = JvmTypeProxy(JarSig.lookupClassByCobraName('Java.Lang.Class'))
         return _typeTypeProxy to !  
@@ -196 +229 @@
         return JvmNativeType(type)
     
     def nativeTypeByName(qualifiedNameOrTag as String) as NativeType is override
-        #map qualified name of .net aliased types  to java equivalents
+        # map the qualified name of .net aliased types  to java equivalents
         # bool, char, decimal, single, double, sbyte, int{16,32,64}, byte, uint{16,32,64}, 
         qualifiedName = .resolveTypeTag(qualifiedNameOrTag)
         return JvmNativeType(.compiler.jvmTypeByName(qualifiedName))
@@ -235 +268 @@
         #print 'Any use of the namespace in cobra code must be changed accordingly.'
 
         #print 'Cobra name collision in namespace "[ns.name]" for child namespace "[name]" and an existing declaration. Use name "[name]NS" for java namespace/package "[name]" .'
-        print 'In namespace "[ns.name]" java namespace "[name]" renamed in cobra to "[name]NS". (cobra name collision)'
+        print 'Java "[ns.name].[name]" renamed in cobra to "[ns.name].[name]NS". (cobra name collision)'
         name = name+'NS'
         return ns.getOrMakeNameSpaceNamed(token, name) # recursive
         
@@ -254 +287 @@
         
     def setUnderlyingType(edcl as EnumDecl)  is override
         edcl.setUnderlyingTypeJvm
+    
+    def getEnumeratorMember(box as Box) as IMember? is override
+        """ Find iterator method member in given Box."""
+        return box.getIteratorMemberJvm
         
+    def getEnumeratorMemberType(box as Box, rt as IType) as IType? is override
+        """Return type from lookup of iterator 'next' field in given Box."""
+        return box.getIteratorNextTypeJvm(rt)
+
+    def validatePrintDestType(t as IType, n as Stmt) is override
+        """
+        Check that the given Type is a valid destination for a print statement redirection.
+        If not record an error message
+        """
+        t = t.nonNil
+        if  t.isDescendantOf(.compiler.libraryType('Java.Io.Writer'))
+            return  # commonly PrintWriter or StringWriter
+        if  t.isDescendantOf(.compiler.libraryType('Java.Io.PrintStream'))
+            return  # for System.out
+        n.recordError('Invalid destination of type "[t.name]" for "print". Use a Java.Io.Writer or subclass thereof (PrintWriter, StringWriter) instead.')
+            
+                
 class GenerateJavaCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/BackEndJvm/JavaGenerator.cobra

@@ -11 +11 @@
 ##
 
 class Compiler is partial
+    var _javaMainClass as String = ''
+    var _fullJarFileName as String = ''
+    
+    get javaMainClass from var
+    get fullJarFileName from var
+    
 
     # run prior to compilation to determine an output filename for the java source
-    # for testing for need for compilation.
+    # for testing, for need for compilation.
     # Filename used may be determined later post AST generation using the first classname in file
     # see 'fixup output filename' in compileJava below
     def computeOutNameJava as String
@@ -25 +31 @@
         if outName == '', outName = .defaultOutName to !
         if outName.endsWith('.java') or outName.endsWith('.JAVA'), outName = outName[:-5]
         if outName.endsWith('.cobra') or outName.endsWith('.COBRA'), outName = outName[:-6]
-        _baseExeFileName = outName
+        _javaMainClass = outName
 
-        outName = Utils.forceExtension(outName, '.class')
-        _fullExeFileName = outName
+        #outName = Utils.forceExtension(outName, '.class') #v1
+        outName = Utils.forceExtension(outName, '.jar')     
+        _fullJarFileName = outName
         return outName
         
     def writeJava
         Node.setCompiler(this)
         try
-            #pass
             _moduleFileName_to_curlyToCobraLineNum = Dictionary<of String, Dictionary<of int, int>>()
             for _curModule in _modules
                 if not _curModule.fileName.endsWith('SystemInterfaces.cobra')
                     javaToCobraLineNum = _curModule.writeJavaDef
-                    _moduleFileName_to_curlyToCobraLineNum[_curModule.fileName] = javaToCobraLineNum
-                    _moduleFileName_to_curlyToCobraLineNum[Path.getFullPath(_curModule.fileName)] = javaToCobraLineNum
+                    .storeJavaFileInfo(_curModule.fileName, javaToCobraLineNum)
         finally
             Node.setCompiler(nil)
-
+            
+    def storeJavaFileInfo(fileName as String, javaToCobraLineNum as Dictionary<of int, int>?)
+        # called above and fm Namespace.writeJavaDef after new class file
+        _moduleFileName_to_curlyToCobraLineNum[fileName] = javaToCobraLineNum
+        _moduleFileName_to_curlyToCobraLineNum[Path.getFullPath(fileName)] = javaToCobraLineNum
+            
     def writeJavaTestInvocation
         # TODO
         print 'TODO: writeJavaTestInvocation'
@@ -59 +69 @@
             options = .options
 
             # locate the Java compiler
-            # TODO: This just does files compilation, augment to also generate manifest and executable jarfile
             # TODO: augment to use Java library compiler when Java native
             compilerPath = options.getDefault('native-compiler', 'auto') to String
             if compilerPath <> 'auto'
@@ -71 +80 @@
                     print 'Cannot find compiler specified by -native-compiler argument: [compilerPath]'
                     throw StopCompilation(this)
             else
-                # TODO use a javatool - wrap javac and jarfile gen for multiple files       
-                # javaTool -m MainClass -o outFile file-list
                 compilerPath = if(Utils.isRunningOnUnix, 'javac', 'javac.exe')
                 
             optChar = '-'
@@ -110 +117 @@
                     nativeArgs = nativeArgs[1:-1]
                 backEndOptions += ' ' + nativeArgs
 
-            #sep = if(CobraCore.isRunningOnUnix, ':', ';') # after next snapshot
-            cpSep = ';'
-            if (Environment.osVersion.platform to int) in [4, 6, 128]  # http://www.mono-project.com/FAQ:_Technical
-                cpSep = ':'
+            cpSep = if(CobraCore.isRunningOnUnix, ':', ';')
 
             libclassPath = ''
             for libPath in .options.getStringList('library-directory')
@@ -123 +127 @@
             # explicitly add reference to it until we get setup to install a copy in extdirs
             ccPath = Path.getDirectoryName(CobraCore.exePath) to !
             ccPath = Path.combine(ccPath, 'CobraCore.jar')
-            backEndOptions += ' -classpath "[ccPath][libclassPath]"'
+            classPath = '[ccPath][libclassPath]'
+            backEndOptions += ' -classpath "[classPath]"'
                 
-            # TODO: add libPaths/classpaths for referenced namespaces
+            # TODO: add libPaths/classpaths for any referenced namespaces
             
             # .java files fm first class name in each module
-            javaFileNameList = List<of String>()
+            javaFileNameSet = Set<of String>()
             for module in _modules[1:]
                 if module.javaFileName.length
-                    javaFileNameList.add(module.javaFileName)
-
+                    javaFileNameSet.add(module.javaFileName)
+            #javaFileNameList = _intermediateFileNames      
+            for name in _intermediateFileNames      
+                if name.length, javaFileNameSet.add(name)
+            javaFileNameList = List<of String>(javaFileNameSet)
+                    
+            #trace javaFileNameList, _intermediateFileNames     
             # fixup javaMain pkg path all lower case
             # fixup output filename (classfile) to be in sync with Java filename
             javaMain = _getFixedMainType
             if outName <> javaFileNameList[0]
                 outName = javaFileNameList[0]
-                #_baseExeFileName = Path.changeExtension(outName, nil) to ! # remove any extn
-                _baseExeFileName = javaMain
+                _javaMainClass = javaMain
                 outName = Utils.forceExtension(outName, '.class')
-                _fullExeFileName = outName
+
+            if .defaultOutName
+                _fullJarFileName = Utils.forceExtension(.defaultOutName to !, '.jar')
                         
             # compilation command
             if _verbosity
@@ -150 +161 @@
                 print 'compiler =', compilerPath
                 print '    compilerOptions =', backEndOptions
                 print '    nativeArgs =', nativeArgs
-                print '    outName =', .fullExeFileName
+                print '    fullExeFileName=',  _fullJarFileName
                 print '    baseExeFileName =', .baseExeFileName
                 print '    javaFileNameList =', javaFileNameList
-
-            output = _execAndCapture(compilerPath, backEndOptions, javaFileNameList)
-            _parseJavaCompilerOutput(output)
-
+                print '    defaultOutName =', .defaultOutName
+                
+            #output = _execAndCapture(compilerPath, backEndOptions, javaFileNameList)
+            #_parseJavaCompilerOutput(output)
+            _javaTool(compilerPath, backEndOptions, classPath, javaFileNameList)
+                
             if .errors.count
                 _exitFromErrors
 
             _deleteIntermediateFiles
+            _copyCoreJvm(outName)
+
+    def _copyCoreJvm(outName as String)
+        if not .options.boolValue('copy-core'), return
+        sourceDir = Path.getDirectoryName(Assembly.getEntryAssembly.location) ? ''
+            # above should be something non platform dependent (COBRA_HOME ?) 
+        outDir = Path.getDirectoryName(outName) ? ''
+        _copyFile(sourceDir, outDir, 'Cobra.Core.jar')
+        #if .options.getDefault('debug', '') not in ['', '-', '0', 0, false]
+        # copy any debug files
+        # TODO: probably also need to adjust Manifest File Class-Path for cobra RTL
             
-    # Better would be options as optionList as List<of String> but ftm we're stuck with space joined strings
-    # coming into caller
+    def _javaTool(javacPath as String, options as String, classPath as String, fileNameList as List<of String>)
+        """
+        javatool - wrap executing javac and executable jarfile generation for single or 
+            multiple files      
+        """
+        # clean directory for java compiled cobraClasses
+        classDir = 'cobraClasses'
+        if Directory.exists(classDir)
+            Directory.delete(classDir, true)
+        Directory.createDirectory(classDir)
+            
+        # put compiled classes in own subdir
+        options = options.replace('-d .', '-d [classDir]')
+
+        # run java compiler on java srcfiles
+        output = _execAndCapture(javacPath, options, fileNameList)
+        _parseJavaCompilerOutput(output)
+        if _errors.count, return
+        
+        # Make manifest file - entry for Class-Path: <classPath>
+        cpSep = if(CobraCore.isRunningOnUnix, ':', ';')
+        manFileName = 'in.mf'   
+        mfClassPath = classPath.replace(cpSep, ' ') # classpath entries space separated
+        mfClassPath = mfClassPath.replace('C:',' ') # cant handle drive designators
+        mfText = 'Class-Path: [mfClassPath] [Environment.newLine]'
+        try
+            File.writeAllLines(manFileName, [mfText].toArray)
+        catch exc as Exception
+            .warning(CobraWarning(manFileName, nil, 'Cannot write manifest file due to: [exc.message] ([exc.getType.name]).'))
+        
+        # make jarfile
+        _intermediateFileNames.add(manFileName)
+        #outName = Utils.forceExtension(.defaultOutName to !, '.jar')
+        outName = _fullJarFileName
+        mainClass = _javaMainClass
+        #print  'jar cfem [outName] [.baseExeFileName] [manFileName] -C [classDir] .'
+        output = _execAndCapture('jar', 'cfem [outName] [mainClass] [manFileName] -C [classDir]', ['.'])
+        #print output # TODO parse this for errs
+        
+    # Better would be options as optionList as List<of String> but ftm we're stuck with space 
+    # joined strings coming into caller
     # TODO: move this to CobraCore to avoid .NET dependency
     def _execAndCapture(binaryPath as String, options as String, fileNameList as List<of String>) as String
         p = System.Diagnostics.Process()
@@ -173 +236 @@
         p.startInfo.arguments = '[options] [fileNames]'
         if _verbosity >= 2
             print '[p.startInfo.fileName] [p.startInfo.arguments]'
-        output = p.runAndCaptureAllOutput
+        try
+            output = p.runAndCaptureAllOutput
+        catch exc as System.ComponentModel.Win32Exception
+            print 'Error: Compiler file [p.startInfo.fileName] not found in path'
+            throw exc
         # TODO: check p.exitCode, especially if output is empty
         return output       
             
@@ -204 +271 @@
             javaMain = '[javaPkg].[exeParts.last]'  
         #trace .mainMethodTypeName, javaMain
         return javaMain 
+    
+    #hoisted from CobraModule
+    def newJavaFile( cobraModuleName as String, javaFileName as String) as CurlyWriter
+        #print 'newJavaFile [javaFileName]'
+        file = File.createText(javaFileName)
+        sw = CurlyWriter(file, CurlyLineNumberTreatment.Comment)
+        .addIntermediateFile(javaFileName)
+        sw.start(cobraModuleName)
+        sw.write('// [javaFileName] from [cobraModuleName]\n')
+        sw.write('// Generated by Cobra-[CommandLine.versionString]\n')
+        sw.write('// on [DateTime.now]\n')
+        # TODO: list op sys
+        sw.write('\n')
+        return sw
+    
+        
 ##
 ## Node
 ##
@@ -328 +411 @@
         return classFileName
                         
     def writeJavaDef as Dictionary<of int, int>? is override
-        file = File.createText(.javaFileName)
-        using sw = CurlyWriter(file, CurlyLineNumberTreatment.Comment)
-            .compiler.addIntermediateFile(_javaFileName)
-            sw.start(.fileName)
-            sw.write('// [_javaFileName] from [_fileName]\n')
-            sw.write('// Generated by Cobra-[CommandLine.versionString]\n')
-            sw.write('// on [DateTime.now]\n')
-            # TODO: list op sys
-            sw.write('\n')
-
+        using sw = (.compiler to Compiler).newJavaFile(.fileName, .javaFileName)
             if .isMainWrapper   
                 .synthesizeJavaMainWrapper(sw)
             else
                 .topNameSpace.writeJavaDef(sw)
             d = sw.curlyToCobraLineNum
         return d
-
+        
     def writeJavaTestInvocation(sw as CurlyWriter) is override
         # TODO: .topNameSpace.writeJavaTestInvocation(sw)
         pass
@@ -422 +496 @@
         return .javaRef
 
     get _computeJavaRef as String
-        if .parent
-            s = .parent.javaRef
+        if .parent 
+            if .parent.javaRef <> 'global' # no global (default) namespace in java
+                s = .parent.javaRef # ?'global'?
+                s += '.'
             s += .javaName
         else
             s = .javaName
@@ -480 +556 @@
 
     def writeJavaDef(sw as CurlyWriter)
         """
-        Write the Java code for this member declaration to the given CurlyWriter.
+        Write the Java code for this member definition/declaration to the given CurlyWriter.
         """
 
     def writeJavaTestInvocation(sw as CurlyWriter)
@@ -523 +599 @@
     def writeJavaDef(sw as CurlyWriter) is override
         assert not .isUnified
         base.writeJavaDef(sw)
+        _writeNameSpaceHeading(sw)
+        
+        # Top Level classes + Interfaces in a Namespace
+        d0 = _declsInOrder[0]
+        firstclass = true
+        for decl in _declsInOrder
+            isNames = List<of String>()
+            if decl inherits Box 
+                .compiler.boxStack.push(decl)
+                isNames.add(decl.defaultAccessLevel)
+            isNames.addRange(decl.isNames)
+            if firstclass or decl == d0 or not 'public' in isNames
+                decl.writeJavaDef(sw)
+                firstclass = if(decl inherits EnumDecl, true, false)
+            else 
+                # java - compile error if public classes are not in their own file - a pox on whoever made this unsuppressable
+                javaFileName = decl.name + '.java'
+                # make it look like this class was made in its own cobra module 
+                # TODO insert Module name in new Java file header
+                cobraModName = decl.name + '.cobra' 
+                #trace javaFileName, cobraModName
+
+                compiler =(.compiler to Compiler)
+                using sw = compiler.newJavaFile(cobraModName, javaFileName)
+                    _writeNameSpaceHeading(sw)
+                    decl.writeJavaDef(sw)
+                    javaToCobraLineNum = sw.curlyToCobraLineNum
+                    compiler.storeJavaFileInfo(cobraModName, javaToCobraLineNum)
+            
+            if decl inherits Box, .compiler.boxStack.pop
+
+    def _writeNameSpaceHeading(sw as CurlyWriter)
         if not .isRoot
-            javaName = .name.toLower # java idiom is all lowercase for packages
-            sw.write('package [javaName][.javaSuffix]; \n\n')
+            pkgName = .name.toLower # java idiom is all lowercase for packages
+            sw.write('package [pkgName][.javaSuffix]; \n\n')
         for ud in _useDirectives  # imports
             ud.writeJavaDef(sw)
-        for decl in _declsInOrder
-            if decl inherits Box
-                .compiler.boxStack.push(decl)
-            decl.writeJavaDef(sw)
-            if decl inherits Box
-                .compiler.boxStack.pop
-        # TODO
-        #if not .isRoot
-        #   sw.dedentAndWrite('} // namespace [.name]\n')
-
+        
     def writeJavaTestInvocation(sw as CurlyWriter) is override
         for decl in _declsInOrder
             decl.writeJavaTestInvocation(sw)
@@ -590 +689 @@
     get javaNameComponent as String
         """
         Returns a string that refers to this type and is suitable for embedding in a larger
-        identifier (meaning there will be no punction, spaces or Java comments).
+        identifier (meaning there will be no punctuation, spaces or Java comments).
         """
 
     get javaRef as String
@@ -778 +877 @@
 ## Enums
 ##
 
-# TODO
+class EnumDecl is partial
+    
+    get javaRef as String is override
+        if .isUsedAsSet, return 'java.util.EnumSet<[base.javaRef]>' 
+        return  base.javaRef
+            
+    get javaRefBase as String
+        return base.javaRef
 
+    get javaInit as String is override
+        if .isUsedAsSet, return 'java.util.EnumSet.noneOf([base.javaRef].class)' 
+        return base.javaRef + '.' + _declsInOrder[0].name
 
+    def writeJavaDef(sw as CurlyWriter) is override
+        base.writeJavaDef(sw)
+        if 'extern' in _isNames
+            return
+        for attr in .attributes
+            attr.writeJavaDef(sw)
+        if not _isNames.count, _isNames.add('internal') # to get nothing
+        .writeJavaIsNames(sw)
+        sw.write('enum [_name]')
+        /# we dont support storageType in java 
+        storageType = _storageType ...
+        #/
+        sw.write(' {\n')
+        sw.indent
+        sep = ''
+        i = 0
+        for em as EnumMember in .declsInOrder
+            sw.write(sep)
+            sw.write(em.name)
+            if em.value
+                sw.write('([em.value])')
+                complex = true
+            i += 1
+            sep = ',\n'
+        sw.write(';\n')
+        if complex # Make something like .Net enum - specific int values 
+            sw.writeLine
+            sw.writeLine('private static int defValue = 0;')
+            sw.writeLine('private static void setDef(int b){defValue = b;}')
+            sw.writeLine('private static int  getDef(){return defValue;}')
+            sw.writeLine('private int value;')
+            sw.writeLine('private [_name](int value) {this.value = value; setDef(value+1);}')
+            sw.writeLine('private [_name]() {this.value = getDef(); setDef(this.value+1);}')
+            sw.writeLine('public int getValue() {return this.value;}')
+        sw.dedent
+        sw.write('}\n\n')
+
+
+class EnumMember is partial
+
+    def writeJavaTestInvocation(sw as CurlyWriter)
+        pass
+
+    get javaRef as String is override
+        return _enumDecl.javaRefBase + '.' + .javaName
+
+
 ##
 ## Boxes
 ##
@@ -831 +987 @@
             #trace .parentNameSpace.javaQualifier
             javaRef = .parentNameSpace.javaQualifier + javaRef
         else if .parentBox
-            trace .parentBox.javaRef
+            #trace .parentBox.javaRef
             javaRef = .parentBox.javaRef + '.' + javaRef
-        #trace java
+        #trace javaRef
         return javaRef
 
     def writeJavaDef(sw as CurlyWriter)
@@ -1077 +1233 @@
 
     def writeJavaConstraint(sw as CurlyWriter)
         if _constraints.count
-            # TODO
+            # TODO map cobra constraints to Java syntax
+            # TODO before that try and comprehend java syntax for generic constraints
             sw.write(' where [_name] :  ')
             sep = ''
             for constraint in _constraints
@@ -1113 +1270 @@
 
 class Extension is partial
 
-    pass # TODO STUB
+    pass # TODO STUB: Implement extensions
 
 
 ##
@@ -1521 +1678 @@
         if .isCompilerGenerated, return
         if param.type.isReference and not param.type inherits NilableType and not param.isOut
             if .compiler.options.boolValue('include-nil-checks')
-                sw.write('if (cobra.core.CobraCore._willCheckNil && [param.javaName]==null) throw new System.ArgumentNullException("[param.name]");\n')
+                sw.write('if (cobra.core.CobraCore._willCheckNil)\n')
+                sw.indent
+                sw.write('cobra.core.CobraImp.checkNotNull([param.javaName], "ParameterGuard Fail: non nilable parameter `[param.javaName]` is null" );\n')
+                sw.dedent
+                #sw.write('if (cobra.core.CobraCore._willCheckNil && [param.javaName]==null) throw new NullPointerException("Non nilable parameter named [param.name] is Null");\n')
 
     def writeJavaDSTHead(sw as CurlyWriter)
         if not .canHaveDetailedStackTrace
@@ -1802 +1963 @@
         #.writeJavaIsNames(sw)
         sw.write(' [_returnType.javaRef] this')
         .writeJavaParams(sw, r'[]')
-        #.writeSharpBody(sw)
+        #.writeJavaBody(sw)
         # TODO: finish correctly (method with special attribute???
 
 class MemberOverload is partial
@@ -1939 +2100 @@
         sw.write(');\n')
         sw.dedent
         
-        /#
-        # use java asserts initially at least
-        sw.write(')\n')
-        sw.indent
-        sw.write('assert ')
-        _expr.writeJavaDef(sw)
-        #_expr.writeJavaBreakdown(sw)
-        #sw.write('[.javaThis]')
-        sw.write(' : ')
-        sw.write('String.format("assertion %s FAILED", ')
-        #sw.write('"assertion " + ')
-        tmpsw = CurlyWriter(StringWriter(), sw.curlyLineNumberTreatment)
-        _expr.writeJavaDef(tmpsw)
-        #sw.write(tmpsw.toString.replace('"', r'\"'))
-        sw.write(Utils.javaStringLiteralFor(tmpsw.toString))
-        #sw.write('" + " FAILED "')
-        sw.write(')')
-        if _info
-            sw.write(' + "info="+')
-            _info.writeJavaDef(sw)
-        sw.write(';\n')
-        sw.dedent
-        #/
-
 class BlockStmt is partial
 
     def writeJavaDef(sw as CurlyWriter)
@@ -2074 +2211 @@
         sw.write('boolean [gotRightExceptionVarName] = false;\n')
         sw.write('try ')
         _block.writeJavaDef(sw)
-        sw.writeAndIndent('catch ([exceptionTypeRef]) {\n')
+        sw.writeAndIndent('catch ([exceptionTypeRef] _expExc ) {\n')
         sw.write('// exactly what is expected\n')
         sw.write('[gotRightExceptionVarName] = true;\n')
         sw.dedentAndWrite('}\n')
         if _exceptionType inherits Box and not (_exceptionType to Box).isJvmSystemExceptionClass
-            wrongExceptionVarName = '_lh_expect_[_varNumber]'
-            assert gotRightExceptionVarName <> wrongExceptionVarName
-            sw.writeAndIndent('catch (java.lang.Throwable [wrongExceptionVarName]) {\n')
-            sw.write('throw new cobra.core.ExpectException(typeof([exceptionTypeRef]), [wrongExceptionVarName]);\n')
+            gotWrongExceptionVarName = '_lh_expect_[_varNumber]'
+            assert gotRightExceptionVarName <> gotWrongExceptionVarName
+            sw.writeAndIndent('catch (java.lang.Throwable [gotWrongExceptionVarName]) {\n')
+            sw.write('throw new cobra.core.ExpectException([gotWrongExceptionVarName].getClass(), [gotWrongExceptionVarName]);\n')
             sw.dedentAndWrite('}\n')
-        sw.write('if (![gotRightExceptionVarName]) throw new cobra.core.ExpectException([exceptionTypeRef].getClass(), null);\n')
+        sw.write('if (![gotRightExceptionVarName]) throw new cobra.core.ExpectException([exceptionTypeRef].class, null);\n')
 
 
 class ForStmt is partial
@@ -2251 +2388 @@
         # in a C# foreach, (1) you must declare a new variable, (2) you cannot reassign it and (3) you cannot access it after the loop
         # these constraints don't exist in Cobra
         helperName = '_lh_for_[_var.name]_[_varNumber]'
-        sw.write('foreach ([_var.type.javaRef] [helperName] in ')
+        sw.write('for/*each*/ ([_var.type.javaRef] [helperName] : ')
 
         # TODO: the javaRef of a type is not qualified and there is no using System.Collections;
         # _what.writeJavaDefInContext(sw, false)
@@ -2320 +2457 @@
 
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
-        if _destination # java Writer
+        if _destination # java Writer or PrintStream
+            methodName = if(_stop, 'printStop', 'printLine')
+            sw.write('cobra.core.CobraImp.[methodName](')
             _destination.writeJavaDef(sw, true)
-            methodName = if(_stop, 'write', 'writeLine')
-            sw.write('.[methodName](')
+            sw.write(', ')
+            
+            # if destination as one type or with constant available methods in each type
+            # i.e if we only allowed destination to be a PrintStream or a PrintWriter...
+            #_destination.writeJavaDef(sw, true)
+            #methodName = if(_stop, 'print', 'println')
+            #sw.write('.[methodName](')
         else
             methodName = if(_stop, 'printStop', 'printLine')
             sw.write('cobra.core.CobraImp.[methodName](')
@@ -2429 +2573 @@
                 sw.write('[sep][Utils.javaStringLiteralFor(expr.toCobraSource)][sep]')
                 expr.writeJavaDef(sw, false)
             sw.write(');\n')
+        
+
+class TryStmt
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter)
+        base.writeJavaDef(sw)
+        if _successBlock
+            # Java also has no "success" (or in Python, "else") block for the "try" statement
+            # so it has to be simulated
+            helperName = '_lh_success_[_varNumber]'
+            sw.write('boolean [helperName] = true;\n')
+            if _finallyBlock
+                sw.write('try {\n')
+                sw.indent
+            sw.write('try')
+            _tryBlock.writeJavaDef(sw, false)
+            sw.dedent
+            sw.write('}\n')
+            if _catchBlocks.count
+                .writeCatchBlocksJava(sw, helperName)
+
+            sw.write('finally /*Success block*/{ if ([helperName])')
+            _successBlock.writeJavaDef(sw)
+            sw.write('}\n')
+
+            if _finallyBlock
+                sw.dedent
+                sw.write('}\n')
+                sw.write('finally')
+                _finallyBlock.writeJavaDef(sw)
+        else
+            sw.write('try')
+            _tryBlock.writeJavaDef(sw)
+            .writeCatchBlocksJava(sw, nil)
+            if _finallyBlock
+                sw.write('finally')
+                _finallyBlock.writeJavaDef(sw)
+    
+    # All exceptions caught will be either
+    # checked exceptions wrapped in a (RuntimeException based) CheckedExceptionWrapper
+    # or other RunTimeException based Exceptions.
+    # Generate code to rethrow these and can then just use the original cobra catchblocks as-is
+    def writeCatchBlocksJava(sw as CurlyWriter, localSuccessVar as String?)
+        sw.write('catch (Exception _exc0) {\n')
+        sw.indent
+        sw.write('try {\n')
+        sw.write('    if (_exc0 instanceof cobra.core.CheckedExceptionWrapper) {\n')
+        sw.write('        cobra.core.CheckedExceptionWrapper cxw = (cobra.core.CheckedExceptionWrapper)_exc0;\n')
+        sw.write('        throw cxw.getCause();   //:codeGen: catchblock Header\n')
+        sw.write('    }\n')
+        sw.write('    else throw (RuntimeException)_exc0;}\n')    
+        
+        sw.write('//-- cobra-code catch blocks\n')
+        _writeCatchBlocksJava(sw, localSuccessVar) # cobra code catch blocks
+        sw.write('//-- end cobra-code catch blocks\n')
+        
+        # fallthrough catch clause to propagate uncaught exceptions
+        hasException = false
+        for cb in _catchBlocks
+            if not cb.type or (cb.type and cb.type == .compiler.exceptionType)
+                hasException = true
+                break
+        if not hasException
+            sw.write('catch (Exception _exc1){\n')    
+            sw.write('    if (_exc1 instanceof cobra.core.CheckedExceptionWrapper){\n')
+            sw.write('        throw (cobra.core.CheckedExceptionWrapper) _exc0; //rethrow as uncaught\n')
+            sw.write('    }\n')
+            sw.write('    else throw (RuntimeException)_exc1;\n}\n')    
+
+        sw.dedent
+        sw.write('}\n')    
+        
+    # This is original writeCatchBlocksJava code generating the cobra catch blocks.
+    # It originally worked alongside writeJavaDef0 in ThrowStmt below
+    def _writeCatchBlocksJava(sw as CurlyWriter, localSuccessVar as String?)
+        for cb in _catchBlocks
+            sw.write('catch (')
+            if cb.type
+                sw.write(' [cb.type.javaRef]')
+            else # no catchAll in Java language so catch Exception
+                sw.write(' java.lang.Exception')
+            helperName = if(cb.varName, cb.sharpHelperName, '_anyExc' )
+            # using sharpHelperName above is correct(same as sharp) - value set in Statements:CatchBlock.bindInt
+            # should be renamed to be non BE specific tho'
+            cb.javaRethrowName = helperName to ! # stash name for possible rethrow
+            sw.write(' [helperName]')
+            sw.write(')')
+            sb = StringBuilder()
+            if localSuccessVar, sb.append('[localSuccessVar] = false;\n')
+            if .compiler.hasDetailedStackTraceOption, sb.append('CobraCoreInternal.CobraImp.HandledException();\n')
+            if cb.varName
+                trackLocals = .compiler.willTrackLocals
+                if trackLocals, sb.append('CobraCoreInternal.CobraImp.SetLocal("[cb.varName]", ')
+                sb.append('[cb.javaVarName] = [helperName]')
+                if trackLocals, sb.append(')')
+                sb.append(';\n')
+            cb.block.writeJavaDef(sw, sb.toString)
+
+        
+        
+class CatchBlock
+    is partial
+
+    get javaVarName as String
+        return _var.javaName
+
+    var javaRethrowName as String?
+    
+class ThrowStmt is partial
+    /# 
+    # This version tries to hide cobra mapping of Exceptions to RuntimeExceptions from coders
+    # We allow checked Exceptions (cobra coded) but when thrown codegen encloses them in a runtimeException: 
+    # In catch clauses we internally unwrap, examine and handle exceptions as coded
+    #
+    # Feeds into and is related to the (YTBD) determination of  what to do with calls to methods throwing 
+    # checked exceptions -
+    # Ideally codegen would automatically wrap calls generating a checked exception in a RuntimeException 
+    # generating wrapper and remainder handling would be treated  as above. 
+    # There is the possibility of a lotta repeated duplicated line by line code generated for cases 
+    # that a coder writing same would put together in a block using same try-catch...
+    # e.g. multiple sequential file io calls all generating IOException say..
+    # so as a convenience we may also want to provide some level of user specification 
+    # (compiler directive maybe) that specifies the enclosure limits of what should be wrapped in the 
+    # automatic code generated exception trapping boilerplate..
+    #   @jvm-wcx <ExceptionTYPE>
+    #       .. lines of code that may gen such an Exception
+    #
+    # As currently implemented we could just detect such calls (not explicitly wrapped) and emit a 
+    # diagnostic (actually rely on javac to do it for us) suggesting that the cobra code must explicitly 
+    # trap/handle/declare checked exceptions and generate RuntimeException from it.
+    #
+    # This explicitly pushes all the necessary handling onto the user but cruelly exposes our non support for 
+    # conveniently remapping checked exceptions... 
+    # also it makes for ugly code (and obscures the code control flow). 
+    #  (see comment below)
+    #/
+    def writeJavaDef(sw as CurlyWriter)
+        base.writeJavaDef(sw)
+        sw.write('throw ')
+        if _expr
+            if _expr.type.isDynamic,  sw.write('((java.lang.RuntimeException)')
+            #throw Runtime Exceptions as is
+            if _expr.type.isDescendantOf(.compiler.libraryType('Java.Lang.RuntimeException') to Box)
+                _expr.writeJavaDef(sw, false)
+            else
+                # Checked exceptions get wrapped in a runtime Exc wrapper
+                sw.write('new cobra.core.CheckedExceptionWrapper("Wrapping checked exception [_expr.type.name]",')
+                _expr.writeJavaDef(sw, false)
+                sw.write(')')
+            if _expr.type.isDynamic, sw.write(')')
+        else # rethrow
+            # Java doesnt support an unadorned throw in a CatchBlock (rethrow), needs an explicit exception
+            # look in enclosing block and if its a catchblock use its stored name (javaVarName)
+            if .superNode and .superNode.superNode inherits CatchBlock
+                rethrow = (.superNode.superNode to CatchBlock).javaRethrowName
+                sw.write('cobra.core.CobraImp.reThrow(')
+                sw.write(rethrow)
+                sw.write(')')
+                
+        sw.write(';\n')
+
+    /# 
+    # This original version of throws codegen was used along with JvmBackEnd
+    #   _tagToTypeName = {... 
+    #       'Exception' :       'Java.Lang.RuntimeException',
+    #       ...}
+    # makes the base Exceptionclass (compiler.ExceptionType) to be set to RuntimeException.
+    #
+    # This forces dvlpr written code to use only RuntimeException based exceptions explicitly       
+    # and also forces the explicit trapping of all methods throwing checked exceptions
+    #(to handle or convert to a wrapping RuntimeException) which does obscure the code layout - just like java... 
+    # We dont provide a way to specify Exceptions thrown on a method definition so the net effect is to 
+    # force cobra code to be written to conform (explicitly) to our forcing of all java Exceptions to 
+    # unchecked which may or may not be seen to be a good thing.....
+    # but its extra boilerplate cruft in cobra code, ugly and inconvenient to do
+    #/
+    def writeJavaDef0(sw as CurlyWriter)
+        base.writeJavaDef(sw)
+        sw.write('throw ')
+        if _expr
+            if _expr.type.isDynamic
+                sw.write('((java.lang.RuntimeException)')
+            _expr.writeJavaDef(sw, false)
+            if _expr.type.isDynamic
+                sw.write(')')
+        else # rethrow
+            # Java doesnt support an unadorned throw in a CatchBlock (rethrow), needs an explicit exception
+            # look in enclosing block and if catchblock use its stored name ( javaVarName)
+            if .superNode and .superNode.superNode inherits CatchBlock
+                rethrow = (.superNode.superNode to CatchBlock).javaRethrowName
+                sw.write(rethrow)
+                
+        sw.write(';\n')
+
             
 
 class UsingStmt
@@ -2698 +3037 @@
 class EnumCallExpr is partial
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
-        if parens, sw.write('(')
+        isSet = _args.count > 1
+        if parens
+            if isSet, sw.write('java.util.EnumSet.of')
+            sw.write('(')   
         if _args.count == 0
-            sw.write('default([_definition.javaRef])')
+            sw.write('/*default([_definition.javaRef])*/')
         else
             sep = ''
             for member in _members
                 sw.write(sep)
                 sw.write(member.javaRef)
-                sep = '|'
+                sep = ',' 
         if parens, sw.write(')')
 
     def writeJavaBreakdownItems(sw as CurlyWriter)
@@ -2887 +3229 @@
                 handled = true
         if not handled
             _target.writeJavaDef(sw)
-
-        ntIdxr = _lookupReadIndexer
+        ntIdxr = _lookupIndexer
         if ntIdxr
-            assert ntIdxr.getter
-            assert ntIdxr.getter.name.length
+            assert ntIdxr.getter             # getter for indexer exists 
+            assert ntIdxr.getter.name.length # and has a name set
             _writeIndexer(sw, '.[ntIdxr.getter.name](', ')')
         else
+            # fallback to treat as Array Type
             _writeIndexer(sw, r'[', r']')
         
         if parens, sw.write(')')
 
-    def _lookupReadIndexer as JavaFieldInfo?
+    def _lookupIndexer as JavaFieldInfo?
         nt = JvmNativeType.nativeType(_target.type.nonNil)
-        #print 'dbg', _target.type.nonNil, nt
+        if not nt # _target.type is genericInstance
+            tt = _target.type.nonNil to Box
+            genDef = tt.genericDef
+            nt = JvmNativeType.nativeType(genDef)
+        #print 'dbg-ReadIdxr', _target.type.nonNil,'\n+ ', nt
         if nt 
-            ntIdxr = nt.indexer
+            ntIdxr = nt.lookupIndexer
+            #print 'ntIdxr: [ntIdxr]'
             if ntIdxr and ntIdxr.isReadable
                 return ntIdxr
         #TODO: check for Indexer attribute for a Cobra user written version
         return nil      
-                
+    
     def _writeIndexer(sw as CurlyWriter, prefix as String, suffix as String)
         sw.write(prefix) 
         _writeIdxArgs(sw)
@@ -3237 +3584 @@
 
     get asJava as String is override
         return _name
+        
+class SequenceLit
+    is partial
 
+    def writeJavaBreakdownItems(sw as CurlyWriter) is override  # CC: axe is override
+        base.writeJavaBreakdownItems(sw)
+        sw.write(', +1')
+        for expr in _exprs
+            expr.writeJavaBreakdownItems(sw)
+        sw.write(', -1')
+    
+class ListLit
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        innerType = (_type to Box).genericParams[0]
+        sw.write('cobra.core.CobraImp.makeList/*<[innerType.javaRef]>*/(')
+        if _exprs.count
+            sep = ''
+            for expr in _exprs
+                sw.write(sep)
+                expr.writeJavaDef(sw, false)
+                sep = ', '
+        sw.write(')')
+
+
+class ArrayLit
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        sw.write('new [_type.javaRef] { ')
+        if _exprs.count
+            sep = ''
+            for expr in _exprs
+                sw.write(sep)
+                expr.writeJavaDef(sw, false)
+                sep = ', '
+        sw.write(' }')
+
+
+class SetLit
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        innerType = (_type to Box).genericParams[0]
+        sw.write('cobra.core.CobraImp.makeSet/*<[innerType.javaRef]>*/(')
+        if _exprs.count
+            sw.write(', ')
+            sep = ''
+            for expr in _exprs
+                sw.write(sep)
+                expr.writeJavaDef(sw, false)
+                sep = ', '
+        sw.write(')')
+    
+        
 class ToNilableOrNotExpr
     is partial
 
@@ -3338 +3740 @@
         if _right inherits TryCatchExpr # expand trycatch and do assignment within the expansion
             _right.writeJavaDef(sw) 
             return  
+        #trace _right
 
         # TODO:
         # if trackLocal:
@@ -3867 +4270 @@
         _left.writeJavaBreakdownItems(sw)
 
 
+class InExpr is partial
+    """ v in container"""
+    
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        v = true
+        branch _op
+            on 'NOTIN', sw.write('!')
+            on 'IN', pass
+            else, throw FallThroughException(_op)
+        if .needsNilCheck
+            # Constraints:
+            # (1) Don't evaluate the left expression twice
+            # (2) Don't evaluate the right expression if the left is nil
+            # In general, don't cause side effects from extra evaluation.
+            if .left inherits IdentifierExpr and (.left to IdentifierExpr).definition inherits IVar
+                # If the left is a var, there is no danger in double evaluation causing side effects.
+                # java: (someVar==null ? false : <check>)
+                sw.write('(')
+                .left.writeJavaDef(sw, false)
+                sw.write('==null ? false : ')
+                # may have to cast int? to int, for example
+                if  .left.type inherits NilableType _
+                    and not .left.type.nonNil.isReference _
+                    and .containsExpr
+                    # well this last condition doesn't work so well due to generic args like List.Contains(T item)
+                    # and not (((.containsExpr to DotExpr).dotRight.memberDefinition to Method).params[0].type inherits NilableType)
+                    
+                    # then need cast
+                    assert .left.type inherits NilableType
+                    .right.writeJavaDef(sw, false)
+                    sw.write('.contains(([.left.type.nonNil.javaRef])')
+                    .left.writeJavaDef(sw)
+                    sw.write(')')
+                    if v, sw.write('/* A */')
+                else
+                    .writeInCheckJava(sw, false, v)
+                    if v, sw.write('/* B */')
+                sw.write(')')
+            else
+                # cobra: left in right
+                # java: cobra.core.CobraImp.inWithNullCheck(<left>, delegate(__lh_value) { return <right>.Contains(__lh_value); })
+                # use:   static public bool inWithNullCheck<T>(T a, Predicate<T> predicate)
+
+                # cobra: left in right
+                # java: cobra.core.CobraImp.in(left, delegate() { return right; })
+                sw.write('cobra.core/*CobraCoreInternal*/.CobraImp.inWithNullCheck(')
+                .left.writeJavaDef(sw, false)
+                sw.write(', delegate([.left.type.javaRef] __lh_value_[.serialNum]) { return ')
+                if .containsExpr
+                    # Do not write the .containsExpr here because it's argument to .contains in the
+                    # full left expression. Instead, we want to pass the argument passed to the delegate.
+                    .right.writeJavaDef(sw, false)
+                    sw.write('.contains(([.left.type.nonNil.javaRef]) __lh_value_[.serialNum]);')
+                    if v, sw.write('/* C */')
+                else
+                    # No .containsExpr means we use CobraImp.In(a, b) for the delegate
+                    sw.write('cobra.core/*CobraCoreInternal*/.CobraImp.in(__lh_value_[.serialNum], ')
+                    .right.writeJavaDef(sw, false)
+                    if v, sw.write('/* D */')
+                sw.write(' })')
+        else
+            .writeInCheckJava(sw, parens, v)
+            if v, sw.write('/* E */')
+
+    def writeInCheckJava(sw as CurlyWriter, parens as bool, v as bool)
+        if .containsExpr
+            .containsExpr.writeJavaDef(sw, parens)
+            if v, sw.write('/* F */')
+        else
+            sw.write('cobra.core/*CobraCoreInternal*/.CobraImp.in(')
+            .left.writeJavaDef(sw, false)
+            sw.write(',')
+            .right.writeJavaDef(sw, false)
+            sw.write(')')
+            if v, sw.write('/* G */')
+
 class InheritsExpr
     is partial
                 
@@ -3875 +4354 @@
         #sw.write(' instanceof ')
         #_right.writeJavaDef(sw, false)
 
+        # have to handle primitives ( bool, char, byte,short, int, long,float, double) specially
+        
         # Compiler generates error with instanceof for non intersecting instance and Type so
         # instead use runtime instance lookup
         #  instead of 'e instanceof T'  becomes 'T.class.isInstance(e)'
-        _right.writeJavaDef(sw, false)
-        #sw.write('.class.isInstance(')
+        # Have to map primitives to wrappers cos autoboxing makes it wrong
+        if _right inherits TypeExpr # primitives
+            ctjref = _right.containedType.javaRef
+            if  ctjref == 'int',    ctjref = 'Integer.class'
+            if  ctjref == 'char',   ctjref = 'Character.class'
+            if  ctjref == 'short',  ctjref = 'Short.class'
+            if  ctjref == 'long',   ctjref = 'Long.class'
+            if  ctjref == 'boolean', ctjref = 'Boolean.class'
+            if  ctjref == 'byte',   ctjref = 'Byte.class'
+            if  ctjref == 'float',  ctjref = 'Float.class'
+            if  ctjref == 'double', ctjref = 'Double.class'
+            sw.write(ctjref)    
+            isPrim = true
+
+        if not isPrim
+            _right.writeJavaDef(sw, false)
         sw.write('.isInstance(')
         _left.writeJavaDef(sw)
         sw.write(' )')
 
-
 class ToExpr is partial
 
 /#  def needsContextCast as bool is override
@@ -4168 +4662 @@
     def writeJavaTestInvocation(sw as CurlyWriter)
         pass
 
-class EnumMember is partial
-
-    def writeJavaTestInvocation(sw as CurlyWriter)
-        pass
-
 class Extension is partial
 
     get javaKeyWord as String is override

Source/TestifyRunner.cobra

@@ -281 +281 @@
         if baseName.startsWith('.') or baseName.startsWith('_')
             # examples: .svn, _svn. Also, _ is a nice way to temporarily exclude a directory if possible
             return
+        if _useConfigPath(dirName), return      
+        _testifyDir(dirName, nil)
+        
+    def _useConfigPath(dirName as String) as bool
         configPath = Path.combine(dirName, 'testify.kv')
         if File.exists(configPath)
             dirOptions = Utils.readKeyValues(configPath)
@@ -288 +292 @@
                 argSets = dirOptions['args'].split(@[c'|'])
                 for argSet in argSets
                     _testifyDir(dirName, argSet.trim)
-                return
-        _testifyDir(dirName, nil)
-
+                return true
+        return false
+            
     def _testifyDir(dirName as String, args as String?)
-        willCopyLibs = true  # not CobraCore.isRunningMono  # On Mono, we use MONO_PATH instead of coping the Cobra.Core.dll around
-        libNames = ['Cobra.Core.dll']
         _extraTestifyArgs = args
         _statusWriter.writeLine(if(args, '[dirName] with args: [args]', '[dirName]'))
         _statusWriter.indent
         try
             print 'Running tests in [dirName]'
             saveDir = Environment.currentDirectory
-            if willCopyLibs
-                # _cleanDir will remove these later
-                for libName in libNames
-                    # Ideally, the file operations below would not be wrapped with try...catch and a
-                    # 'warning' because if the current library files cannot be copied into the test
-                    # directory, then the test is not valid. However, Windows has problems with
-                    # deleting and/or copying over Cobra.Core.dll right after it has been used. This
-                    # comes up on Tests\340-contracts whose testify.kv config file specifies two
-                    # runs of the directory.
-                    targetPath = Path.combine(dirName, libName)
-                    if File.exists(targetPath)
-                        if Utils.isRunningOnUnix
-                            File.delete(targetPath)
-                        else
-                            # Windows is just too damn picky...
-                            try
-                                File.delete(targetPath)
-                            catch UnauthorizedAccessException
-                                print 'testify warning: cannot delete:', targetPath
-                    if libName == 'Cobra.Core.dll' or File.exists(libName)
-                        if Utils.isRunningOnUnix
-                            File.copy(Path.combine(saveDir, libName), targetPath)
-                        else
-                            try
-                                File.copy(Path.combine(saveDir, libName), targetPath, true)
-                            catch IOException
-                                print 'testify warning: cannot copy or copy over:', targetPath
+            _copyLibs(saveDir, dirName)
             Directory.setCurrentDirectory(dirName)
             try
-                setUpScript = if(Utils.isRunningOnUnix, 'testify-set-up', 'testify-set-up.bat')
-                if File.exists(setUpScript)
-                    print '* * * * Running [setUpScript]'
-                    process = Process()
-                    process.startInfo.fileName = setUpScript
-                    setUpOutput = process.runAndCaptureAllOutput
-                    if process.exitCode <> 0
-                        print 'TESTIFY WARNING: Script [setUpScript] exited with error code [process.exitCode]'
-                        print 'begin output'
-                        print setUpOutput.trim
-                        print 'end output'
+                _runSetupScript
                 paths = List<of String>(Directory.getFiles('.'))
                 paths.addRange(Directory.getDirectories('.') to passthrough)
                 paths.sort
@@ -359 +325 @@
         finally
             _statusWriter.dedent
         _testifyFlush
+        
+    def _copyLibs(saveDir as String, dirName as String)
+        """
+        Copy Cobra Libs etc to sources directory if platform needs it.
+        _cleanDir will remove these later
+        """
+        if _runtimePlatform(nil) <> 'clr'  # other platforms use a Path instead of dll in cwd
+            return
+        # if CobraCore.isRunningMono  # On Mono, we use MONO_PATH instead of copying the Cobra.Core.dll around
+        #   return  
+        libNames = ['Cobra.Core.dll']
+        for libName in libNames
+            # Ideally, the file operations below would not be wrapped with try...catch and a
+            # 'warning' because if the current library files cannot be copied into the test
+            # directory, then the test is not valid. However, Windows has problems with
+            # deleting and/or copying over Cobra.Core.dll right after it has been used. This
+            # comes up on Tests\340-contracts whose testify.kv config file specifies two
+            # runs of the directory.
+            targetPath = Path.combine(dirName, libName)
+            if File.exists(targetPath)
+                if Utils.isRunningOnUnix
+                    File.delete(targetPath)
+                else
+                    # Windows is just too damn picky...
+                    try
+                        File.delete(targetPath)
+                    catch UnauthorizedAccessException
+                        print 'testify warning: cannot delete:', targetPath
+            if libName == 'Cobra.Core.dll' or File.exists(libName)
+                if Utils.isRunningOnUnix
+                    File.copy(Path.combine(saveDir, libName), targetPath)
+                else
+                    try
+                        File.copy(Path.combine(saveDir, libName), targetPath, true)
+                    catch IOException
+                        print 'testify warning: cannot copy or copy over:', targetPath
 
+    def _runtimePlatform(options as OptionValues?) as String
+        if not options, options = .testifyOptions
+        rtp = if(options['back-end']=='none', CobraCore.runtimePlatform, options['back-end'] to String)
+        return rtp
+        
+    def _runSetupScript
+        setUpScript = if(Utils.isRunningOnUnix, 'testify-set-up', 'testify-set-up.bat')
+        if File.exists(setUpScript)
+            print '* * * * Running [setUpScript]'
+            process = Process()
+            process.startInfo.fileName = setUpScript
+            setUpOutput = process.runAndCaptureAllOutput
+            if process.exitCode <> 0
+                print 'TESTIFY WARNING: Script [setUpScript] exited with error code [process.exitCode]'
+                print 'begin output'
+                print setUpOutput.trim
+                print 'end output'
+
     def testifyFile(baseName as String) as int
         save = _failureCount
         _firstAttempt = true
@@ -423 +443 @@
         if inLineMessages.count > 0 #  hasInlineMessages
             return _testifyInlineMessages(inLineMessages, expectingError, 
                                             compilerVerbosity, [baseName], options, verbose )
-
+                                            
         if firstLineInsensitive.startsWith('#.error.')
             # deprecated: put errors on the lines where they occur. the "hasInlineMessages" code above will detect them.
             # Note that errors that are only detected by the backend C# compiler are not detectable by testify
@@ -471 +491 @@
                 continue
 
             if firstLineInsensitive.startsWith('#.require.')
-                rtPlatform  = if(options['back-end']=='none', CobraCore.runtimePlatform, options['back-end'])
+                rtPlatform  = _runtimePlatform(options)
                 what = firstLineInsensitive[10:]
                 branch what
                     on 'mono'
@@ -714 +734 @@
             
     def _testifyStd(compilerVerbosity as int, fileNames as IList<of String>,
                             options as OptionValues, verbose as bool) as int        
-        c = Compiler(compilerVerbosity, _cachedTestifyModules, commandLineArgParser=_cl.argParser)
         try
+            c = Compiler(compilerVerbosity, _cachedTestifyModules, commandLineArgParser=_cl.argParser)
             c.testifyFilesNamed(fileNames, options, _resultsWriter to !, verbose)
         catch StopCompilation
             .failed
@@ -768 +788 @@
 
         print .bar
 
-        _cachedTestifyModules = for mod in c.modules where mod inherits AssemblyModule get mod
+        #_cachedTestifyModules = for mod in c.modules where mod inherits AssemblyModule get mod
 
         return 1
 

Source/Enums.cobra

@@ -10 +10 @@
     var _storageType as IType?
     var _nativeType as NativeType?
     var _needScanNativeType as bool
-
+    var _isUsedAsSet = false    # flag if multi member initted
+    
     cue init(parent as IParentSpace?, token as IToken, idToken as IToken, name as String, isNames as List<of String>, attribs as AttributeList, storageTypeNode as ITypeProxy?, docString as String, enumMembers as List<of EnumMember>)
         base.init(parent, token, name, isNames, docString)
         _idToken = idToken
@@ -27 +28 @@
         _nativeType = nativeType
         assert .compiler
         .backEnd.setUnderlyingType(this)  # sets _storageTypeNode
-        #_storageTypeNode = ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).backEndType))  # TODO: fix native
         _needScanNativeType = true
         
     def _scanNativeType
@@ -84 +84 @@
     get typeForReceiver as IType is override
         return this
 
+    pro isUsedAsSet from var
+        
     def _bindInt is override
         base._bindInt
         for attrib in .attributes, attrib.bindInt
@@ -119 +121 @@
         body
             _parentBox = newBox
 
-
+    
 class EnumMember
     is partial
     inherits NamedNode
     implements IMember
     """
     Holds the name and (optionally) value of a member of an EnumDecl.
+    One of these is what an enum instance will be set to.
     """
 
     var _value as int?

Source/Statements.cobra

@@ -667 +667 @@
         if isStreamOfKeyValue, kvRHS = ['key', 'value']
         if _var.type inherits Box
             if not isStreamOfKeyValue
-                isStreamOfKeyValue = (_var.type to Box).isIndirectConstructionOf(.compiler.libraryType('System.Collections.Generic.KeyValuePair<of,>') to Box)
+                #isStreamOfKeyValue = (_var.type to Box).isIndirectConstructionOf(.compiler.libraryType('System.Collections.Generic.KeyValuePair<of,>') to Box)  # compiler.KeyValuePairOfType
+                isStreamOfKeyValue = (_var.type to Box).isIndirectConstructionOf(.compiler.keyValuePairOfType)
                 if isStreamOfKeyValue, kvRHS = ['key', 'value']
             if not isStreamOfKeyValue
                 isStreamOfKeyValue = (_var.type to Box).isDescendantOf(.compiler.libraryType('Cobra.Core.BasePair') to Box)
@@ -976 +977 @@
         base._bindImp
         if .destination
             .destination.bindImp
-            t = .destination.type
-            if not t.isDynamicOrPassThrough and not t.isDescendantOf(.compiler.libraryType('System.IO.TextWriter'))  # TODO-BACKEND
-                .recordError('Invalid destination of type "[t.name]" for "print". Use a TextWriter or subclass thereof instead.')
+            t = .destination.type 
+            if not t.isDynamicOrPassThrough
+                .compiler.backEnd.validatePrintDestType(t to !, this) 
 
 
 class PrintStmt inherits AbstractPrintStmt is partial
@@ -1403 +1404 @@
         else if _typeNode
             _typeNode.bindImp
             _type = _typeNode.realType  # CC: combine with above: _type = _typeNode.bindImp.realType
-        _sharpHelperName = '_lh_catch_[.compiler.curBox.makeNextPrivateSerialNumber]'
+        _sharpHelperName = '_lh_catch_[.compiler.curBox.makeNextPrivateSerialNumber]' # TODO rename to HelperName or beHelperName - common to both backends
         _block.bindImp
 
 
@@ -1455 +1456 @@
                     if _expr.definition inherits BoxEvent
                         reason = 'it is an event, not an exception. Either throw an exception or use "raise" on the event instead of "throw"'
                     else
-                        reason = 'it does not inherit from Exception'
+                        reason = 'it does not inherit from [exceptionType.name] (Exception)'
                     .throwError('Cannot throw "[_expr.type.name]" because [reason].')
         .compiler.curCodeMember.hasThrowStmt = true
 
@@ -1807 +1808 @@
             if isPair
                 memberNames = ['a', 'b']
             else if not isPair
-                isPair = (_source.type to Box).isIndirectConstructionOf(.compiler.libraryType('System.Collections.Generic.KeyValuePair<of,>') to Box)
+                isPair = (_source.type to Box).isIndirectConstructionOf(.compiler.keyValuePairOfType)
                 if isPair, memberNames = ['key', 'value']
 
         if isPair

Source/Cobra.Core/Java/CobraCore.java

@@ -18 +18 @@
 
 public class CobraCore {
     
+    // Release info
+    public static final String versionDescription = "svn-post-0.8.0(jvm)";
+        //textual description of the version such as "X.Y.Z" or "svn-post-X.Y.Z".
+    public static final boolean isOfficialRelease = false;
+    public static final int version = CobraCore.toVersionNumber(0,8,0); // Version# - Version(0, 8, 0)
+    public static final int releaseNum = 25;
+
     public static Boolean _willCheckInvariant = true;
     public static Boolean _willCheckRequire = true;
     public static Boolean _willCheckEnsure = true;
@@ -47 +54 @@
     System.exit(exitCode);
     }
             
-    public static String newLine =  System.getProperty("line.separator");
+    public static final String newLine =  System.getProperty("line.separator");
     //""" Returns the newline for the current environment/platform. """
 
     // Property StringMaker techStringMaker
@@ -76 +83 @@
     """
     Run all Cobra `test` sections in all assemblies using reflection to locate them.
     """
-    if CobraImp.showTestProgress, listener = Cobra.Lang.Test.TextWriterListener(Console.out)
-    else, listener = Cobra.Lang.Test.TextWriterOnlyOnFailureListener(Console.out)
-    tr = Cobra.Lang.Test.TestRunner(listener)
+    if CobraImp.showTestProgress, listener = Cobra.Core.Test.TextWriterListener(Console.out)
+    else, listener = Cobra.Core.Test.TextWriterOnlyOnFailureListener(Console.out)
+    tr = Cobra.Core.Test.TestRunner(listener)
     tr.runAllTests
     if listener.testFailures, CobraCore.exit(1)
      */
@@ -103 +110 @@
         // TODO: CobraImp.printLine( "    See also: http://cobra-language.com/docs/debugging");
         CobraImp.printLine();
     }
+    
+    public static final int toVersionNumber( int major, int minor, int rev) {
+        assert major >= 0 && major < 100 : "Major between 0 and 99";
+        assert minor >= 0 && minor < 100 : "Minor between 0 and 99";
+        assert rev >= 0 && rev < 100 :   "Rev between 0 and 99";
+        return major*1000 + minor*100 + rev;
+    }
 }
 

Source/Cobra.Core/Java/CheckedExceptionWrapper.java

@@ +1 @@
+/* 
+ * A Runtime Exception wrapping a Checked Exception.
+ * Compiler generates internally in 'throws' codegen and unwrapped in catch clauses codegen
+ * See JavaGenerator.cobra ThrowStmt.writeJavaDef and tryStmt.writeCatchBlocksJava
+ * 
+ * Basically a Marker class for RuntimeException.
+ */
+
+package cobra.core;
+
+
+public class CheckedExceptionWrapper extends RuntimeException {
+    
+    public CheckedExceptionWrapper(String msg, Exception cause) {
+        super(msg, cause);
+    }
+
+    public Exception getCause() {
+        return (Exception) super.getCause();
+    }
+}
+
+

Source/Cobra.Core/Java/Delegate.java

@@ -8 +8 @@
  *  call      myDelegate(arg0,...)                                -> d.invoke(arg0,...)  
  *            (or no args:  myDelegate()                          -> d.invoke()  )
  *
- * Doesnt support Generics.
  * This Implementation genericised on ReturnType
  */
 
@@ -19 +18 @@
 import java.util.*;
 import java.lang.reflect.*;
 
+
 public class Delegate<T> {
     Class<T> returnType;  //  method returnType
     Class<?>[] paramTypes;  // Types of the method parameters 
@@ -209 +209 @@
     }
 }    
 
-
 class TestDelegate {
 
     public static void main(String... args) { 

Source/Cobra.Core/Java/mkjarAll

@@ -8 +8 @@
 
 [ -d classes ] || mkdir classes
 [ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
-EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java"
-javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java ${EXCEPTIONS} CobraDirectString.java
+EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java ExpectException.java CheckedExceptionWrapper.java"
+javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java DelegateO.java Pair.java ${EXCEPTIONS} CobraDirectString.java
 [ $? == 0 ] || exit
 
 jar cvf ${CORE_RTL} -C classes .
 [ $? == 0 ] || exit
 cp ${CORE_RTL} ../..
 
-if [ ! -e PkgSig.class ]; then 
+#if [ ! -e PkgSig.class ]; then 
+#    echo 'building PkgSig app'
+#    javac -cp . PkgSig.java
+if [ ! -e PkgSig.jar ]; then 
     echo 'building PkgSig app'
-    javac -cp . PkgSig.java
+    PSIGDIR=pkgsig-classes
+    [ -d $PSIGDIR ] || mkdir $PSIGDIR
+    javac -cp . -d $PSIGDIR PkgSig.java
+    jar cvfe PkgSig.jar PkgSig -C $PSIGDIR .
 fi
 
+export CLASSPATH='PkgSig.jar'
 echo 'Gen pkgSig file for '${CORE_RTL}
-java -cp ".;${CORE_RTL}"  PkgSig -j ${CORE_RTL} > ${CORE_RTL}.sig
+java -cp "${CLASSPATH};${CORE_RTL}"  PkgSig -j ${CORE_RTL} > ${CORE_RTL}.sig
 
 echo 'Gen pkgSig file for rt.jar'
-java -cp .  PkgSig -jrt > rt.jar.sig
+java   PkgSig -jrt > rt.jar.sig
 echo 'Gen pkgSig file for java.lang'
-java -cp .  PkgSig  java.lang > java.lang.sig
+java   PkgSig  java.lang > java.lang.sig
 echo 'Gen pkgSig file for java.util'
-java -cp .  PkgSig  java.util > java.util.sig
+java  PkgSig  java.util > java.util.sig
 
-echo 'copy .sig files to compiler directory'
-cp ${CORE_RTL}.sig rt.jar.sig java.util.sig java.lang.sig ../..
+#echo 'copy .sig files to compiler directory'
+#cp ${CORE_RTL}.sig rt.jar.sig java.util.sig java.lang.sig ../..

Source/Cobra.Core/Java/read-me.text

@@ -14 +14 @@
 compiler. Then we'll have a cobra to java compiler on the jvm.
 
 Supporting that is this directory which provides 
-    - stub code for a java cobra RTL (CobraLang.jar)
-    - A tool to generate descriptions for java library classes (Pkgsig files)
-    - a script to build and copy the various supporting pieces the java backend needs to the compiler Source directory.
+    - stub code for a java cobra RTL (CobraCore.jar)
+    - A tool (PkgSig.jar) to generate descriptions for java library classes (Pkgsig files)
+    - a script (mkjarAll) to build and copy the various supporting pieces the java backend needs to 
+        the compiler Source directory. 
     
 
-The base java version supported is currently 1.6.
+The base java version supported is currently 1.7. 
+(I started with 1.6, It may still work to some extent with that java version )
 This one specifically
-java version "1.6.0_24"
-Java(TM) SE Runtime Environment (build 1.6.0_24-b07)
-Java HotSpot(TM) Client VM (build 19.1-b02, mixed mode, sharing)
+java version "1.7.0_04"
+Java(TM) SE Runtime Environment (build 1.7.0_04-b22)
+Java HotSpot(TM) Client VM (build 23.0-b21, mixed mode, sharing)
 
-This will move up to at least 1.7 as the port/code generation progresses
-and will probably stabilise on 1.8 eventually.
+This will move up to 1.8 as the port/code generation progresses and 1.8 gets more useful
+capabilities. I will probably stabilise on 1.8 as the base eventually.
  
 = Caveats =
 
 This backend  is under development 
- - for any but the most trivial uses it is effectively broken.
- There are large amounts of (java) code generation missing.
- It spews debug/diagnostic/conversational/status info all the time.
+ - for any but the most trivial uses it is broken.
+ There are amounts of (java) code generation missing.
+ It will possibly spew debug/diagnostic/conversational/status info all the time.
  There are bugs.
  There are missing capabilities.  
  There are horrible bits 
@@ -48 +50 @@
 This is a source modification - no installation support. 
 Run the compiler out of the cobra source directory
 
-I'm developing this in Windows (XP) - it may or may not be working under mono 
-on any other platform.
+I'm now developing this in Windows 7 (I started in Windows XP but a System crash caused a 
+correction of that)
+ - it may or may not be working under mono on any other platform.
 
-This is (the/an) initial devt snapshot. 
-Its working(ish) but rough, 
+This is a devt snapshot. Its working(ish) but rough, 
 Things will change
 
 - What To Do -
@@ -61 +63 @@
  happens, good for you.
  This is what you will need to do
 
-    1) If necessary 
-       Apply the patches providing the java backend to the Source tree
-        - get the modified compiler subsequently rebuilt
-
-       As on Nov 2011 (and touch wood) all the jvm patches posted have been 
-       applied to the code repository source so it should be enough to pull down the latest compiler source and build it.
+    1) As of Nov 2011 (and touch wood) all the jvm patches posted have been 
+       applied to the code repository source so it should be enough to pull down the latest
+       compiler source and build it.
        
-        Patch should be on the cobra website http://cobra-language.com
+        Any unapplied patches should be on the cobra website http://cobra-language.com
         Ticket 275: More support for java backend
             http://cobra-language.com/trac/cobra/ticket/275
         
-    2) Ensure java and javac executables (1.6 or later) are in your PATH and work.
+    2) Ensure jar, java and javac executables (1.7 or later) are in your PATH and work.
     
-    3) Go into this dir and run ./mkJarAll 
+    3) Go into this dir and run ./mkjarAll 
         ( its a bash script - you will need bash or to port the script, 
-            or run the command contents manually) - this builds the cobra RTL and  
-        package signature tool and uses that to create the class description info and copies 
-        them to the  right places in the  cobra source tree)
+            or run the command contents manually) - this compiles the (minimal) cobra RTL 
+            ( java source to a jarfile) and builds the package signature tool and uses that 
+            to create the class description info (.sig files) and copies 
+                them to the  right places (Source dir alongside cobra.exe)
+                in the cobra source tree)
+                
     4) find a test cobra script and compile it
+        a good smoke test is Tests/100-basic/001.cobra
 
 - How to build and run a cobra program generating a java app -
 
@@ -103 +106 @@
 
 
 - Status - 
+
+    Theres a more complete timeline tracking the uploaded patches on the ticket
+        Ticket 275: More support for java backend
+        http://cobra-language.com/trac/cobra/ticket/275
+    
  Jul-2011 - We can build and run simple (single file) programs. 
     (Up to about 032-* of the files in Tests/100-*. 
         Maybe more but thats what I've tried so far)
@@ -112 +120 @@
     (Up to about 080-* of the files in Tests/100-*)
     Have properties and Indexers, Casting, reading Commandline ...     
 
+ Mar-2012 - Minor cleanups and Testify compiler testcase harness working
+
+ 10-Aug-2012 try and sync a major push for a cobra release.
+   Fix testcase regressions noted from testify runs
+      - fix issue with multiple internal Testify invocations
+      - fix incorrect conversion cobra to java name forms in multiple namespace generics 
+      - get indexing ([]) working mapping to indexer getters/setters
+      - type inference in foreach and support iterators (java vs enumerators in CLR)
+      - In pkgSig correct some bad name handling for nested classes in rt.jar
+      - extend java RTL some more support codegen
+   Support try/catch and throw  (minimally)
+       Modify this to correctly autowrap thrown checked Exceptions into runtimeExceptions and
+       unwrap, catch or propagate correctly in catch clauses.
+       Methods throwing checked Exceptions still need to be explicitly wrapped 
+
+   Pull backEnd Abstract base classs out to its own file
+   
+   Start enum support   
+    (Up to about 301-* of the files in Tests/100-*)
+
+   Sep-2012
+   Complete enum support (Tests/100-*/302-334a*).
+   setup so enums built using the ctor syntax with multiple initial values( Enum(val1,val2) internally
+   use ( in java) and EnumSet. Codegen will break if you try and treat this as a sigle enum value and a multivalue set.
+    
+   Add inbuilt support for testing for an enum value membership in a enum variable (set) using 
+   'value in enumSet'
+   see test  (310j-* and 334a-*)
+   
+   Modify build so creates an executable jar file from classfiles(and runs it).
+   This means all classpath dependencies must be listed correctly in the manifest file 
+   (see JavaGenerator.cobra _javaTool) 
+   Correct handling for multiple cobra files and cobra file containing multiple classes. 
+
+   Fixup codegen for print and print redirection. Add necessary RTL support 
+
+   BackEnd KeyValuePair Type, support Pair (since compiler now uses it) 
+
+
+TODO
+    load annotations into .sig files and use for things like nullability
+        PkgSig.java and handling in JarSig.cobra
+        
+    Support native static methods on box instances
+        installJvmNativeMethods in ScanJvmType    
+        
+    Handling ( wrap and convert) calls to methods in java libs generating
+    non RuntimeExceptions.
+     
 - Other -
 
 Post issues/questions/comments/etc if you have them to Cobra Programming Language Forum

Source/Cobra.Core/Java/DynamicOperationException.java

@@ -29 +29 @@
     protected Object _obj;
     protected String _name;
     Class _type;
+    Exception _exc;
 
     public UnknownMemberException(Object obj, String name, Class type) {  this(obj, name, type, null);}
     public UnknownMemberException(Object obj, String name, Class type, Exception cause) 
@@ -39 +40 @@
         this._obj = obj;
         this._name = name;
         this._type = type;
+        this._exc = cause;
     }
 }
 
+
+class CannotInTypeException extends UnknownMemberException
+{
+    public CannotInTypeException(Object obj, String name, Class type)
+    {
+        super(obj, name, type, null);
+    }
+
+    public CannotInTypeException(Object obj, String name, Class type, Exception innerExc)
+    {
+    super(obj, name, type, innerExc);
+    }
+}
+
+
 /*
  * Missing, unreadable Member Exceptions
  * / 
@@ -78 +95 @@
             base.init(obj, name, type, innerExc)
 
 
-    class CannotInTypeException inherits UnknownMemberException
 
-        # CC: axe init()s
-
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
-
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init(obj, name, type, innerExc)
-
-
 class CannotCompareException inherits DynamicOperationException
 
         var _a

Source/Cobra.Core/Java/PkgSig.java

@@ -799 +799 @@
         String tStr = t.toString();
         //System.out.printf("### %-50s \n", tStr);
         tStr = tStr.replace("java.util.Map.java.util.Map", "java.util.Map");  // EntrySets screwed for some reason
-        
+        tStr = tStr.replace("java.nio.file.WatchEvent.java.nio.file.WatchEvent", "java.nio.file.WatchEvent"); 
+        tStr = tStr.replace("java.nio.file.DirectoryStream.java.nio.file.DirectoryStream", "java.nio.file.DirectoryStream");
+
         tStr = tStr.replace("class ", "");  // sometimes puts on leading 'type '
         tStr = tStr.replace("interface ", "");  
         // possibly others - enum ?

Source/Cobra.Core/Java/mkjar

@@ -7 +7 @@
 
 [ -d classes ] || mkdir classes
 [ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
-EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java"
-javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java ${EXCEPTIONS} CobraDirectString.java
+EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java ExpectException.java CheckedExceptionWrapper.java"
+javac -Xlint:unchecked -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java DelegateO.java BasePair.java Pair.java ${EXCEPTIONS} CobraDirectString.java
 [ $? == 0 ] || exit
 
 jar cvf ${CORE_RTL} -C classes .
 [ $? == 0 ] || exit
 cp ${CORE_RTL} ../..
 
-#echo 'pkgSig for CobraCore.jar'
-java -cp ".;${CORE_RTL}"  PkgSig -j ${CORE_RTL} >  ${CORE_RTL}.sig
+echo 'Gen pkgSig for CobraCore.jar'
+java -cp "PkgSig.jar;${CORE_RTL}"  PkgSig -j ${CORE_RTL} >  ${CORE_RTL}.sig
 cp  ${CORE_RTL}.sig  ../..
 
 

Source/Cobra.Core/Java/SourceSite.java

@@ -8 +8 @@
 
 public class SourceSite {
     /* 
-     * See Cobra.Lang.SourceSite.cobra
+     * See Cobra.Core.SourceSite.cobra
      * 
      *  A SourceSite instance captures the source location of a statement or expression, as in the
      *  filename, line number, declaring class name, method name and run-time object. The Cobra

Source/Cobra.Core/Java/mkjarOnly

@@ -7 +7 @@
 
 [ -d classes ] || mkdir classes
 [ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
-EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java"
-javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java ${EXCEPTIONS} CobraDirectString.java
+EXCEPTIONS="AssertException.java InvariantException.java RequireException.java EnsureException.java NonNilCastException.java DynamicOperationException.java ExpectException.java CheckedExceptionWrapper.java"
+javac -Xlint:unchecked -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java DelegateO.java Pair.java ${EXCEPTIONS} CobraDirectString.java
 [ $? == 0 ] || exit
 jar cvf ${CORE_RTL} -C classes .
 [ $? == 0 ] || exit
 cp ${CORE_RTL} ../..
 
 #echo 'pkgSig for '${CORE_RTL}
-#java -cp ".;${CORE_RTL}"  PkgSig -j ${CORE_RTL} > ${CORE_RTL}.sig
+#java -cp "PkgSig.jar;${CORE_RTL}"  PkgSig -j ${CORE_RTL} > ${CORE_RTL}.sig
 #cp ${CORE_RTL}.sig  ../..
 
 

Source/Cobra.Core/Java/NonNilCastException.java

@@ -39 +39 @@
 
 /*  ## Misc exceptions
 
-    class ExpectException inherits Exception
+    class ExpectException extends RuntimeException 
 
         cue init(expectedExceptionType as Type, actualException as Exception?)
             base.init

Source/Cobra.Core/Java/DelegateO.java

@@ +1 @@
+/*
+ * Non genericised Delegate Impl (to be same as .Net)
+ * Uses genericised version code 
+ * Will need codegen support for casting invoke type
+ */
+
+package cobra.core;
+
+import java.lang.*;
+import java.io.*;
+import java.util.*;
+
+
+// Tmp placeholder
+public class DelegateO {
+    Delegate<Object> delTgt;
+    Class returnType;
+    
+    public DelegateO(Class returnType, Class... paramTypes) {
+    //public Delegate(Class... paramTypes) {
+        this.delTgt = new Delegate<Object>(Object.class, paramTypes);
+        this.returnType = returnType;
+    }
+
+    public void init(Object target, String methodName){
+        this.delTgt.init(target, methodName);
+    }
+
+    public void init(Class targetClass, String methodName){
+        this.delTgt.init(targetClass, methodName);
+    }
+    public Object invoke(Object... arguments) {
+        return delTgt.invoke(arguments);
+    }
+
+    public void add(Object target, String methodName){
+        delTgt.add(target, methodName);
+    }
+    
+    public void remove(Object target, String methodName){
+        delTgt.remove(target, methodName);
+    }
+    
+    public void clear(){
+        delTgt.clear();
+    }
+}
+

Source/Cobra.Core/Java/Pair.java

@@ +1 @@
+/* 
+ *  Pair.java
+ *
+ *  Provides simple pair class hierarchy to satisfy RT requirements for compiler
+ *  Rough translation based on cobra implementation for .Net
+ */ 
+
+package cobra.core;
+import java.util.*;
+
+public class Pair<TA extends Comparable<Object>, TB extends Comparable<Object>>  extends BasePair 
+implements Iterable, Comparator<Pair<TA, TB>> { 
+
+    final TA a;
+    final TB b;
+
+/*  test
+        p = Pair<of int, int>(1, 2)
+        assert p.a == 1 and p.b == 2
+        assert p[0] == 1 and p[1] == 2
+        assert p.toString == 'Pair(1, 2)'
+        expect IndexOutOfRangeException, assert p[2] == 3
+*/
+    public Pair(TA a, TB b) {
+        super();
+        this.a = a;
+        this.b = b;
+    } 
+    
+    public Object getItem(int i) {
+        if (i == 0)
+            return a;
+    if (i == 1)
+            return b;
+    throw new IndexOutOfBoundsException("Index " + i + " is out of range for a pair (0-1).");
+    }
+
+    @Override
+    public String toString() {
+        String sa = CobraCore.toTechString(this.a);
+        String sb = CobraCore.toTechString(this.b);
+        return String.format("%s (%s, %s)", this.getClass().getName(), sa, sb);
+    }
+
+    //Comparator
+    public int compare(Pair<TA, TB> t, Pair<TA, TB> p) {
+        /* test
+        assert Pair<of String, int>('a', 3) < Pair<of String, int>('b', 4)
+        assert Pair<of int, int>(2, 3) > Pair<of int, int>(2, 2)
+        assert Pair<of String?, String?>(nil, 'a') < Pair<of String?, String?>(nil, 'b')
+        assert Pair<of int?, int?>(nil, nil) < Pair<of int?, int?>(1, 1)
+         */ 
+        int cmp = _compare(t.a, p.a);
+    if (cmp == 0)
+            cmp = _compare(t.b, p.b);
+    return cmp;
+    }
+    
+    public boolean equals(Pair<TA, TB> p) {
+    /*test
+        assert Pair<String>('a', 'b').equals(Pair<String>('a', 'b'))
+        assert Pair<String>('a', 'b').equals(Pair<String>('a', 'c'))
+         */ 
+    return p.a == this.a && p.b == this.b;
+    }
+    
+    //Comparable
+    public int compareTo(Pair<TA, TB> obj) {
+        if (obj == null) return 1;
+        if (obj == this) return 0;
+        if (obj.getClass() == this.getClass() ) {
+            int comp_a = this.a.compareTo(obj.a);
+            if (comp_a ==0 )
+                return this.b.compareTo(obj.b);
+            return comp_a;
+        }
+        return -1;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked") 
+    public boolean equals(Object obj) {
+        /*test
+            assert Pair<String, String>('a', 'b') == Pair<String, String>('a', 'b')
+        assert Pair<String, String>('a', 'b') <> Pair<String, String>('a', 'c')
+         */
+        if (obj == null)  return false;
+        if (obj == this)  return true;
+        if (obj.getClass() == this.getClass() ) {
+            Pair<TA,TB> p = (Pair<TA,TB>) obj;
+            return p.a == this.a && p.b == this.b;
+        }
+        return false;
+    }
+    
+    
+    @Override
+    public int hashCode() {
+    /*test
+        d = {
+            Pair<of int, String>(1, 'one'): 'one',
+            Pair<of int, int>(2, 2): 'two',
+            Pair<of dynamic, dynamic>(nil, nil): 'nil',
+        }
+        assert d[Pair<of int, String>(1, 'one')] == 'one'
+        assert d[Pair<of int, int>(2, 2)] == 'two'
+        assert d[Pair<of dynamic, dynamic>(nil, nil)] == 'nil'
+         */
+    // same as CobraCore.HashCodeUtils.combine( (this.a == null) ? 0  : this.a.hashCode(),
+        //                          (this.b == null) ? 0  : this.b.hashCode() );
+        int ha = ((this.a == null) ? 0  : this.a.hashCode());
+        int hb = ((this.b == null) ? 0  : this.b.hashCode());
+        int hc = 37;
+        hc = hc * 23 + ha;
+        hc = hc * 23 + hb;
+        return hc;
+    }
+    
+    public Iterator<?> iterator() {
+    /*test
+        assert (for s in Pair<of String, String>('a', 'b') get s) == ['a', 'b']
+         */ 
+        return new PairIterator();
+      }
+    
+    class PairIterator implements Iterator {
+        private int ofst =0;
+
+        public boolean hasNext() { 
+            return (this.ofst < 2); 
+        }
+
+        public Object next() {
+            Object ret;
+            switch (this.ofst) {
+                case 0: ret= a; break;
+                case 1: ret = b; break;
+                default:
+                    throw new NoSuchElementException("Pair: no element after .a and .b") ;
+            }
+            this.ofst++;
+            return ret;
+            
+        }
+        
+        public void remove() {
+            throw new UnsupportedOperationException("Pair: no remove operation");
+        }
+        
+    }        
+    
+}

Source/Cobra.Core/Java/CobraImp.java

@@ -2 +2 @@
  * CobraImp.java
  * Native java support code RTL
  *
- *  Currently only stubbed, minimal native code impl.
- * see also Cobra.Lang/NativeExtern.cobra
+ *  Currently only stubbed, minimal native code implementation.
  */
 package cobra.core;
 
 import java.lang.*;
 import java.util.*;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.io.IOException;
 
  
 public class CobraImp {
@@ -22 +25 @@
             return sb.toString();
         }
         public String makeString(String s) {
+            if (s == null) return "nil";
             return s;
         }
         public String makeString(int i) {
@@ -34 +38 @@
         
         public String makeString(Object... args) {
             StringBuilder sb = new StringBuilder();
-            for (Object arg : args)
-                sb.append(arg.toString());
+            for (Object arg : args) {
+                if (arg == null) 
+                    sb.append("nil");
+                else
+                    sb.append(arg.toString());
+            }
             return sb.toString();
         }
     }
+
     //static public StringMaker _printStringMaker = new StringMaker();
     static public SimpleStringMaker _printStringMaker = new SimpleStringMaker();
-    static public SimpleStringMaker _techStringMaker = new SimpleStringMaker();
-    
+    static public SimpleStringMaker _techStringMaker  = new SimpleStringMaker();
+
+    //static private Deque<PrintStream> _printToStack; 
+    // above is Stack<PrintStream> TODO: support as PrintWriter
+    static private Deque<Writer> _printToStack; 
+    static private PrintWriter outPW;
+    static private boolean _prtErr = false;
     static {
-        //  _printToStack = new Stack<TextWriter>();
-        //  PushPrintTo(Console.Out);
+        _printToStack = new ArrayDeque<Writer>(); 
+        outPW = new PrintWriter(System.out, true);  
+        pushPrintTo(outPW);
         //  _printStringMaker = new PrintStringMaker();
         //  _techStringMaker = new TechStringMaker();
         //  PromoteNumerics = NumericTypeInfo.PromoteNumerics;
         }
     
+    static public Writer getPrintDestination() {
+        return _printToStack.peek();
+    }
+
+    // Convenience for System.out
+    static public void pushPrintTo(PrintStream ps) {
+        Writer wr = new PrintWriter(ps, true);
+        pushPrintTo(wr);      
+    }
+    
+    static public void pushPrintTo(Writer wr) {
+    _printToStack.push(wr);
+    }
+
+    static public void popPrintTo() {
+    _printToStack.pop();
+    }
+
+    static public void reset() {
+    _printToStack.clear();
+    pushPrintTo(outPW);
+    }
+    
+    static public void reset(Writer printDestination) {
+    _printToStack.clear();
+    pushPrintTo(printDestination);
+    }
+    
     static public void printLine() {
-        //_printToStack.Peek().WriteLine();
-        System.out.println();
+        printLine("");
+        //_printToStack.peek().println();
+        //System.out.println();
     }
-
+        
+    // Convenience for System.out
+    static public void printLine(PrintStream ps, String s) {
+        Writer wr = new PrintWriter(ps, true);
+        printLine(wr, s);
+    }
+    
     static public void printLine(String s) {
-        //      _printToStack.Peek().WriteLine(s);
-        System.out.println(s);
+        printLine(_printToStack.peek(), s);
     }
+    static public void printLine(Writer wr, String s) {
+        // We do this manually rather than using a PrintWriter so we can support use of a StringWriter
+        // which (of course) doesnt support the useful things like print and println...
+        try {
+            wr.write(s);
+            wr.write(System.lineSeparator());
+            wr.flush();
+        }
+        catch(IOException ioe) {
+            _prtErr = true;
+        }
+        //_printToStack.peek().println(s);
+        //System.out.println(s);
+    }
 
     static public void printStop() {
     }
 
+    // Convenience for System.out
+    static public void printStop(PrintStream ps, String s) {
+        Writer wr = new PrintWriter(ps, true);
+        printStop(wr, s);
+    }
+    
     static public void printStop(String s) {
-        //      _printToStack.Peek().Write(s);
-        System.out.print(s);
+        printStop(_printToStack.peek(), s);
     }
+    
+    static public void printStop(Writer wr, String s) {
+        try {
+            wr.write(s);
+        }
+        catch(IOException ioe) {
+            _prtErr = true;
+        }
+            
+        //_printToStack.peek().print(s);
+        //System.out.print(s);
+    }
+    /*
+     * Check if a Print error (IOException on print) has ocurred.
+     */
+    static public boolean chkPrtError() {
+        return _prtErr;
+    }
 
+    /*
+     * Clear any print error setting, return the value that was set.
+     */
+    static public boolean clearPrtError() {
+        boolean r = _prtErr;
+        _prtErr = false;
+        return r;
+    }
+
+
+
     static public String makeString(String[] args) {
         return _printStringMaker.makeString(args);
     }
@@ -77 +174 @@
         return s;
     }
     
+    /*
+     * Convenience ctors for literal Lists, Sets and Dicts
+     */
     @SuppressWarnings("unchecked")
     static public <T> List<T> makeList(T... args) {
-    return new ArrayList<T>(Arrays.asList(args));
+    //return new ArrayList<T>(Arrays.asList(args));
+    return Arrays.asList(args);
     }
     
     /*
@@ -106 +207 @@
     return d;
     }
     
+    
+    
+    static public <T> T checkNotNull(T value, String msg)
+    {
+        // used for generic checking for non null arg, throws NPE if fails
+        // msg expected to contain info and name of item being checked.
+        if (/*cobra.core.CobraCore._willCheckNil && */ value == null) {
+           throw new NullPointerException(msg);
+        }
+        return value;
+    }
 
     static public <T> T checkNonNil(Object obj, String sourceCode, T value, /* SourceSite */ String fileName, int lineNum, String className, String memberName, Object thiss) 
     {
@@ -285 +397 @@
     
     static public boolean referenceEquals(Object o, Object o1) { return o == o1; }
     
+    static public boolean is(Object a, Object b) {
+    return CobraImp.referenceEquals(a, b);
+    }
+
+    static public boolean isNot(Object a, Object b) {
+            return !CobraImp.referenceEquals(a, b);
+    }
+
+    static public boolean is(Enum a, Enum b) {
+        if (a==null) return b==null;
+        if (b==null) return false;
+        //   return a.equals(b);
+        return a == b;  
+    }
     
+    /*
+     * ........ Support for inclusion testing: 'a in b' ................... 
+     */
+
+    static public boolean in(char a, String b) {
+    return b.indexOf(a) != -1;
+    }
+
+    static public boolean in(String a, String b) {
+    return b.indexOf(a) != -1;
+    }
+/*    static public boolean in(Object a, Collection b) {
+    return b.contains(a);
+    }
+
+    static public boolean in(Object a, Iterable b) {
+    for (Object item : b) {
+            if (item.equals(a) /*equals(item, a)* /)
+        return true;
+    }
+    return false;
+    }
+ */
+    
+    // Covers collections including enums via EnumSet
+    static public <T> boolean in(T a, Collection<T> b) {
+    return b.contains(a);
+    }
+
+    static public <T> boolean in(T a, Iterable<T> b) {
+    for (T item : b) {
+        if (item.equals(a) /* Equals(item, a) */)
+        return true;
+    }
+    return false;
+    }
+
+    static public <T> boolean in(T a, Map<T,?> b) {
+    return b.containsKey(a);
+    }
+
+/* LATER    static public <T> bool InWithNullCheck(T a, Predicate<T> predicate) {
+        if (a == null) return false;
+        return predicate(a);
+    }
+*/
+    static private boolean _noNestedIn = false;
+
+    static public boolean in(Object a, Object b) {
+        if (_noNestedIn)
+            throw new RuntimeException(String.format("_noNestedIn a=0$s, a.getClass=%1$s, b=%2$s, b.getClass=%3$s", 
+                a, a==null ? "" : a.getClass().getName(), 
+                b, b==null ? "" : b.getClass().getName() ) );
+    _noNestedIn = true;
+    try {
+        if (b instanceof Collection) {   // probably the most common case, check has to come before Iterable
+            return in(a, (Collection<?>)b);
+        } else if (b instanceof String) {
+            if (a instanceof String) {
+            return in((String)a, (String)b);
+            } if (a instanceof Character) {
+            return in( ((Character)a).charValue(), (String)b);
+            } else {
+            throw new CannotInTypeException(a, "a of `a in b`", a.getClass());
+            }
+        } else if (b instanceof Iterable) {
+            return in(a, (Iterable<?>)b);
+        } else if (b instanceof Map) {
+            return in(a, (Map<?,?>)b);
+        } else if (b instanceof Enum) {
+                    throw new RuntimeException("Cannnot test inclusion in an Enum, should be using EnumSet"); 
+        } else {
+            throw new CannotInTypeException(b, "b of `a in b`", b.getClass());
+        }
+    } finally {
+        _noNestedIn = false;
+    }
+    }
+    
+    // support for throws codegen and checked exception wrapping
+    static public RuntimeException reThrow(Exception e) {
+        if (e instanceof RuntimeException) return (RuntimeException)e;
+        return new CheckedExceptionWrapper("Wrapping rethrown exception", e);
+    }
 }
 

Source/Cobra.Core/Native.cs

@@ -326 +326 @@
         return false;
     }
 
+        static bool In(Object a, Enum b) {
+            Type et = b.GetType();
+            if (! Enum.IsDefined(et, a))
+                return false;
+            int v = Convert.ToInt32((Enum)a);
+            int v1 = Convert.ToInt32(b);
+            return (v1 & v) == v;
+        }
+        
     static public bool In<T>(T a, IList<T> b) {
         return b.Contains(a);
     }
@@ -364 +373 @@
                 return In(a, (IEnumerable)b);
             } else if (b is IDictionary) {
                 return In(a, (IDictionary)b);
+            } else if (b is Enum) {
+                return In(a, (Enum)b);
             } else {
                 throw new CannotInTypeException(b, "b of `a in b`", b.GetType());
             }

Tests/100-basics/307-enums.cobra

@@ +1 @@
+#.require. clr
 enum Medium
     of uint64
     air

Tests/100-basics/902-access.cobra

@@ +1 @@
+#.require. clr
+@platform clr
+
 # access System
 class Test
 

Tests/100-basics/900j-access.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+class Test
+
+    def main is shared
+        assert CobraCore.releaseNum > 0
+        assert CobraCore.version > CobraCore.toVersionNumber(0,0,0)
+        #print CobraCore.commandLineArgs.size
+        assert CobraCore.commandLineArgs.size == 1

Tests/100-basics/902j-access.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+
+# access System
+class Test
+
+    def main
+        is shared
+        
+        s as Java.Lang.Object = 'aoeu'
+        s = 'qwerty'
+        CobraCore.noOp(s)

Tests/100-basics/140-break.cobra

@@ +1 @@
+#.require. clr
+
 namespace Test
     
     class Test

Tests/100-basics/140j-break.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+
+namespace Test
+    
+    class Test
+        
+        def main
+            is shared
+                
+            x as int = 0
+            while x<10
+                if true, break
+                x += 1 # without 'if true' above java unreachable statement
+            assert x==0
+            
+            x = 1
+            for i as int in 1 : 10
+                if true, break
+                x = i
+            assert x==1
+            
+            s as String = 'a'
+            #l =['a', 'b']  # works
+            l = ArrayList<of String>()
+            l.add('a')
+            l.add('done')
+            for arg as String in l
+                CobraCore.noOp(arg)
+                if true, break
+                s = 'b'
+            assert s=='a'

Tests/100-basics/150j-continue.cobra

@@ +1 @@
+#.require. jvm
+# Modified for jvm for use of commandLine args and unreachable statement errors fm BackEnd 
+# on statements after a unconditional continue.
+
+namespace Test
+    
+    class Test
+        
+        def main
+            is shared
+                
+            count as int = 0
+            x as int = 0
+            while x<10
+                x += 1
+                if true, continue
+                count += 1 #unreachable statement
+            assert x==10
+            assert count==0
+            
+            x = 1
+            for i as int in 1 : 10
+                x = i
+                if true, continue
+                count += 1 #unreachable statement
+            assert x==9
+            assert count==0
+            
+            s as String = 'a'
+            for arg as String in CobraCore.commandLineArgs
+                CobraCore.noOp(arg)
+                s = 'b'
+                if true, continue
+                count += 1 #unreachable statement
+            assert s=='b'
+            assert count==0

Tests/100-basics/700j-print.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+
+class Test
+
+    def main
+        is shared
+        print 1
+        print 1, 2, 3
+        print 1 stop
+        print 2 stop
+        print 3
+        print to System.out, 1, 2, 3
+        print to System.out
+            print 123
+
+        sw as StringWriter = StringWriter()
+        print to sw, 1, 2
+        assert sw.toString.trim == '1 2'
+        assert sw.toString <> sw.toString.trim
+
+        sw = StringWriter()
+        print to sw, 1, 2 stop
+        assert sw.toString == '1 2'
+        assert sw.toString == sw.toString.trim
+        
+        sw = StringWriter()
+        print to sw     
+            print 'sw.'
+        assert sw.toString == 'sw.'+ System.lineSeparator

Tests/100-basics/200-try-raise.cobra

@@ -8 +8 @@
             x as int = 0
 
             try
-                throw Exception('')
-                x = 1
-            catch
-                pass
-            finally
-                x = 2
-            assert x==2
-
-            try
-                x = 1
-                throw Exception('')
-                x = 2
-            catch
-                pass
-            assert x==1
-
-
-            try
-                x = 0
-                throw Exception('')
-            catch e as Exception
-                x = 1
-            assert x==1
-
-
-            try
-                x = 0
-                throw Exception('')
-            catch nre as NullReferenceException
+                if true
+                    throw Exception('')
+                x = 1 # unreachable code without if above (jvm)
+            catch nre as NonNilCastException # Platform independent exception
                 CobraCore.noOp(nre)
                 x = 1
             catch

Tests/100-basics/150-continue.cobra

@@ +1 @@
+#.require. clr
 namespace Test
     
     class Test

Tests/100-basics/080j-inherits.cobra

@@ -17 +17 @@
             assert 5 inherits int  # .warning. always
             assert 5 inherits Object  # .warning. always
             assert not (5 inherits String)  # .warning. never
-            assert 5 inherits Integer  # .warning. always
+            assert 5 inherits Integer  # .warning. never
             
             assert true inherits bool  # .warning. always
             assert true inherits Object  # .warning. always

Tests/100-basics/900-access.cobra

@@ +1 @@
+#.require. clr
+@platform clr
 class Test
 
     def main is shared

Tests/100-basics/310j-enums-combine.cobra

@@ +1 @@
+enum Color
+    Red = 1
+    Green = 2
+    Blue = 4
+
+class Test
+
+    def main is shared
+        c = Color(Red, Green) # in java BE c is actually an EnumSet
+        print c
+        .takeColor(Color(Red, Green))
+        # TODO: Should have a qualified example. System.SomeEnum(MemberA, MemberB) and System.Something.SomeEnum(MemberA, MemberB)
+        
+        # testing enum membership with 'in' operator
+        assert Color.Red in c
+        assert Color.Green in c
+        assert Color.Blue not in c
+        assert not Color.Blue in c
+
+    def takeColor(c as Color) is shared
+        pass

Tests/100-basics/901j-access.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+# access System
+class Test
+
+    def main
+        is shared
+        
+        nl as String = System.lineSeparator
+        CobraCore.noOp(nl)
+        
+        nl1 = CobraCore.newLine
+        assert nl1 == System.lineSeparator

Tests/100-basics/903j-use-structs.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm
+
+namespace Test
+    class Test
+        def main
+            is shared
+            
+            #now as Date = Date() #DateTime.now
+            #assert now.year > 2000
+            now as Calendar = Calendar.getInstance
+            assert now.get(Calendar.YEAR) > 2000

Tests/100-basics/200j-try-raise.cobra

@@ +1 @@
+#.require. jvm
+# mods for unreachable code and using RuntimeException rather than Exception
+namespace Test
+
+    class Test
+
+        def main
+            is shared
+
+            x as int = 0
+
+            try
+                if true, throw RuntimeException('')
+                x = 1 # unreachable code
+            catch nre as NonNilCastException # Cobra RTL exception
+                CobraCore.noOp(nre)
+                x = 1
+            catch
+                x = 2
+            assert x==2
+
+            try
+                x = 0
+                throw RuntimeException('')
+            catch RuntimeException  # no variable
+                x = 1
+            assert x==1
+
+            loc as int
+            count as int
+
+            # rethrow an exception
+            try
+                loc = 1
+                try
+                    loc = 2
+                    throw RuntimeException('aoeu')
+                catch
+                    loc = 3
+                    throw
+            catch e as RuntimeException
+                loc = 4
+                assert e.message=='aoeu'
+            assert loc==4
+
+            # test that the "success" block executes when no exception is thrown
+            try
+                loc = 1
+                count = 1
+            catch
+                loc = 2
+                count += 1
+            success
+                loc = 3
+                count += 1
+            assert loc==3
+            assert count==2
+
+
+            # test the the "catch" block does not execute when no exception is throwd
+            try
+                loc = 1
+                count = 1
+            catch
+                loc = 2
+                count += 1
+            success
+                loc = 3
+                count += 1
+            finally
+                loc = 4
+                count += 1
+            assert loc==4
+            assert count==3
+
+
+            # test that the "success" block does not execute when an exception is throwd
+            try
+                loc = 1
+                count = 1
+                throw RuntimeException('')
+            catch
+                loc = 2
+                count += 1
+            success
+                loc = 3
+                count += 1
+            assert loc==2
+            assert count==2
+
+
+            # just for the heck of it
+            try
+                pass
+            catch
+                pass
+            success
+                pass
+            finally
+                pass
+
+            # this actually failed code gen at one point
+            try
+                pass
+            success
+                pass
+            finally
+                pass
+
+            # test that `success` and `finally` execute even with a `return` in the try part
+            .reset
+            .returnInTry
+            assert not _didCatch and _didSuccess and _didFinally
+
+            # test that `finally` executes even with an exception
+            .reset
+            expect RuntimeException, .throwInSuccess
+            assert not _didCatch and _didSuccess and _didFinally
+
+        var _didCatch as bool is shared
+        var _didSuccess as bool is shared
+        var _didFinally as bool is shared
+        
+        def reset is shared
+            _didCatch = _didSuccess = _didFinally = false
+
+        def returnInTry is shared
+            try
+                return  # test that a return statement here doesn't side-step `success` or `finally`
+            catch
+                _didCatch = true
+                throw
+            success
+                _didSuccess = true
+            finally
+                _didFinally = true
+
+        def throwInSuccess is shared
+            try
+                pass
+            success
+                _didSuccess = true
+                throw Exception('aoeu')  # test that an exception here doesn't side-step `finally`
+            finally
+                _didFinally = true

Tests/100-basics/334a-enums-comma.cobra

@@ +1 @@
+# comma sep syntax, platform independant inclusion test
+enum Color
+    Red = 1, Green = 2,
+    Blue = 4
+
+class Test
+
+    def main is shared
+        c = Color(Red, Green)
+        print c
+        .takeColor(Color(Red, Green))
+        # TODO: Should have a qualified example. System.SomeEnum(MemberA, MemberB) and System.Something.SomeEnum(MemberA, MemberB)
+        
+        # testing enum membership with 'in'
+        assert Color.Red in c
+        assert Color.Green in c
+        assert Color.Blue not in c
+        assert not Color.Blue in c
+
+    def takeColor(c as Color) is shared
+        pass

Tests/100-basics/700-print.cobra

@@ +1 @@
+#.require. clr
+@platform clr
+
 class Test
 
     def main

Tests/100-basics/310-enums-combine.cobra

@@ +1 @@
+#.require. clr
+@platform clr
+
 enum Color
     Red = 1
     Green = 2

Tests/100-basics/901-access.cobra

@@ +1 @@
+#.require. clr
+@platform clr
 # access System
 class Test
 

Tests/100-basics/903-use-structs.cobra

@@ +1 @@
+#.require. clr
+@platform clr
+
 namespace Test
     class Test
         def main

Tests/100-basics/300-enums.cobra

@@ +1 @@
+#.require. clr
+@platform clr
+# This test of enums as value types is specific to the .Net environment
+# other platforms treat enums differently.
 enum Colors
     Red
     Green

Tests/100-basics/334-enums-comma.cobra

@@ -1 @@
-# comma sep syntax
+#.require. clr
+@platform clr
+# comma seperated syntax
 enum Color
     Red = 1, Green = 2,
     Blue = 4
@@ -8 +10 @@
     def main is shared
         c = Color(Red, Green)
         print c
-        print c to int
+        print c to int # non portable - assumes Enums castable to int
         .takeColor(Color(Red, Green))
         # TODO: Should have a qualified example. System.SomeEnum(MemberA, MemberB) and System.Something.SomeEnum(MemberA, MemberB)
         
-        # testing enum membership with bitwise-and
+        # testing enum membership with bitwise-and (also int centric)
         assert c & Color.Red == Color.Red
         assert c & Color.Green == Color.Green
         assert c & Color.Blue <> Color.Blue