Ticket #275: java-jvm-part2.patch

Source/BackEndJvm/JvmJarSig.cobra

@@ +1 @@
+# Java back end
+# Responsible for turning a jarfile name into an object holding a description/signature of
+# the jarfile contents suitable for reflecting on - this is roughly similar to a .Net Assembly.
+
+# Supporting this requires delving through java jar files and obtaining class info which we cant easily 
+# do in a .Net program
+# so until we have a java implementation of the cobra compiler we instead rely on a java helper program
+# (see pkgSig.java and pkgSig.class, pkgSig.jar in the cobra distribution)
+
+# This is expected to have been run and creates what we call a pkgSignature file (pkgSig File) that is 
+# named the same as a jarfile (or the same as a java package) with a '.sig' extension' and
+# contains an easily parseable text description of the classes and interfaces in the jarfile or package
+# this sigfile is expected to be in an obvious place, currently the cwd or same place as the cobra compiler executable....
+#
+# e.g. 'rt.jar' (java runtime classes) has a sigfile 'rt.jar.sig'
+#   'java.lang' (java package) has a sigfile 'java.lang.sig'
+
+class JarSig
+    
+    var name = '' # jarfile or pkg
+    var location = '' # abs pathname of sigFile
+    var _javaTypes as List<of JavaClassType> # lists of classes, interfaces or Enums in this jarfile or pkg
+    
+    shared
+        var classByNameCache = Dictionary<of String, JavaClassType>()
+            """All classes found in all jars keyed by canonical/full name."""
+                
+        def lookupClass(fullName as String) as JavaClassType
+            """ Lookup class by full/canonicalName."""
+            if not JarSig.classByNameCache.containsKey(fullName)
+                if fullName.startsWith(r'['),     .addArrayClass(fullName)
+                else if fullName.contains(r'<'),  .addGenericInstClass(fullName)
+                else if not fullName.contains('.'), .addGenericParamClass(fullName)
+                else
+                    print 'Dbg:JarSig.lookupClass - unknown class:[fullName]'
+            #print 'Lookup class', fullName
+            return JarSig.classByNameCache[fullName]
+                    
+        def addArrayClass(aName as String)
+            """Array classes are synthesized on reference assuming element class already exists."""
+            print 'Dbg crt ArrayClass "[aName]"'    
+            elName = aName.replace(r'[','') 
+            branch elName
+                on 'Z', elName = 'boolean'
+                on 'B', elName = 'byte'
+                on 'I', elName = 'int'
+                on 'S', elName = 'short'
+                on 'J', elName = 'long'
+                on 'C', elName = 'char'
+                on 'D', elName = 'double'
+                on 'F', elName = 'float'
+                else 
+                    if elName.startsWith('L') and elName.endsWith(';')
+                        elName = elName[1:-1] # e.g. Ljava.lang.Integer;
+                    else 
+                        print 'Unknown arrayName [elName]'  
+                        assert false, 'arrayName [elName]'
+            if not JarSig.classByNameCache.containsKey(elName)
+                print 'Dbg: class "[elName]" not in classByNameCache "[aName]"'     
+            #elType = JarSig.classByNameCache[elName]
+            elType = JarSig.lookupClass(elName)
+            arrayCls = JavaClassType(aName, elType) # ArrayType
+            JarSig.classByNameCache[aName] = arrayCls
+            print 'Dbg: added ArrayOf_[elName] "[aName]"'   
+        
+        def addGenericInstClass(fullName as String)
+            """
+            Generic class being instantiated.
+                e.g. com.x.MyClass<com.x.Inst, java.lang.String>
+            Synthesized (here) as a result of being referenced.
+            """
+            print 'Dbg crt GenericInstClass "[fullName]"' 
+            assert fullName.contains('<') and fullName.endsWith('>')
+            canonName = fullName.beforeL('<')
+            assert canonName.contains('.')
+            idx = canonName.lastIndexOf('.')
+            gName = canonName[idx+1:]
+            pkg = canonName[0:idx]
+            paramTypes = fullName.afterL('<')[0:-1] # drop end '>'
+            print 'Dbg: GenericInstanceClass "[pkg]" "[gName]" "[paramTypes]'   
+            giCls = JavaClassType(gName, pkg, paramTypes)
+            JarSig.classByNameCache[fullName] = giCls
+            # JarSig.registerClassType(pkg, giCls)  
+            print 'Dbg: added GenericInstanceClass "[fullName]"'    
+                
+        def addGenericParamClass(name as String)
+            print 'Dbg crt Generic Param Class "[name]"' 
+            gparamCls = JavaClassType(name, JavaType.GenericParam, '')
+            JarSig.classByNameCache[name] = gparamCls
+            print 'Dbg: added Generic Parameter Class "[name]"'     
+                
+    def sigFile(name as String) as String is shared
+        """ 
+        Check that a sig file exists for the given name (jarfile or pkgname).
+        Return the sig filename if found, InvalidOperationException if not
+        """
+        assert not name.endsWith('.sig')    
+        sigFile =  name + '.sig'
+        if File.exists(sigFile)
+            fileName = sigFile
+            #if not Path.IsPathRooted(sigFile)
+            #   fileName = Path.getFullPath(sigFile)
+        else
+            ccPath = Path.getDirectoryName(CobraCore.exePath) to !
+            absName =  Path.combine(ccPath, sigFile)
+            if File.exists(absName)
+                fileName = absName
+            else
+                throw InvalidOperationException('Cannot find a PkgSig file for "[name]" ("[sigFile]") in cwd or [ccPath].')
+        return fileName
+                    
+    cue init(jarName as String)
+        base.init
+        .name = jarName
+        _javaTypes = List<of JavaClassType>()
+        _genTypesList
+        _aliasPrimitives
+
+    def _genTypesList
+        jarName = if(.name.endsWith('.sig'), .name[:-4], .name)
+        fileName = JarSig.sigFile(jarName)
+        .location = fileName
+        desc = List<of String>()
+        for line in File.readAllLines(fileName)
+            if line.trim.startsWith('#'), continue
+            if line.length == 0 
+                if desc.count == 0, continue
+                jct = JavaClassType.makeFromDesc(desc)
+                _registerClassType(jct)
+                desc.clear
+                continue
+            desc.add(line)
+        
+        if desc.count >0
+            jct = JavaClassType.makeFromDesc(desc)
+            _registerClassType(jct)
+            
+    def _registerClassType(jct as JavaClassType)
+        _javaTypes.add(jct)
+        canonName = jct.canonicalName
+        if '`' in canonName # jct.isGeneric
+            canonName = canonName.beforeL('`')
+            #parts = canonName.split('`')
+            #canonName = parts[0]   
+        JarSig.classByNameCache[canonName] = jct
+            
+    def _aliasPrimitives
+        if JarSig.classByNameCache.containsKey('void')
+            return
+        # ['void', 'boolean','byte', 'short', 'int', 'long', 'float', 'double']
+        JarSig.classByNameCache['void']    = JarSig.classByNameCache['java.lang.Void'] 
+        JarSig.classByNameCache['boolean'] = JarSig.classByNameCache['java.lang.Boolean'] 
+        JarSig.classByNameCache['char']    = JarSig.classByNameCache['java.lang.Character'] 
+        JarSig.classByNameCache['byte']    = JarSig.classByNameCache['java.lang.Byte'] 
+        JarSig.classByNameCache['short']   = JarSig.classByNameCache['java.lang.Short'] 
+        JarSig.classByNameCache['int']     = JarSig.classByNameCache['java.lang.Integer'] 
+        JarSig.classByNameCache['long']    = JarSig.classByNameCache['java.lang.Long'] 
+        JarSig.classByNameCache['float']   = JarSig.classByNameCache['java.lang.Float'] 
+        JarSig.classByNameCache['double']  = JarSig.classByNameCache['java.lang.Double'] 
+
+        
+                
+    def getExportedTypes as JavaClassType*
+        return _javaTypes
+        
+    def toString as String is override
+        """ For testing dump rep of jarSig"""
+        sb = StringBuilder('[.name]: ')
+        sb.append(' [_javaTypes.count] types')
+        return sb.toString
+    
+#
+# Below are classes describing JavaTypes (class), JavaFields, Java Ctors and JavaMethods    
+# They are temporary placeholders until can get a native implementation and direct access to Java RTL equivalents.
+
+enum JavaType
+    NoType, JavaClass, JavaInterface, JavaEnum, GenericParam
+    
+
+class JavaClassType     # Simplified System Type for java classes, interface, enum
+    """ Descriptor for a java class - equivalent of java.lang.Class for cobra in .Net"""
+    shared 
+        var emptyClassList  = List<of JavaClassType>()
+        var _emptyFieldList = List<of JavaFieldInfo>()      
+        var _emptyCtorList  = List<of JavaCtorInfo>()   
+        var _emptyMethodList = List<of JavaMethodInfo>()        
+        var _emptyStringList = List<of String>()        
+    
+        def genClassTypeList(names as List<of String>)  as List<of JavaClassType>
+            """ Generate JavaClassType List for list of names."""
+            classList = List<of JavaClassType>()
+            for name in names
+                cls = JarSig.lookupClass(name)
+                classList.add(cls)
+            return classList
+    
+        
+    var name = ''
+    var package = ''
+    var type = JavaType.NoType #class,interface, enum
+    var superclass = ''
+    var modifiers as List<of String>
+    var interfaceNames as List<of String>
+    var _interfaces as List<of JavaClassType> = JavaClassType.emptyClassList
+
+    var _fields as List<of JavaFieldInfo> = JavaClassType._emptyFieldList   # JavaFieldInfo*
+    var _props as List<of JavaFieldInfo>  = JavaClassType._emptyFieldList   # JavaFieldInfo*
+    var _ctors as List<of JavaCtorInfo>   = JavaClassType._emptyCtorList    # JavaCtorInfo*
+    var _methods as List<of JavaMethodInfo> = JavaClassType._emptyMethodList # JavaMethodInfo*
+
+    # TODO split these out as subclass
+    var _isGenericDefn = false  
+    var _isGenericInst = false  
+    var _isGenericParam = false 
+    var _genParamNames as List<of String> = JavaClassType._emptyStringList
+    var _genParams as List<of JavaClassType> = JavaClassType.emptyClassList # generic params list
+    set genParamNames from var
+    
+    var _isArray  = false   
+    var _arrayDimension = 0 
+    var _arrayComponentType as JavaClassType? = nil
+
+    def makeFromDesc(descriptor as List<of String>) as JavaClassType is shared
+        """
+        Generate a populated JavaClassType from a string descriptor.
+        
+        Descriptor entry for a Type (as per pkgSig output), single entry per line ( or '-' ),
+        entries nl terminated
+        
+            <Type> <absolute classname>
+                <Type> # Class, Interface or Enum
+                <Pkg>
+                <Name> #simple Name
+                <absolute superclass name>
+                <absolute interface names implemented>  #comma separated
+                <modifiers>  # spc separated 'static', 'default', 'public', 'protected'
+                var <name>  # 0 or more fields 
+                    <modifiers>
+                    <full TypeName>
+                    <attributes>
+                ... 
+                ctor <absClassName> # 0 or more constructors
+                    <paramList> # comma sep list of typeNames
+                ... 
+                method name # 0 or more methods
+                    modifiers
+                    returnType
+                    paramList
+                    throwsList
+                    ...                 
+        Descriptor is parsed and info and various field, ctor, method and property lists populated.
+        """
+        
+        fieldList = List<of JavaFieldInfo>()
+        propList = List<of JavaFieldInfo>()
+        props = Dictionary<of String, JavaFieldInfo>() # cache for inferred propertyNames
+        ctorList = List<of JavaCtorInfo>()
+        methodList = List<of JavaMethodInfo>()
+        
+        lines = descriptor
+        assert lines.count >= 7
+
+        # header - fixed length and format; absName, type, pkg, name, superclass, interfacesList, ModifiersList
+        absName  = _popTop(lines)   # absolute class name
+        CobraCore.noOp(absName)
+        branch _popTop(lines).toLower
+            on 'class',     type = JavaType.JavaClass
+            on 'interface', type = JavaType.JavaInterface
+            on 'enum',      type = JavaType.JavaEnum
+            else, type = JavaType.NoType
+        pkg  = _popTop(lines)
+        name = _popTop(lines)
+        isGen = name.contains('`')
+        super = _popTop(lines)
+        if super == '-', super = ''
+        interfaces = _parseList(_popTop(lines), [c','])
+        modifiers  = _parseList(_popTop(lines), [c' '])
+        if isGen, gParamNames = _parseList(_popTop(lines), [c','])
+        while true
+            et = _popTop(lines)
+            if et.length == 0, break
+                
+            if et.startsWith('var ')
+                varName = et[3:].trim
+                field =  JavaFieldInfo()
+                field.name = varName
+
+                assert lines.count >= 2     
+                # procField(et, subline, field, fieldList)
+                field.modifiers = _parseList(_popTop(lines), [c' '])
+                field.typeName = _popTop(lines)
+                if type == JavaType.JavaEnum 
+                    field.value = _popTop(lines)    
+                #field.attributes = _parseList(_popTop(lines), [c','])
+                fieldList.add(field)
+
+            else if et.startsWith('ctor ')
+                ctorName = et[4:].trim
+                ctor = JavaCtorInfo()
+                ctor.name = ctorName
+                assert lines.count >= 1     
+                ctor.paramNames = _parseList(_popTop(lines), [c','])
+                # attributes ??
+                ctorList.add(ctor)
+                
+            else if et.startsWith('method ')
+                methodName = et[6:].trim
+                if methodName.endsWith(r'[V]') # hack encoding flags
+                    methodName = methodName[:-3]
+                    isVari = true
+                method = JavaMethodInfo()
+                method.name = methodName
+                method.modifiers = _parseList(_popTop(lines), [c' '])
+                method.returnTypeName = _popTop(lines)
+                assert method.returnTypeName <> '-'
+                method.paramNames = _parseList(_popTop(lines), [c',']) 
+                method.throwsList = _parseList(_popTop(lines), [c',']) 
+                # attributes ??
+                if isVari,  method.attributes = ['IsVari']
+                methodList.add(method)
+
+                # map method getters and setters to property
+                propName = .chkForProp(methodName, method)
+                if propName
+                    _genProp(method, propName, propList, props)
+            else 
+                print 'Unknown item in class: [et]'
+
+        jct = JavaClassType(name, pkg, type, super, interfaces, modifiers)
+        if isGen, jct.genParamNames = gParamNames
+        jct._fields = fieldList
+        jct._props  = propList
+        jct._ctors  = ctorList
+        jct._methods = methodList
+        return jct
+            
+    def _parseList(et as String, seps as List<of char> ) as List<of String> is shared
+        if et == '-'
+            l = List<of String>()
+        else
+            l = et.split(seps.toArray).toList   
+        return l
+    
+    def _popTop(content as List<of String>) as String is shared 
+        while true
+            if content.count == 0
+                return ''
+            e = content[0]
+            content.removeAt(0)
+        
+            if e.trim.startsWith('#')   # commentline
+                continue
+            idx = e.indexOf('#')    # trailing comment
+            if idx >= 0 
+                e = e[:idx] 
+                e = e.trimEnd to !
+                if not e.length, continue
+            break
+        return e.trim
+        
+    # property: get<Propname> and no paramList and returnType is Property Type or
+    #           is<PropName> and no paramList and returnType is bool
+    #       and  set<PropName> and 1 parameter (value to set) 
+    def chkForProp(methodName as String, method as JavaMethodInfo) as String? is shared
+        tag = methodName[:3] 
+        if  tag in [ 'get', 'set'] and methodName.length > 3 and method.modifiers.contains('public')
+            if tag == 'set' and method.paramNames.count <> 1        # setXXXX without a single param
+                return nil
+            return methodName[3:]
+        if methodName.startsWith('is') and method.paramNames.count == 0 and method.returnTypeName == 'boolean' and method.modifiers.contains('public')
+            return methodName[2:]
+        return nil  
+            
+    # indexer: get<Propname> and has params  -  first param in paramList is index  (retType is Property Type)
+    #     or  set<PropName> and more than value in paramList, 1st parameter is index and second is value to set.
+    def isIndexer(methodName as String, method as JavaMethodInfo, isSetProp) as bool is shared
+        if methodName.startsWith('is')
+            return false
+        assert methodName.startsWith('get') or methodName.startsWith('set')
+        isGetProp = not isSetProp
+        return  (isGetProp and method.paramNames.count) or (isSetProp and method.paramNames.count > 1)
+
+    def _genProp(method as JavaMethodInfo, propName as String, propList as List<of JavaFieldInfo>, props as Dictionary<of String, JavaFieldInfo>) as JavaFieldInfo is shared
+        """ Create or update property fm getter/setter method and update given List and Dict. """
+        assert method.name.startsWith('get') or method.name.startsWith('set') or method.name.startsWith('is')   
+        isSetProp = method.name.startsWith('set')
+        isGetProp = not isSetProp
+        #print method.name, propName
+        if props.containsKey(propName)
+            prop = props[propName]
+        else # no existing property
+            prop = JavaFieldInfo() # JavaPropInfo
+            prop.name = propName
+            prop.isProp = true
+            prop.isIndexer = .isIndexer(method.name, method, isSetProp)
+            prop.isReadable = prop.isWritable = false
+            props[propName] = prop
+            propList.add(prop)  
+            method.prop = prop
+            #print '-- new Prop'
+        if isGetProp 
+            prop.isReadable = true
+            prop.getter = method
+            if not prop.typeName.length and method.returnTypeName.length, prop.typeName = method.returnTypeName
+            #prop.name0 = method.name
+            #print '-- isGetProp'
+        else #isSetProp 
+            prop.isWritable = true
+            prop.setter = method
+            #print '-- isSetProp'
+            if not prop.typeName.length and method.paramNames.count, prop.typeName = method.paramNames[0]
+        if not prop.modifiers.count or not prop.modifiers[0].length, prop.modifiers = method.modifiers
+        if not prop.attributes.count,    prop.attributes = method.attributes
+        assert prop.name.length
+        assert prop.typeName.length
+        return prop
+            
+    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>"""
+        base.init
+        assert not name.contains(".")
+        .name = name
+        .package = pkg
+        .type = type
+        .superclass = super
+        .interfaceNames = ifcs
+        .modifiers = modifiers
+    
+        _isGenericDefn = name.contains('`')  # Generic types have name suffix  `<nGenericArgs>
+        
+        #print '[type] [pkg].[name]'
+        assert .name.length
+        assert .type <> JavaType.NoType
+        if .type == JavaType.JavaClass and .canonicalName <> 'java.lang.Object' 
+            assert '.' in .superclass # canonical form
+        assert .package.length
+        
+    cue init(name as String, elementType as JavaClassType)
+        """Create an ArrayType."""
+        base.init
+        .name = name
+        .package = elementType.package
+        .type = JavaType.JavaClass
+        .superclass = 'java.lang.Object' # not really - closest is javax.openmanagment.mbean.ArrayType
+            # maybe should fake up an Abstract ArrayBaseType providing methods, etc synthesized below
+        .modifiers = elementType.modifiers
+        .interfaceNames = JavaClassType._emptyStringList
+        
+        _isArray = true
+        _arrayComponentType = elementType
+        _arrayDimension = name.count(c'[')
+        
+        # has properties 'length' and method 'getLength' and indexer for get and set
+        methodList = List<of JavaMethodInfo>()
+        method = JavaMethodInfo()
+        method.name = 'getLength'
+        method.modifiers = ['public']
+        method.returnTypeName = 'int'
+        method.paramNames =  JavaClassType._emptyStringList
+        methodList.add(method)
+    
+        propList = List<of JavaFieldInfo>()
+        prop = JavaFieldInfo()
+        prop.name = 'length'
+        prop.typeName = 'int'
+        prop.modifiers = ['public']
+        prop.isProp = true
+        prop.isIndexer = false
+        prop.isReadable = true
+        method.prop = prop
+        prop.getter = method
+        prop.isWritable = false
+        propList.add(prop)  
+    
+        idxr = JavaFieldInfo()
+        idxr.name = r'[]'
+        idxr.typeName = name.replace(r'[', r'')
+        idxr.modifiers = ['public']
+        idxr.isProp = true
+        idxr.isIndexer = true
+        idxr.isReadable = true
+        idxr.isWritable = true
+        # TODO getter return type same as typeName
+        # TODO setter params List 'int' 
+        propList.add(idxr)  
+        
+        _props  = propList
+        _methods = methodList
+
+        assert .name.length
+        assert .type <> JavaType.NoType
+        if .type == JavaType.JavaClass and .canonicalName <> 'java.lang.Object' 
+            assert '.' in .superclass # canonical form
+        assert .package.length
+
+        assert _arrayDimension >0
+        assert _arrayComponentType
+        assert .name.contains(r'[')
+    
+    cue init(name as String, pkg as String, paramTypes as String)
+        """Create a Generic Instantiation Type. Like MyClass<java.Lang.String>"""
+        base.init
+        print 'JavaClassType.init([name])'
+        assert not name.contains('.')
+        #assert pkg.contains('.')
+        gPart = '[pkg].[name]'
+        paramList = JavaClassType._parseList(paramTypes, [c','])
+        print 'Looking for Generic Class [gPart]'
+        genType = JarSig.lookupClass(gPart)
+        assert genType.isGenericTypeDefinition
+
+        .name = name
+        .package   = pkg # genType.package
+        .type      = genType.type
+        .superclass = genType.canonicalName  # not really but thats how we'll fake it
+        #.superclass = 'java.lang.Object' 
+        .modifiers = genType.modifiers
+        .package   = genType.package
+        _isGenericInst = true
+    
+        .interfaceNames = JavaClassType._emptyStringList
+        _genParamNames= paramList
+    
+        #print '[type] [pkg].[name]'
+        assert .name.length
+        assert .type <> JavaType.NoType
+        assert '`' in .superclass # fake parentage to the Generic Definition
+        assert .package.length
+    
+    cue init(name as String, jType as JavaType, pkg as String)
+        """Create a Generic Parameter Type. Like the T of MyClass<T>"""
+        base.init
+        assert jType == JavaType.GenericParam 
+        assert not name.contains("<") and not name.contains(">")
+        assert not name.contains(".")
+        #assert name[0].isUpper # ??
+        
+        .name = name
+        .type      = jType
+        .superclass = 'java.lang.Object' # not really but thats how we'll fake it
+        .package   = pkg
+        if not .package.length, .package = 'java.lang'
+        .modifiers = ['public']
+            
+        _isGenericParam = true
+    
+        .interfaceNames = JavaClassType._emptyStringList
+    
+        #print '[type] [pkg].[name]'
+        assert .name.length
+        assert .type <> JavaType.NoType
+        assert 'Object' in .superclass 
+        assert .package.length
+        
+
+    #pro name from var 
+    #pro package from var
+    # ...
+
+    get canonicalName as String
+        """package and name"""
+        assert .name.length
+        return if(.package.length, '[.package].[.name]', .name)
+
+    get isClass as bool
+        return .type == JavaType.JavaClass
+        
+    get isInterface as bool
+        return .type == JavaType.JavaInterface
+        
+    get isEnum as bool
+        return .type == JavaType.JavaEnum
+        
+    get isNested as bool
+        #return .flags.contains('N')
+        return .name.contains('$')  and not .name.startsWith('$') # temporary hack
+    
+    get declaringType as JavaClassType?
+        if .isNested
+            assert .name.contains('$')
+            declName = .name.beforeL('$')
+            #idx = .name.indexOf('$') 
+            #declName = .name[:idx] 
+            trace declName
+            # return JarSig.classByNameCache[declName]
+            return JarSig.lookupClass(declName)
+        return nil
+        
+    get isPublic
+        return .modifiers.contains('public')
+    get isProtected
+        return .modifiers.contains('protected')
+    get isPrivate
+        return .modifiers.contains('private')
+    get isDefault
+        return .modifiers.contains('default')   # = protected + package
+    get isStatic
+        return .modifiers.contains('static')
+    get isFinal # sealed 
+        return .modifiers.contains('final')
+    get isAbstract
+        return .modifiers.contains('abstract')
+
+    def getSuperClass as JavaClassType?
+        if not .superclass.length
+            return nil
+        #return  JvmNativeType(_type.getSuperClass)
+        if JarSig.classByNameCache.containsKey(.superclass)
+            return JarSig.lookupClass(.superclass)
+            #return JarSig.classByNameCache[.superclass]
+        else 
+            #return JarSig.classByNameCache['java.lang.Object']
+            return JarSig.lookupClass('java.lang.Object')
+            # e.g. Abstract base classes with default access - java.lang.AbstractStringBuilder  
+        #else 
+        #   synth = SyntheticObject(.superclass)
+        #   JarSig.classByNameCache[.superclass] = synth
+        #   return synth
+                
+    get isValueType as bool
+        return false    # TODO true for unboxed primitives...
+
+    # TODO hops array handling
+    get isArray as bool
+        return _isArray 
+
+    get arrayComponentType as JavaClassType?
+        #if not .isArray, return nil
+        assert .isArray
+        print 'JavaClassType Array support NYI [.canonicalName]'
+        return _arrayComponentType
+
+    get arrayDimension as int
+        require .isArray
+        assert _arrayDimension > 0
+        return _arrayDimension
+    
+    # TODO hops Generics handling
+    # Two forms of Generic Types: Definition ( MyClass<T>) and Instantiation ( MyClass<java.lang.String>)
+    # In java with runtime generic Type instantiation all we see from the jarfile directly are definitions (:-(
+    # Walking the classes and getting the class(names) referenced (params, intefaces, returnTypes,...)
+    # gives us the names of the instantiations which we synthesize as Types or Params for our purposes...
+
+    get isGenericType as bool
+        return _isGenericDefn or _isGenericInst or _isGenericParam
+        
+    get genericArgsCount as int
+        assert .isGenericType
+        #return _genArgNames.count # number of Generic args associated with this Generic Type
+        # We use dotNet naming here where generic (defn) classes are named with trailing '`<nTypeParams>'
+        if _isGenericDefn
+            parts = .name.split(c'`')
+            return int.parse(parts[1])
+        else if _isGenericInst
+            return _genParamNames.count
+        else    
+            return 0
+            
+    get isGenericParameter as bool 
+        """
+        assumes generic parameters are instantiated as Types.
+        Things like T,U,E,.. - basically simple names not package specified - probably 1 Upcase char 
+        """
+        return _isGenericParam
+    
+    get isGenericTypeDefinition as bool
+        """ 
+        Can use this generic type to create new types if this type is a template form.
+        e.g myClass<T, U> defn allows creating new type like MyClass<String, int>
+        """
+        assert  .isGenericType
+        return _isGenericDefn
+            
+    def getGenericArguments as JavaClassType* #List<of JavaClassType>
+        assert .genericArgsCount
+        if false # tmp pending jarSig gen and loading of generic args list
+            assert _genParamNames.count
+        if _genParamNames.count and not _genParams.count 
+            _genParams = JavaClassType.genClassTypeList(_genParamNames) 
+        return _genParams
+    
+        
+    def getInterfaces as JavaClassType* #List<of JavaClassType>
+        if .interfaceNames.count and not _interfaces.count 
+            _interfaces = JavaClassType.genClassTypeList(.interfaceNames)   
+        return _interfaces
+        
+    def getFields as JavaFieldInfo*
+        return _fields
+
+    def getConstructors as JavaCtorInfo*
+        return _ctors
+        
+    def getMethods as JavaMethodInfo*
+        return _methods
+            
+    def getProperties as JavaFieldInfo*
+        return _props
+            
+    def getAnnotations as IList<of dynamic>
+        # TODO when store annotations in .sigfile - return as a list of classes
+        #return List<of JavaClassType>()
+        return @[] to IList<of dynamic>
+        
+        
+    get fields from var
+    get props  from var
+    get ctors  from var
+    get methods from var
+
+    #dbg
+    def toMinString as String
+        return '[.type] [.canonicalName]'
+        
+    def toString as String is override
+        sb = StringBuilder()
+        sb.append('[.type] [.canonicalName]')
+        if _genParamNames.count
+            sb.append('<')
+            sep = ''
+            for pName in _genParamNames
+                sb.append(sep)
+                sb.append(pName)
+                sep = ','
+            sb.append('>')
+        sb.append(' ')
+        if .modifiers.count     
+            sb.append('is ')
+            sb.append(.modifiers.join(','))
+            sb.append(' ')
+        if .superclass.length
+            sb.append('inherits [.superclass] ')
+        if .interfaceNames.count
+            sb.append('implements ')
+            sb.append(.interfaceNames.join(','))
+        #sb.append(String.format(' -- {0} fields {1} props {2} ctors {3} methods', _fields.count, _props.count, _ctors.count, _methods.count))
+        return sb.toString
+        
+    def dumpFields
+        for field in .getFields
+            print field
+        
+    def dumpCtors
+        for ctor in .getConstructors
+            print 'ctor ', ctor.toString
+
+    def dumpMethods
+        for mthd in .getMethods
+            print mthd
+            
+    def dumpProps
+        for prop in .getProperties
+            print prop
+        
+    def dumpIndexers
+        assert false, 'Indexers NYI'
+    
+class JavaMemberInfo
+    var name = ''   
+    var _attributes as List<of String>?
+    var modifiers = List<of String>() # public, default (=protected+pkg), protected, private
+
+    pro attributes
+        get 
+            if not _attributes 
+                _attributes = List<of String>()
+            return _attributes
+        set 
+            _attributes = value
+    
+    get isPublic
+        return .modifiers.contains('public')
+    get isProtected
+        return .modifiers.contains('protected')
+    get isPrivate
+        return .modifiers.contains('private')
+    get isDefault
+        return .modifiers.contains('default')   # = protected + package
+    get isStatic
+        return .modifiers.contains('static')
+    get isFinal
+        return .modifiers.contains('final')
+    get isAbstract
+        return .modifiers.contains('abstract')
+
+    get isOverride
+        # in java this is an annotation (at best), - via pkgSig treated as strings      
+        return .attributes.contains('Override')
+
+    get isNonNullable
+        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' 
+        #       return true
+        #return false
+    
+    get isVari
+        """
+        VarArgs arglist to a a method. 
+        Java sets this as a flag on the method but we convert it to a faked attribute on the methodInfo
+        """
+        return .attributes.contains('IsVari') 
+    
+class JavaFieldInfo inherits JavaMemberInfo  
+    """Info for fields and properties."""
+    var typeName = ''
+    var value = ''      # pkgsig set value if final and initted
+    var isProp = false
+    var isIndexer = false
+    var isReadable = true
+    var isWritable = true
+    var getter as JavaMethodInfo?
+    var setter as JavaMethodInfo?
+    #var name0 = '' # original name before tweaked for propertyname
+    var _type as JavaClassType?
+    
+    get type as JavaClassType
+        assert .typeName.length
+        if .typeName.length and not _type
+            #_type = JarSig.classByNameCache[.typeName]
+            _type = JarSig.lookupClass(.typeName)
+        return _type to !   
+
+    def getValue as Object # ??
+        return .value
+    
+    def getIndexParameters as List<of JavaClassType>
+        """ List of Types for indexes for an indexer Property."""
+        if not .isIndexer
+            return JavaClassType.emptyClassList
+        assert .getter
+        return .getter.getParameters    
+        #if .setter
+        #   pars =  List<of JavaClassType(.setter.getParameters)
+        #   pars.removeAt(pars.count-1) # last is value to set
+        #   return pars
+        
+    def toString as String is override
+        prefix = 'var'
+        if .isProp
+            if .isReadable and .isWritable, prefix = 'pro'
+            else if .isReadable, prefix = 'get'
+            else if .isWritable, prefix = 'set'
+
+        sb = StringBuilder('[prefix] [.name]')
+        if .typeName.length, sb.append(' as [.type]')
+        if .modifiers.count 
+            sb.append(' is ')
+            sep=''
+            for mod in .modifiers
+                sb.append(sep)
+                sep =','
+                sb.append(mod)
+        # TODO attributes
+        if .isProp
+            sb.append(' { ')
+            if .getter
+                sb.append('getter [.getter.name], ')
+            if .setter
+                sb.append('setter [.setter.name]')
+            sb.append(' }')
+        return sb.toString
+    
+class JavaCtorInfo inherits JavaMemberInfo
+    var paramNames = List<of String>() 
+    var _params = JavaClassType.emptyClassList
+    
+    def getParameters as List<of JavaClassType>
+        if .paramNames.count and not _params.count 
+            _params = JavaClassType.genClassTypeList(.paramNames)   
+        return _params
+            
+        
+    def toString as String is override
+        sb = StringBuilder(.name)
+        if .paramNames.count and .paramNames[0].length
+            sb.append('(')
+            sep=''
+            for p in .paramNames
+                sb.append(sep)
+                sep =', '
+                sb.append(p)
+            sb.append(')')
+        # TODO attributes
+        return sb.toString
+        
+class JavaMethodInfo inherits JavaCtorInfo
+    var returnTypeName = ''
+    var throwsList = List<of String>() # list of String
+    var prop as JavaFieldInfo? # if this is a get or set method for a prop refer to the property
+
+    def returnType as JavaClassType?
+        if not .returnTypeName.length
+            return nil
+        #return JarSig.classByNameCache[.returnTypeName]
+        return JarSig.lookupClass(.returnTypeName)
+
+    def getGenericArguments as List<of JavaClassType>
+        return JavaClassType.emptyClassList # TODO: support generics
+                
+    def toString as String is override
+        nampar = base.toString
+        sb = StringBuilder('def [nampar] ')
+        if .returnTypeName.length
+            sb.append('as [.returnTypeName] ')
+        if .modifiers.count 
+            sb.append('is ')
+            sep=''
+            for mod in .modifiers
+                sb.append(sep)
+                sep =','
+                sb.append(mod)
+        if .prop
+            getset = .name[:3]          
+            sb.append(" {[getset]ter for prop '[.prop.name]'} ")
+        if .throwsList.count
+            sb.append(' #throws')
+            sep=''
+            for thrw in .throwsList
+                sb.append(sep)
+                sep =','
+                sb.append(thrw)
+                
+        # TODO attributes
+        return sb.toString
+    
+    

Source/BackEndJvm/JvmJarSigTest.cobra

@@ +1 @@
+# standalone test for jvmJarSig class
+
+# compile with      cobra -d JvmJarSigTest.cobra JvmJarSig.cobra
+#
+class JvmJarSigTest
+    
+    def main
+        expect InvalidOperationException
+            failPkgFile = JarSig('doWhakkaDay')
+            CobraCore.noOp(failPkgFile)
+        .simple1
+        .simple2
+
+        .pkgFile
+        .cmdline
+
+    def cmdline
+        if CobraCore.commandLineArgs.count > 1
+            pkgFile = CobraCore.commandLineArgs[1]
+            js = JarSig(pkgFile)
+            print js.toString
+            #print 'JarSig name:', js.name
+            for jc in js.getExportedTypes
+                print jc.toMinString
+                #print jc.toString
+            
+    def simple1
+        #Empty class
+        # how about supporting a multiline string???
+        simple = 'com.hops.Mpt\n    Class\n    com.hops\n    Mpt\n    com.hops.AlsoMpT\n    -\npublic static\n\n'
+        jc = JavaClassType.makeFromDesc(simple.split(c'\n').toList)
+        .chkType(jc, 'com.hops.Mpt', 'Mpt', 'com.hops', 'com.hops.AlsoMpT', JavaType.JavaClass, [ 'public', 'static'], List<of String>())
+        
+        assert jc.isClass
+        assert not jc.isInterface
+        assert not jc.isEnum
+        assert jc.fields.count == 0
+        assert jc.ctors.count == 0
+        assert jc.methods.count == 0
+        assert jc.props.count == 0
+        
+    def chkType(jc as JavaClassType, canonicalName as String, name as String, pkg as String, superclass as String, type as JavaType, modifiers as List<of String>, interfaces as List<of String>)
+        assert jc.canonicalName == canonicalName
+        assert jc.name == name
+        assert jc.package == pkg
+        assert jc.superclass == superclass
+        assert jc.type == type
+        assert jc.interfaces.count == interfaces.count
+        for ifc in jc.interfaces
+            assert interfaces.contains(ifc)
+        assert jc.modifiers.count == modifiers.count
+        for m in jc.modifiers
+            assert modifiers.contains(m)
+
+    def simple2
+        # how about supporting a multiline string???
+        desc = [
+            'com.hops.Simple',
+            '   Class',
+            '   com.hops',
+            '   Simple',
+            '   com.hops.SimpleBase',
+            '    -              # no interfaces',
+            '   public',
+            '   ctor com.hops.Simple',
+            '       java.lang.String',
+            '   var count',
+            '       default',
+            '       int',
+            '   method toString',
+            '       public                         # modifiers',
+            '       java.lang.String               # returnType',
+            '       -                              # no parameters',
+            '       -                              # no exceptions',
+            '   method getNameStr',
+            '       public                         # modifiers',
+            '       java.lang.String               # returnType',
+            '       -                              # no parameters',
+            '       -                              # no exceptions',
+            '   method setNameStr',
+            '       public                         # modifiers',
+            '       void                           # returnType',
+            '       java.lang.String               # parameters',
+            '       -                              # no exceptions',
+            '   method setFoo',
+            '       public                         # modifiers',
+            '       void                           # returnType',
+            '       java.lang.String               # parameters',
+            '       -                              # no exceptions',
+        ]
+        jc = JavaClassType.makeFromDesc(desc)
+        .chkType(jc, 'com.hops.Simple', 'Simple', 'com.hops', 'com.hops.SimpleBase', JavaType.JavaClass, [ 'public'], List<of String>())
+        
+        assert jc.isClass
+        assert not jc.isInterface
+        assert not jc.isEnum
+        
+        assert jc.fields.count == 1
+        assert jc.fields[0].name == 'count' 
+        assert jc.fields[0].type == 'int'   
+        assert jc.fields[0].modifiers.count == 1
+        assert jc.fields[0].modifiers[0] in ['default']
+        #jc.dumpFields
+
+        assert jc.ctors.count == 1
+        assert jc.ctors[0].paramList.count == 1
+        assert jc.ctors[0].paramList[0] == 'java.lang.String'
+        #jc.dumpCtors
+        
+        assert jc.methods.count == 4
+        assert jc.methods[0].name == 'toString' 
+        assert jc.methods[0].returnType == 'java.lang.String'   
+        assert jc.methods[0].modifiers[0] == 'public'   
+        assert jc.methods[1].name == 'getNameStr'   
+        assert jc.methods[2].name == 'setNameStr'   
+        assert jc.methods[3].name == 'setFoo'   
+        #jc.dumpMethods
+        
+        assert jc.props.count == 2
+        assert jc.props[0].name =='NameStr'
+        assert jc.props[1].name =='Foo'
+        #jc.dumpProps
+        
+    def pkgFile
+        expect InvalidOperationException
+            js = JarSig('noJarSigFile')
+            
+        # requires file 'jarSigTestFile1.sig' 
+        pkgFile = 'jarSigTestFile1'
+        js = JarSig(pkgFile)
+        assert js.name == 'jarSigTestFile1'
+        assert JarSig.sigFile(js.name) == 'jarSigTestFile1.sig'
+        
+        expTypes = for jct in js.getExportedTypes get jct
+        assert expTypes.count == 3
+    
+        for jct in expTypes
+            assert jct.name in ['AbstractMethodError','Appendable','Thread$State']
+    

Source/BackEndJvm/jarSigTestFile1.sig

@@ +1 @@
+# Class paths and boot paths being searched
+#   C:\Program Files\Java\jre6\lib\resources.jar
+#   C:\Program Files\Java\jre6\lib\rt.jar
+#   C:\Program Files\Java\jre6\lib\sunrsasign.jar
+#   C:\Program Files\Java\jre6\lib\jsse.jar
+#   C:\Program Files\Java\jre6\lib\jce.jar
+#   C:\Program Files\Java\jre6\lib\charsets.jar
+#   C:\Program Files\Java\jre6\lib\modules\jdk.boot.jar
+#   C:\Program Files\Java\jre6\classes
+# jarfile=C:\Program Files\Java\jre6\lib\resources.jar
+# jarfile=C:\Program Files\Java\jre6\lib\rt.jar
+# jarfile=C:\Program Files\Java\jre6\lib\jsse.jar
+# jarfile=C:\Program Files\Java\jre6\lib\jce.jar
+
+java.lang.AbstractMethodError
+    class                          # Type
+    java.lang                      # package
+    AbstractMethodError            # name
+    java.lang.IncompatibleClassChangeError # superclass
+    -                              # no interfaces
+    public                         # modifiers
+    ctor java.lang.AbstractMethodError
+        -                              # no parameters
+    ctor java.lang.AbstractMethodError
+        java.lang.String               # parameters
+
+java.lang.Appendable
+    Interface                      # Type
+    java.lang                      # package
+    Appendable                     # name
+    -                              # superclass
+    -                              # no interfaces
+    public                         # modifiers
+    method append
+        public                         # modifiers
+        java.lang.Appendable           # returnType
+        java.lang.CharSequence         # parameters
+        java.io.IOException            # exceptions
+    method append
+        public                         # modifiers
+        java.lang.Appendable           # returnType
+        java.lang.CharSequence, int, int # parameters
+        java.io.IOException            # exceptions
+    method append
+        public                         # modifiers
+        java.lang.Appendable           # returnType
+        char                           # parameters
+        java.io.IOException            # exceptions
+
+java.lang.Thread$State
+    Enum                           # Type
+    java.lang                      # package
+    Thread$State                   # name
+    java.lang.Enum                 # superclass
+    -                              # no interfaces
+    static public                  # modifiers
+    var NEW
+        static public                  # modifiers
+        java.lang.Thread$State
+    var RUNNABLE
+        static public                  # modifiers
+        java.lang.Thread$State
+    var BLOCKED
+        static public                  # modifiers
+        java.lang.Thread$State
+    var WAITING
+        static public                  # modifiers
+        java.lang.Thread$State
+    var TIMED_WAITING
+        static public                  # modifiers
+        java.lang.Thread$State
+    var TERMINATED
+        static public                  # modifiers
+        java.lang.Thread$State
+    method values
+        static public                  # modifiers
+        [Ljava.lang.Thread$State;      # returnType
+        -                              # no parameters
+        -                              # no exceptions
+    method valueOf
+        static public                  # modifiers
+        java.lang.Thread$State         # returnType
+        java.lang.String               # parameters
+        -                              # no exceptions
+

Source/BackEndJvm/JvmType.cobra

@@ +1 @@
+# NativeType wrapper for Java Classes
+
+# Eventually will use/handle java native classes but pending that and while cross compiling
+# wrap a JavaClassType (declared in JvmJarSig.cobra)
+
+class JvmNativeType inherits NativeType
+
+    var _type as JavaClassType
+    #var _type as java.lang.Class
+    
+    #cue init(type as java.lang.Class)
+    cue init(type as JavaClassType)
+        base.init
+        _type = type
+
+    def equals(other as Object?) as bool is override
+        if other is this
+            return true
+        if other inherits JvmNativeType
+            return .backEndType == other.backEndType
+        else
+            return false
+
+    def getHashCode as int is override
+        return .backEndType.getHashCode
+
+    get backEndType as JavaClassType
+        return _type
+
+    get name as String is override
+        #return _type.getSimpleName
+        return _type.name
+
+    get fullName as String is override
+        return _type.canonicalName
+
+    get isValueType as bool is override
+        #return _type.isValueType # fix for char, int, bool, long  etc vs Boxed Classes
+        return false
+        
+    get baseType as NativeType? is override
+        super = _type.getSuperClass
+        if not  super, return nil
+        return JvmNativeType(super)  # cache?
+        #if(_type.superclass.length, JvmNativeType(_type.superclass), nil)
+
+    def customAttributes as IList<of dynamic> is override
+        return .backEndType.getAnnotations #to IList<of dynamic>
+        
+    get isSystemObjectClass as bool is override
+        return /#_type and #/ .fullName == 'java.lang.Object'
+        
+    get isSystemTypeClass as bool is override
+        return /# _type and #/ .fullName == 'java.lang.Class'
+        
+        
+class JvmTypeProxy inherits NativeTypeProxy
+    """
+    Acts as an ITypeProxy where the Jvm type is known.
+    Typically used when scanning DLLs.
+    """
+
+    shared
+        var _cobraNameForJvmGenericNameCache = Dictionary<of String, String>()
+
+        def cobraNameForJvmType(jvmType as JavaClassType) as String
+            """
+            Returns 'Foo' for 'Foo' and 'Foo<of,>' for 'Foo<T,T1>'
+            Converts generic and non-generic classes and interfaces.
+            Does *not* work for arrays, etc.
+            """
+            name = jvmType.name
+            if not jvmType.isGenericType or jvmType.isGenericParameter
+                return name
+            if _cobraNameForJvmGenericNameCache.containsKey(name)
+                return _cobraNameForJvmGenericNameCache[name]
+            else
+                count = jvmType.genericArgsCount
+                assert count >0
+                cobraName = name + '<of'
+                for i in count-1, cobraName += ','
+                cobraName += '>'
+                _cobraNameForJvmGenericNameCache[name] = cobraName
+                return cobraName
+                
+        def cobraNameForJvmBoxName(name as String) as String
+            """
+            Assunmed we've mangled java generics typenames a la .Net ( i.e TypeName`<nGenericTypeParams>) 
+            Returns 'Foo' for 'Foo' and 'Foo<of,>' for 'Foo`2'
+            Works on generic and non-generic classes, structs and interfaces.
+            Does *not* work for arrays etc.
+            """
+            if '`' not in name, return name
+            if _cobraNameForJvmGenericNameCache.containsKey(name)
+                return _cobraNameForJvmGenericNameCache[name]
+            else
+                parts = name.split(c'`')
+                count = int.parse(parts[1])
+                cobraName = parts[0] + '<of'
+                for i in count-1, cobraName += ','
+                cobraName += '>'
+                _cobraNameForJvmGenericNameCache[name] = cobraName
+                return cobraName
+            
+                
+    var _jvmType as JavaClassType
+
+    cue init(nativeType as NativeType)
+        .init((nativeType to JvmNativeType).backEndType)
+
+    cue init(jvmType as JavaClassType)
+        base.init
+        _jvmType = jvmType
+
+    def addMinFields
+        base.addMinFields
+        .addField('jvmType', _jvmType)
+
+    get realType as IType is override
+        return _realTypeWithCache(_jvmType)
+
+    def _realTypeWithCache(jvmType as JavaClassType) as IType
+        t = (.compiler to Compiler).typeForJvmType(jvmType)
+        if t is nil
+            t = _realTypeWithoutCache(jvmType, 0)
+            (.compiler to Compiler).addTypeForJvmType(t to !, jvmType)
+        return t to !
+
+    def _realTypeWithoutCache(jvmType as JavaClassType, level as int) as IType
+        assert .compiler.basicTypes.count > 9   # should have bool, char, all the ints, etc.
+        
+        # Must return the Cobra primitive types in place of System.Boolean, System.Char, System.Int16, etc.
+        # because it's the primitives that are used all over the compiler.
+        jvmPrimitiveToIType = .compiler.primitiveToITypeCache
+        if jvmPrimitiveToIType is nil or jvmPrimitiveToIType.count == 0
+            _initPrimToITypeCache
+            jvmPrimitiveToIType = .compiler.primitiveToITypeCache
+            assert jvmPrimitiveToIType is not nil and jvmPrimitiveToIType.count <> 0
+        basicType as IType?
+        if jvmPrimitiveToIType.tryGetValue(jvmType, out basicType)
+            return basicType to !
+        
+        # handle wrapped types, like arrays, with recursive calls
+        if jvmType.isArray
+            #assert jvmType.name.endsWith(r'[]') # could be [,] so TODO: handle multidim arrays
+            return .typeProvider.arrayType(_realTypeWithCache(jvmType.arrayComponentType to !))
+        else if jvmType.isNested and not jvmType.isGenericParameter
+            declaringType = _realTypeWithCache(jvmType.declaringType to !)
+            potential = declaringType.memberForName(jvmType.name)
+            if potential is nil
+                .throwError('Cannot locate nested Jvm type "[jvmType]" (simple name is "[jvmType.name]").')
+            else if potential inherits IType
+                return potential
+            else
+                .throwError('Located Jvm type spec "[jvmType]" but got a [potential.englishName] instead of a type.')
+
+        # generic parameters
+        if jvmType.isGenericParameter
+            return GenericParam(JvmNativeType(jvmType))
+
+        typeName = _computeCobraTypeName(jvmType)
+        missing = false
+        curNS = _computeNameSpace(jvmType, level, out missing)
+        if missing
+            .throwError('Cannot find Jvm type "[jvmType.canonicalName]"  in package "[jvmType.package]".')
+            # since the type exists, but cannot be located in our namespaces,
+            # it must be pulled from a dependent DLL that was not directly referenced
+            # but maybe it was already attempted
+            #if level > 0, .throwError('Cannot read Jvm type "[jvmType.fullName]" or its package "[jvmType.package]". Please report to the Cobra discussion forums (http://cobra-language.com/).')
+
+            #(.compiler to dynamic).jvmReadAssembly(clrType.assembly)
+            #return _realTypeWithoutCache(jvmType, level+1) # recurse. guard is just above.
+
+        # return namespace member
+        member as IMember? = curNS.declForName(typeName)
+        if member inherits IType
+            if member inherits Box
+                if jvmType.isGenericType and not jvmType.isGenericTypeDefinition
+                    # So we have something like ICollection<of KeyValuePair<of TKey,TValue>> which is all Generic types.
+                    # We need the Cobra types of those args so we can construct the Cobra type from the generic cobra type
+                    # otherwise, we would just end up returning the generic definition.
+                    print 'Dbg: JvmType.realTypeWithoutCache generic type [jvmType.canonicalName] [member.name].'
+                    #.throwError('TODO support for Generic Types in JvmType _realTypeWithoutCache')
+                    #member = _typeForArgsOfGeneric(jvmType, member)
+            return member
+        else
+            print '[typeName] not in [curNS.name] declsforName'
+            msg = 'Cannot locate jvm type "[jvmType]".'
+            if jvmType.package.length and jvmType.package.startsWith('java.lang')
+                if .compiler and .compiler.verbosity > 1, print msg
+                # TODO: .compiler.warning(msg)
+                return .compiler.objectType
+            else
+                .throwError(msg)
+        return .compiler.intType  # CC: to make C# code gen happy.
+    
+    def _initPrimToITypeCache
+        typeToIType = _makePrimitiveTypesDict
+        jvmPrimitiveToIType = Dictionary<of dynamic, IType>()
+        for key in typeToIType.keys
+            jvmPrimitiveToIType[key] = typeToIType[key]
+        (.compiler to Compiler).primitiveCache  = jvmPrimitiveToIType #to !
+
+    def _makePrimitiveTypesDict as IDictionary<of JavaClassType, IType>
+        primitiveToIType = Dictionary<of JavaClassType, IType>()
+        for bt in .compiler.basicTypes
+            if bt.systemAliasProxy
+                # lookup by qualified name (includes translation) and pull out (jvm) NativeType
+                key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to JvmNativeType).backEndType
+                primitiveToIType[key] = bt
+        assert primitiveToIType.count == 0 or primitiveToIType.count >=8
+        return primitiveToIType
+    
+        
+    def _computeCobraTypeName(jvmType as JavaClassType) as String
+        typeName = jvmType.name
+        if jvmType.isGenericType 
+            # generic like IComparable`1
+            assert r'[' not in typeName
+            typeName = .cobraNameForJvmType(jvmType)
+        else if not typeName[typeName.length-1].isLetterOrDigit
+            .throwError('Cannot locate JVM type "[jvmType.canonicalName]".')
+        return typeName
+
+    def _computeNameSpace(jvmType as JavaClassType, level as int, missing as out bool) as NameSpace
+        missing = false
+        if not jvmType.package.length, return .compiler.globalNS
+        nameParts = jvmType.package.split(c'.')
+        member = .compiler.globalNS.symbolForName(nameParts[0])
+        if member inherits NameSpace, curNS = member
+        else, missing = true
+        if not missing
+            i = 1
+            while i < nameParts.length
+                namePart = nameParts[i]
+                possible = curNS.declForName(namePart)
+                if possible is nil
+                    missing = true
+                    break
+                else if possible inherits NameSpace
+                    curNS = possible
+                else
+                    .throwError('Found "[namePart]" at component [i+1] of JVM type "[jvmType.canonicalName]", but it is a [possible.englishName].')
+                i += 1
+        return curNS    
+
+/#
+    def _typeForArgsOfGeneric(jvmType as JavaClassType, member as IType) as IType
+        args = List<of IType>()
+        for genArg in jvmType.getGenericArguments
+            args.add(_realTypeWithCache(genArg))
+        boxMember = member to Box
+        if boxMember.qualifiedName == 'System.Nullable<of>'
+            assert args.count == 1
+            member = .typeProvider.nilableType(args[0])
+        else
+            member = boxMember.constructedTypeFor(args)
+        return member   
+#/
+    def _typeForArgsOfGeneric(jvmType as JavaClassType, member as IType) as IType
+        args = List<of IType>()
+        for genArg in jvmType.getGenericArguments
+            args.add(_realTypeWithCache(genArg))
+        boxMember = member to Box
+        member = boxMember.constructedTypeFor(args)
+        return member   
+        

Source/BackEndJvm/TODO

@@ +1 @@
+= Java Backend Gen TODO =
+
+include-tests:no - remove Test invocation call
+
+
+fixup Object namespace for X-compile so items like System.Object are rooted off
+java.lang namespace ( rather than .Net system)
+    DONE  June-2011
+
+passthru compilation of *.java files 
+    - seems to work for single files But
+        - calc of main class fm passthru *.java files
+    
+computeOutName from name of main class (or first/only) class in file rather
+than permutation of input name
+    DONE 31-Jan-2011
+    
+
+cobra namespaces capitalized (as .Net) Java all lowercase
+    - convert namespaces in java code to lowcase
+    DONE 31-Jan-2011
+    
+
+java names lowcase 
+    method Names  - DONE 31-Jan-2011
+    var names - DONE 31-Jan-2011, corrected 10-Feb-2011 BoxField._backendName -> BoxField.{sharp,java}BackEndName
+    params
+    events
+    local variables
+    -> remove/reverse cobra conversion to upcase for C#/.Net
+        ( look for calls to .capitalized)       
+        DONE (I think)
+
+remove all uses of ClrNativeType in core compiler ( ->NativeType??)
+    Compiler/Enums/Types.cobra
+    DONE
+
+properties - pro/get/set
+    - auto convert to java getters/setters and map calls
+    - Whats the equiv for indexers
+        Look at Beans spec but otherwise use/convert to {get,set}Indexer method call.
+            <indexedT> getIndexer<T, indexedT>(T) and 
+                       setIndexer<T, indexedT>(T, indexedT)
+      DONE 
+                       
+Events
+    - auto add boiler plate for listener (de)registration
+        - event firing
+
+
+partial classes
+    Add extra phase to aggregate partial classes together into first Module
+    (Chk if cobra is doing sommat like this or relying on C# compiler)
+    
+Extensions
+    convert to static classes methods taking instance as first param
+    If lookup for name fails see if sig matches extension and remap call to extn static class method
+
+
+Parse error lines fm java giving source line, find (trailing comment) cobra
+line number and modify the java error msg line with the cobra lineno
+printing  that in any java error mesages so to relate the java error back 
+to the generating cobra code line.
+  - start with just spew the javac lines to output
+    - assemble into ErrorMessage Line and 'supporting lines associated with it - keeps error line count in sync
+    
+
+
+single file:
+    generate to java src files in namespace dir hier
+    compile to class file ( in class dir hier)
+    run class file
+ 
+If specify multiple files
+    generate thm all to java src in in namespace dir hier
+    compile to class files ( in class dir hier)
+    generate manifest file and generate classfiles to jar file
+    Leave jar file at root of hierarchy
+    
+
+ensure support ( as builtin alternative) for jikes compiler.
+        https://sourceforge.net/projects/jikes/files/Jikes/    
+
+
+add synonym for sharp''/sharp"" -> java''/java""
+    or general be''/be"" (for backend)
+
+
+see http://www.25hoursaday.com/CsharpVsJava.html
+
+java 'synchronized' (block is exact equivalent of C# 'lock' stmt.
+
+varargs 
+    'params' keyword in C# (qualifier to the last argument to the method which should be an array).
+    In Java, the same effect is achieved by appending the string "..." to the typename of the last argument to the method.
+    
+Attributes
+    C# extend Atttribute - metainfo also ([AttributeUsage(AttributeTargets.Class)])
+    java specify with @interface and Metainfo 
+        e.g @Documented //we want the annotation to show up in the Javadocs 
+            @Retention(RetentionPolicy.RUNTIME))
+
+Java has Set in its collections framework so use that instead of Cobra lib version.
+
+Cobra methods nonVirtual (C# not marked virtual) in java mark as final (Cannot redefine or override).
+
+out and inout (ref)
+        x as <Type>?  = nil
+        method(...., out x)  # def method(.... out x as <Type>)
+        # use X here
+    
+    becomes in java
+        Type x = nil
+        Object xRef = x
+        method(..., xRef)    // void method(..., xRef as Object) - inmethod xRef assigned to whatever x calculated as 
+        x = xRef
+        // use x here
+
+
+Cobra backend targetting stab language (explicitly) ??
+    backend 'stab-jvm'
+
+
+Decimal Type
+    Initially wrap it as new type thats is a Double with an associated DecimalFormatter
+    (giving same precision as .Net).
+    Calcs are all as doubles, toString uses formatter...
+     still get rounding error etc...
+     Decimal Type internally and emit as BigDecimal, trap math ops and map
+
+    Maybe easier to just default to Integer and ignore Decimal (initially)
+
+
+Add convenience methods to 
+    java.io.File for
+        remember
+            (Buffered)Reader(FileReader(File(path)           - read text 
+            (Buffered)InputStream(FileInputStream(File(path) - read bytestream
+                
+        static FileInputStream/FileOutputStream openRead/openWrite(String path)- r/w bytestream
+
+        static BufferedInputStream createRead(String path)  - open or create - bytes
+        static BufferedOutputStream createWrite(String path)  - open+truncate or create - bytes
+
+        static BufferedWriter createText(String path) - open or create Textfile for writing 
+        static BufferedReader openText(String path)  - open textfile for reading 
+
+        static byte[] readAllBytes(String path)
+        static String readAllText(String path)
+        static String[] readAllLines(String path)
+        static IEnumerable<of String> readLines(String path)
+
+
+= Issues =
+
+How support yield and conversion to enumerator/iterator?
+-------------------------------------------------------------------------
+
+Checked to Unchecked exceptions
+
+Fm http://www.mindview.net/Etc/Discussions/CheckedExceptions
+See also ExceptionChaining since JDK1.4
+
+ExceptionAdapter
+
+Here's a tool that I developed with the help of Heinz Kabutz.  It
+converts any checked exception into a RuntimeException while
+preserving all the information from the checked exception.
+
+import java.io.*;
+class ExceptionAdapter extends RuntimeException {
+  private final String stackTrace;
+  public Exception originalException;
+  public ExceptionAdapter(Exception e) {
+    super(e.toString());
+    originalException = e;
+    StringWriter sw = new StringWriter();
+    e.printStackTrace(new PrintWriter(sw));
+    stackTrace = sw.toString();
+  }
+  public void printStackTrace() { 
+    printStackTrace(System.err);
+  }
+  public void printStackTrace(java.io.PrintStream s) { 
+    synchronized(s) {
+      s.print(getClass().getName() + ": ");
+      s.print(stackTrace);
+    }
+  }
+  public void printStackTrace(java.io.PrintWriter s) { 
+    synchronized(s) {
+      s.print(getClass().getName() + ": ");
+      s.print(stackTrace);
+    }
+  }
+  public void rethrow() { throw originalException; }
+} 
+
+The original exception is stored in originalException, so you can
+always recover it.  In addition, its stack trace information is
+extracted into the stackTrace string, which will then be printed using
+the usual printStackTrace() if the exception gets all the way out to
+the console.  However, you can also put a catch clause at a higher
+level in your program to catch an ExceptionAdapter and look for
+particular types of exceptions, like this:
+
+catch(ExceptionAdapter ea) {
+  try {
+    ea.rethrow();
+  } catch(IllegalArgumentException e) {
+    // ...
+  } catch(FileNotFoundException e) {
+    // ...
+  }
+  // etc.
+}
+
+Here, you're still able to catch the specific type of exception but
+you're not forced to put in all the exception specifications and
+try-catch clauses everywhere between the origin of the exception and
+the place that it's caught.  An even more importantly, no one writing
+code is tempted to swallow the exception and thus erase it.  If you
+forget to catch some exception, it will show up at the top level.  If
+you want to catch exceptions somewhere in between, you can.
+
+Or, since originalException is public, you can also use RTTI to look
+for particular types of exceptions.
+
+Here's some test code, just to make sure it works (not the way I
+suggest using it, however):
+
+public class ExceptionAdapterTest {
+  public static void main(String[] args) {
+    try {
+      try {
+        throw new java.io.FileNotFoundException("Bla");
+      } catch(Exception ex) {
+        ex.printStackTrace();
+        throw new ExceptionAdapter(ex);
+      }   
+    } catch(RuntimeException e) {
+      e.printStackTrace();
+    }
+    System.out.println("That's all!");
+  }
+}
+
+By using this tool you can get the benefits of the unchecked exception
+approach (less code, cleaner code) without losing the core of the
+information about the exception.
+
+If you were writing code where you wanted to throw a particular type
+of checked exception, you could use (or modify, if it isn't already
+possible) the ExceptionAdapter like this:
+
+  if(futzedUp)
+    throw new ExceptionAdapter(new CloneNotSupportedException());
+
+This means you can easily use all the exceptions in their original
+role, but with unchecked-style coding.
+
+-------------------------------------------------------------------------
+I've managed to fiddle javac to not check exceptions anymore *evil
+grin*.
+
+Very simple really.  Add a directory java/lang to your project and
+copy into that directory Exception.java and RuntimeException.java
+
+Change Exception to extend RuntimeException and change
+RuntimeException to extend Throwable.
+
+Now the compile-time exception checking is turned off. 
+
+-- hops: Doesnt work unfortunately ---
+-------------------------------------------------------------------------
+
+
+
+
+
+-------------------------------------------------------------------------
+= Current compile cmd (X-compile) =
+
+cobra -back-end:jvm Name.cobra
+cobc0 -back-end:jvm -kif Name.cobra
+
+
+= MSW Default compiler cmd =
+File.cobra (containing class File)
+javac -cp '[CobraCore.exePath][pathSep]CobraLang.jar File.java
+javac -cp '../wkspace/Source/CobraLang.jar' File.java
+
+
+= MSW run cmd =
+java -cp ".;../wkspace/Source/CobraLang.jar" File
+
+
+= Other back ends =
+Fantom : compile to jvm or dotNet

Source/BackEndJvm/ScanJvmType.cobra

@@ +1 @@
+# Load Jvm references and libraries
+
+class Compiler is partial
+
+    #var _didLoadJars = Set<of String>()
+
+    var _didReadJars = Set<of String>()
+    
+    var _jvmTypeToType = Dictionary<of JavaClassType, IType>()
+    
+    var _jvmTypeCache = Dictionary<of String, JavaClassType>()
+    
+    
+    # Java specific Reference loading
+    def jvmLoadReference(reference as String) as bool
+        try 
+            return  __jvmLoadReference(reference)
+        catch fnfe as System.IO.FileNotFoundException
+            throw LoadReferenceException('FileNotFound', fnfe.fileName, fnfe.message)
+        catch fle as System.IO.FileLoadException
+            throw LoadReferenceException('FileLoadException', fle.fileName ? reference, fle.message)
+        catch fiop as InvalidOperationException
+            throw LoadReferenceException('InvalidOperationException', reference, fiop.message)
+            
+    def __jvmLoadReference(reference as String) as bool
+        # uses reference parameter
+        # compiler .referenceVerbosity
+        # fills .loadedReferences
+    
+        # Hopefully this is simpler than .Net case, look for reference which devolves to a pkgSig file
+        # in cwd or as abspathname or in cobra library-path settings.
+        # When running java native would probably also need to check the classpath
+        require
+            reference.endsWith('.jar')
+            reference not in ['.jar']
+        ensure
+            result implies .loadedReferences[.loadedReferences.count-1] == reference
+            not result implies .loadedReferences.count == old.loadedReferences.count
+        body
+            jarSig as JarSig? = nil
+            rv = .referenceVerbosity
+            assert not (reference.startsWith('-r') and '-r' in reference[2:])
+            sigFile =  reference + '.sig'
+            if rv, print 'Looking for sigfile("[sigFile]").'
+            sigFilePath = _lookForSigFile(sigFile, rv, reference)
+            if not sigFilePath
+                # eventually may also search CLASSPATH              
+                if rv, print 'Returning false for __jvmLoadReference("[reference]").'
+                return false 
+
+            if rv, print 'Will read jarsig: [sigFilePath]'
+            try
+                jarSig = JarSig(sigFilePath)
+            catch readExc as Exception
+                if rv, print 'Caught exception during jarSig creation: [readExc]'
+                throw
+            if rv
+                print 'Did find jarSig: [jarSig]'
+                print 'Will read jarsig contents: [jarSig]'
+            try
+                .javaReadJar(jarSig to !)
+            catch readExc as Exception
+                if rv, print 'Caught exception during javaReadJar: [readExc]'
+                throw
+            if rv, print 'Did read jar signature file: [jarSig]'
+            .loadedReferences.add(reference)
+            if rv, print 'Returning true for __jvmLoadReference("[reference]").'
+            return true
+        
+    def _lookForSigFile(sigFile as String, rv as int, reference as String) as String?
+        """Pathname to sigfile if found in cwd, abspath or in library-directory paths, nil otherwise."""
+        if File.exists(sigFile) # current directory or abspathname
+            if rv, print '"[reference]" found as file in [sigFile].'
+            return sigFile  
+        ccPath = Path.getDirectoryName(CobraCore.exePath) to !
+        absSigFile =  Path.combine(ccPath, sigFile)
+        if File.exists(absSigFile)
+            if rv, print '"[reference]" found as file in [absSigFile].'
+            return absSigFile   
+            
+        if rv, print 'File does not exist in std places. Searching library-directory setting'
+        searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
+        if not searchPaths.count
+            if rv, print 'No lib paths to search.'
+            return nil
+                
+        found = false
+        for searchPath in searchPaths
+            if rv,  print 'Checking lib path: "[searchPath]"'
+            combinedPath = Path.combine(searchPath, sigFile)
+            if File.exists(combinedPath)
+                if rv, print '"[reference]" found as file in [combinedPath].'
+                found = true
+                break
+                
+        if not found
+            if rv and searchPaths.count, print 'Did not find "[reference]" in lib paths'
+            return nil
+        return combinedPath
+
+    def javaReadJar(jSig as JarSig)
+        """
+        Reads the contents of a jar (actually JarSig) file so that they are accessible to the program.
+        """
+        if jSig.name in _didReadJars, return
+        _didReadJars.add(jSig.name)
+        verbosity = .verbosity
+        if verbosity
+            print 'Reading jar(sig):  [jSig.name]'  # extra space lines up with 'Loading reference:'
+            print '              at:  [jSig.location]'
+        namespaceQualNameToNameSpaceObject = Dictionary<of String, NameSpace>()
+        module = AssemblyModule(jSig.location, .globalNS)
+        saveModule, _curModule = _curModule, module
+        try
+            _modules.add(module)
+            for type in jSig.getExportedTypes
+                if type.isNested #or type.declaringType
+                    # these will be scanned by Box._scanNestedTypes
+                    # print '### skipping [type.name] in [type.namespace]. isNested=[type.isNested], declaringType=[type.declaringType]'
+                    continue
+                typeNamespace = type.package
+                if typeNamespace.length == 0
+                    # happens for classes etc. that are not declared in a namespace
+                    curNameSpace = module.topNameSpace
+                else
+                    namespaceName = typeNamespace
+                    if namespaceQualNameToNameSpaceObject.containsKey(namespaceName)
+                        curNameSpace = namespaceQualNameToNameSpaceObject[namespaceName]
+                    else
+                        curNameSpace = module.topNameSpace
+                        for name in typeNamespace.split(c'.')
+                            curNameSpace = curNameSpace.getOrMakeNameSpaceNamed(Token.empty, name)
+                            assert not curNameSpace.isUnified
+                        namespaceQualNameToNameSpaceObject[namespaceName] = curNameSpace
+                if verbosity >= 4
+                    print '  Reading type [type.name] in namespace "[namespaceName]"'
+                jvmType = JvmNativeType(type)
+                if curNameSpace.unifiedNameSpace.declForName(jvmType.name)
+                    .warning(CobraWarning('Already have declaration "[jvmType.name]" in namespace "[curNameSpace.fullName]".'))
+                else
+                    if type.isClass
+                        if type.name.startsWith('Extend_') and type.name.count(c'_') >= 2
+                            # e.g.Extend_String - TODO 
+                            curNameSpace.addDecl(Extension(jvmType, .backEnd))
+                        else
+                            curNameSpace.addDecl(Class(jvmType, .backEnd))
+                    else if type.isInterface
+                        curNameSpace.addDecl(Interface(jvmType, .backEnd))
+                    else if type.isEnum
+                        #print jvmType.name
+                        curNameSpace.addDecl(EnumDecl(curNameSpace, jvmType, type.modifiers, ''))  # TODO: isNames; docString?
+                    else if type.isValueType
+                        curNameSpace.addDecl(Struct(jvmType, .backEnd))
+                    else
+                        throw FallThroughException(type)
+        finally
+            _curModule = saveModule
+
+    def jvmFixNilableMemberSigs
+        # TODO: this really needs to go in a separate file that the compiler reads each time
+
+        # fix up member sigs regarding methods returning nilable values
+        # hard coded below. TODO: read from a Cobra config file
+        # _fix is defined in ScanClrType
+    
+        # These are just reflected over from the .Net ones since I dont know what the basis for inclusion is/was
+        
+        _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.String', 'padLeft padRight remove replace substring toLower toUpper trim')
+        #_fix('System.Type', 'assembly name toString')
+            # namespace can return nil if the Type is a generic parameter
+        #_fix('System.Environment', 'commandLine currentDirectory newLine version')
+        _fix('java.lang.Exception', 'message')
+        #_fix('System.Collections.Generic.IEnumerable<of>', r'getEnumerator')
+        #_fix('java.util.Enumeration<of>', r'getNext')
+        _fix('java.util.Iterator<of>', r'next')
+        _fix('java.util.ListIterator<of>', r'next previous')
+        _fix('java.util.Collection<of>', r'toArray')
+        
+        #_fix('System.Collections.Generic.List<of>', r'[]')
+        _fix('java.util.List<of>', r'[] get set remove')
+        _fix('java.util.AbstractList<of>', r'[] get set remove')
+        _fix('java.util.AbstractSequentialList<of>', r'[] get set remove')
+        _fix('java.util.ArrayList<of>', r'[] get set remove')
+        #_fix('java.util.CopyOnWriteArrayList<of>', r'[] get set remove')
+        #_fix('java.util.LinkedList<of>', r'[] get set remove element getFirst getLast peek peekFirst peekLast poll pollFirst pollLast pop removeFirst removeLast')
+        #_fix('java.util.Vector<of>', r'[] get set elementAt firstElement lastElement remove')
+        #_fix('java.util.Stack<of>', r'[] peek pop push')
+        
+        #_fix('System.Collections.Generic.IDictionary<of,>', r'[] keys values')
+        _fix('java.util.Map<of,>', r'[] get')
+        #    _fix('System.Collections.Generic.Dictionary<of,>', r'[]')
+        _fix('java.util.AbstractMap<of,>', r'[] get')
+        _fix('java.util.HashMap<of,>', r'[] get')
+        #_fix('java.util.ConcurrentHashMap<of,>', r'[] get')
+        #_fix('java.util.ConcurrentSkipListHashMap<of,>', r'[] get')
+        #_fix('java.util.EnumMap<of,>', r'[] get')
+        #_fix('java.util.IdentityHash<of,>', r'[] get')
+        #_fix('java.util.TreeMap<of,>', r'[] get')
+        #_fix('java.util.WeakHashMap<of,>', r'[] get')
+        _fix('java.util.Map.Entry<of,>', r'getKey getValue')
+        #_fix('java.util.AbstractMap.SimpleEntry<of,>', r'getKey getValue')
+        #_fix('java.util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue')
+        
+        #_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')
+        #_fix('System.IO.FileSystemInfo', 'name fullName')
+        #_fix('System.IO.TextWriter', 'newLine')
+        #_fix('System.IO.Path', 'combine getFullPath')
+        #   combine = File(strA, strB).getPath(), getFullPath = File().getAbsolutePath()
+        #_fix('java.lang.StringBuilder', 'toString') # ??
+        _fix('java.lang.Text.RegularExpressions.Regex', 'match replace')
+        _fix('System.Diagnostics.Process', 'processName')
+        
+        _fix('System.Reflection.Assembly', 'getEntryAssembly getExecutingAssembly location')
+        _fix('System.Reflection.MemberInfo', 'name')
+        _fix('System.Reflection.FieldInfo', 'fieldType')
+        _fix('System.Reflection.ParameterInfo', 'parameterType')
+        _fix('System.Reflection.PropertyInfo', 'propertyType')
+
+        # TODO: shouldn't need the following. see comment in _fixSubs
+        #_fix('System.IO.StringWriter', 'toString')
+
+    
+        
+    #
+    # Jvm Type Cache
+
+    def typeForJvmType(jvmType as JavaClassType) as IType?
+        """
+        Returns the Cobra type for a Java type if the Java type was previously scanned.
+        i.e this is access to the Java Type/Class cache.
+        """
+        return if(_jvmTypeToType.containsKey(jvmType), _jvmTypeToType[jvmType], nil)
+
+    def addTypeForJvmType(type as IType, jvmType as JavaClassType)
+        require .typeForJvmType(jvmType) in [nil, type]
+        _jvmTypeToType[jvmType] = type
+        
+    def jvmTypeByName(qualifiedName as String) as JavaClassType
+        """
+        Obtain the Jvm Type given by the fully qualified (cobra) name.
+        """
+        t as JavaClassType?
+        _jvmTypeCache.tryGetValue(qualifiedName, out t)
+        if t is nil
+            # TODO - lookup the JavaClassType by name.
+            t = JarSig.classByNameCache[qualifiedName]
+            _jvmTypeCache[qualifiedName] = t to passthrough  # "to passthrough" instead of "to !" to avoid non-nil check
+        return t to passthrough
+    
+    
+    def installJvmNativeMethods(box as Box, nativeType as NativeType) 
+        print '++ TODO scanJvmType.installJvmNativeMethods'
+/#
+        meths = List<of Method>()
+        _installClrNativeMethodsFrom('System', nativeType, nativeType, box, meths)
+        _installClrNativeMethodsFrom('System', ClrNativeType(System.Math.getType), nativeType, box, meths)
+
+        # the next statement can be problematic in that you have to add new DecimalTools methods in Snapshot just so the compiler can see them
+        # ultimately, extensions of primitive types should be supported
+        _installClrNativeMethodsFrom('CobraLangInternal', ClrNativeType(Cobra.Lang.DecimalTools.getType), nativeType, box, meths)
+
+         _printMethods(meths, box)
+        
+    def compareMethodNames(a as Method, b as Method) as int
+        return a.name.compareTo(b.name)
+        
+    def _printMethods(meths as IList<of Method>, box as Box)
+        # print out the methods, useful for documentation
+        print
+        print 'type', box.name
+        sharedMeths = for meth in meths where meth.isShared
+        if sharedMeths.count
+            sharedMeths.sort(ref .compareMethodNames)
+            print '    shared'
+            for meth in sharedMeths
+                print '        [meth.cobraSourceSignature(false)]'
+        objectMeths = for meth in meths where not meth.isShared
+        if objectMeths.count
+            objectMeths.sort(ref .compareMethodNames)
+            for meth in objectMeths
+                print '    [meth.cobraSourceSignature]'
+
+#/      
+
+
+class Box is partial
+
+    get _jvmType as JavaClassType
+        """
+        Returns the Jvm NativeType (System.Class eventually)) boxed in the .nativeType.
+        Throws exception rather than return nil.
+        """
+        return (.nativeType to JvmNativeType).backEndType
+
+    def isJvmSystemExceptionClass as bool
+        return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'java.lang'
+
+    def _scanNativeTypeJvm
+        """
+        Subclasses should invoke base and then invoke the various _scanXXX methods that are appropriate for them.
+        """
+        ensure not .needScanNativeType
+        _needScanNativeType = false
+        # print '<> _scanNativeType for [.name] in [_parentNameSpace.fullName], class is [.getType.name]'
+        
+    def _scanGenericArgsJvm
+        if _jvmType.isGenericType
+            for genArg in _jvmType.getGenericArguments
+                t = (.compiler to Compiler).typeForJvmType(genArg)
+                if t is nil
+                    t = GenericParam(JvmNativeType(genArg), parentDefinition=this)
+                    (.compiler to Compiler).addTypeForJvmType(t to !, genArg)
+                _genericParams.add(t)
+                
+    def _prepSystemObjectClassJvm
+        # map method getType to java getClass
+        # C#'s typeof(X) is X.getType in Cobra.
+        #existing = .declForName('getClass') to BoxMember
+        #overload = MemberOverload(existing)
+        #.registerOverload(overload)
+        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 = 'getClass' 
+        #meth.sharedMethodBackingIsAlias = true # not static
+        #overload.addMember(meth)
+        .addDecl(meth)
+                
+    def _scanJvmIsNames
+        # TODO
+        _isNames.add('extern')  # to make the box like the ones that were in SystemInterfaces.cobra
+
+    def _scanJvmImplements
+        for interf in _jvmType.getInterfaces
+            if not _badJvmRelatedType(interf)
+                _baseInterfaceProxies.add(JvmTypeProxy(interf))
+
+/#
+    def _scanJvmNestedTypes
+        # TODO: enable and fix resulting bugs
+        # for type in .clrType.getNestedTypes(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
+        for type in _jvmType.getNestedTypes
+            _scanJvmNestedType(type)
+        #for type in _clrType.getNestedTypes(BindingFlags(Static, DeclaredOnly, NonPublic))
+        for type in _jvmType.getNestedTypes
+            if type.isEnum and not type.isPublic
+                _scanJvmNestedType(type)
+
+    def _scanJvmNestedType(type as JavaClassType)
+        nativeType = JvmNativeType(type)
+        if type.isClass
+            .addDecl(Class(nativeType, .compiler.backEnd))
+        else if type.isInterface
+            .addDecl(Interface(nativeType, .compiler.backEnd))
+        else if type.isEnum
+            isNames = List<of String>()
+            docString =''
+            .addDecl(EnumDecl(this, nativeType, isNames, docString))  # TODO: isNames; docString?
+        #else if type.isValueType
+        #   .addDecl(Struct(clrType, .compiler.backEnd))
+        #else if type.isAnsiClass
+        #   # The Enum class is an example that returns false for .isClass but true for .isAnsiClass
+        #   .addDecl(Class(clrType, .compiler.backEnd))
+        else
+            throw FallThroughException(type)
+        lastDecl = .declsInOrder[.declsInOrder.count-1] to dynamic
+        if (lastDecl to Object).getType.getProperty('ParentBox')  # CC: if lastDecl responds to (get parentBox as Box?)
+            lastDecl.parentBox = this
+            
+#/
+
+    def _scanJvmFields
+        for fieldInfo in _jvmType.getFields
+            #if fieldInfo.declaringType is not _jvmType, continue
+            if fieldInfo.isDefault, continue    # pkgprivate
+            if fieldInfo.isPrivate, continue
+            name = Utils.cobraNameForNativeMemberName(fieldInfo.name)
+            type = _jvmMemberTypeResultProxy(fieldInfo, fieldInfo.type)
+            attrs = AttributeList()
+            if fieldInfo.isProtected
+                isNames = ['protected']  # isNames = ['protected' 'internal']
+            #else if  fieldInfo.isDefault # pkgprivate
+            #   isNames = ['internal'] # 
+            else
+                isNames = ['public']  # private was guarded against above
+
+            if fieldInfo.isFinal and fieldInfo.isStatic     # java static final fields are constants 
+                value = if(fieldInfo.isStatic, fieldInfo.getValue, nil)
+                initExpr = SharpExpr(TokenFix.empty, if(value, .toString, 'nil'))  # DocGenerator.cobra uses this
+                boxConst = BoxConst(TokenFix.empty, TokenFix.empty, this, name, type, isNames, initExpr, attrs, '')
+                boxConst.binaryName = fieldInfo.name
+                .addDecl(boxConst)
+            else
+                if fieldInfo.isStatic, isNames.add('shared')
+                if fieldInfo.isFinal, isNames.add('readonly') # final fields are readonly
+                varr = BoxVar(TokenFix.empty, TokenFix.empty, this, name, type, isNames, nil, attrs, '')
+                varr.binaryName = fieldInfo.name
+                .addDecl(varr)
+
+    def _scanJvmInitializers
+        for ctorInfo in _jvmType.getConstructors
+            if ctorInfo.isPrivate, continue
+            #if ctorInfo.declaringType is not _clrType, continue
+            skip = false
+            for paramInfo in ctorInfo.getParameters
+                if _badJvmRelatedType(paramInfo)
+                    skip = true
+                    break
+            if skip, continue
+            params = _scanJvmParams(ctorInfo.getParameters, ctorInfo.isVari)
+            isNames = _isNamesForJavaMemberInfo(ctorInfo)
+            attribs = _attribsForJavaMemberInfo(ctorInfo)
+            docString = ''  # TODO: get doc string for class?
+            initer = Initializer(TokenFix.empty, TokenFix.empty, this, params, isNames, attribs, docString)
+            overload as MemberOverload? = nil
+            other = .declForName('cue.init')
+            if other
+                if other inherits MemberOverload
+                    overload = other
+                else if other inherits AbstractMethod
+                    overload = MemberOverload(other)
+                    .registerOverload(overload to !)
+                else
+                    throw FallThroughException([this, initer, other])
+            if overload
+                overload.addMember(initer)
+            else
+                .addDecl(initer)
+                
+    def _scanJvmProperties
+        for propInfo in _jvmType.getProperties
+            getMethod = propInfo.getter 
+            setMethod = propInfo.setter
+            visible = false
+            if getMethod
+                if getMethod.isPublic or getMethod.isProtected
+                    theMethod = getMethod
+                    visible = true
+            if not visible and setMethod
+                if setMethod.isPublic or setMethod.isProtected
+                    theMethod = setMethod to !
+                    visible = true
+            if not visible, continue
+            #if theMethod.declaringType is not _jvmType, continue
+            if propInfo.isIndexer
+                _scanJvmIndexer(propInfo)
+                continue
+                
+            if _badJvmRelatedType(propInfo.type),   continue
+            attribs = _attribsForJavaMemberInfo(propInfo)
+            docString = ''  # TODO: get doc string
+            isNames = _isNamesForJavaMemberInfo(theMethod)
+            #print propInfo
+            propName = Utils.cobraNameForNativeMemberName(propInfo.name)
+            #if _declsByName.containsKey(propName), propName = propInfo.name0+'_prop'
+            prop = Property(TokenFix.empty, TokenFix.empty, this, propName, _jvmMemberTypeResultProxy(propInfo, propInfo.type), isNames, attribs, docString)
+            prop.binaryName = propInfo.name
+            if propInfo.isReadable
+                prop.makeGetPart(TokenFix.empty)
+            if propInfo.isWritable
+                prop.makeSetPart(TokenFix.empty)
+            if _declsByName.containsKey(prop.name) # for            # Double.naN
+                print 'DUP name already exists already for property [prop.name]', _declsByName[prop.name], prop
+                return # just drop the property, field or  method still available
+            .addDecl(prop)
+
+
+    def _scanJvmIndexer(propInfo as JavaFieldInfo)
+        for paramInfo in propInfo.getIndexParameters
+            if _badJvmRelatedType(paramInfo)
+                return
+        params = _scanJvmParams(propInfo.getIndexParameters, false)
+        attribs = _attribsForJavaMemberInfo(propInfo)
+        docString = ''
+        if propInfo.isReadable
+            isNames = _isNamesForJavaMemberInfo(propInfo.getter to !)
+        else if propInfo.isWritable
+            isNames = _isNamesForJavaMemberInfo(propInfo.setter to !)
+        else
+            throw FallThroughException(propInfo)
+        #name = Utils.cobraNameForNativeMemberName(propInfo.name)
+        name = r'[]'    
+        indexer = Indexer(TokenFix.empty, TokenFix.empty, this, name, params, _jvmMemberTypeResultProxy(propInfo, propInfo.type), isNames, attribs, docString)
+        overload as MemberOverload? = nil
+        other = .declForName(name)
+        if other
+            if other inherits MemberOverload
+                overload = other
+            else if other inherits Indexer
+                overload = MemberOverload(other)
+                .registerOverload(overload to !)
+            else
+                throw FallThroughException([this, indexer, other])
+        if overload
+            overload.addMember(indexer)
+        else
+            .addDecl(indexer)
+
+    # In Java  properties are methods with leading is/get/set names
+    # Indexers are methods as for properties but with additional indexes in paramList.
+    def _scanJvmMethods
+        for methInfo in _jvmType.getMethods
+            if methInfo.isPrivate, continue
+            if methInfo.isDefault, continue # pkgPrivate
+            #if methInfo.declaringType is not _clrType, continue
+            skip = false
+            if _badJvmRelatedType(methInfo.returnType)
+                skip = true
+            else
+                for param in methInfo.getParameters
+                    if _badJvmRelatedType(param)
+                        skip = true
+                        break
+            if skip, continue
+            name = Utils.cobraNameForNativeMemberName(methInfo.name)
+            genericParams = List<of IType>()
+            for genArg in methInfo.getGenericArguments
+                genericParams.add(GenericParam(JvmNativeType(genArg)))
+            params = _scanJvmParams(methInfo.getParameters, methInfo.isVari)
+            isNames = _isNamesForJavaMemberInfo(methInfo)
+            if methInfo.isOverride,  isNames.add('override')    # only on methods
+            attribs = _attribsForJavaMemberInfo(methInfo)
+            docString = '' 
+            implementsTypeNode as ITypeProxy?  # TODO: explicit interface implementation?
+            method = Method(TokenFix.empty, TokenFix.empty, this, name, genericParams, params, _jvmMemberTypeResultProxy(methInfo, methInfo.returnType), implementsTypeNode, isNames, attribs, docString)
+            method.binaryName = methInfo.name
+            overload as MemberOverload? = nil
+            other = .declForName(name)
+            if other
+                if other inherits MemberOverload
+                    overload = other
+                else if other inherits AbstractMethod
+                    overload = MemberOverload(other)
+                    .registerOverload(overload to !)
+                else
+                    print 'Unexpected overload for name:', name, other
+                    throw FallThroughException([this, method, other])
+            if overload
+                overload.addMember(method)
+            else
+                .addDecl(method)
+
+    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool) as List<of Param>
+        """
+        Returns a list of Cobra Params given a list of Java ClassTypes (presumably a java parameterList)
+        """
+        params = List<of Param>()
+        if not jparams or not jparams.count
+            return params
+        
+        paramN = 0
+        for javaParam in jparams
+            paramN +=1  
+            isVari = paramN == jparams.count and isVariMethod #and javaParam is an array
+            # TODO support varags detection.
+            #java encodes a variable length paramlist as method.isVarArgs==TRUE and varargs parameter as an array of the the LCD Type ( Object[], String[] ) ( and perhaps args has transient modifier)
+            
+            # TODO: detect nullable on paramlist types ?
+            # To support nilable on params need change representation to a javaParamType containing type + attributes (for param) ( + direction possibly)
+            # Java not support nilable directly so ignore for moment
+            #isNotNull = javaParam.isNonNullable
+            isNotNullable = false # can be null
+            parameterType = javaParam
+            type = _jvmMemberTypeProxy(parameterType, isNotNullable)
+            if isVari, type = VariTypeProxy(type)
+            name = 'unkname' # java not keep names of given formal parameters
+            param = Param(name, type)
+            param.direction = Direction.In # Java doesnt have Out or InOut equivs
+            params.add(param)
+        return params
+
+                
+    def _isNamesForJavaMemberInfo(mi as JavaMemberInfo) as List<of String>
+        """
+        Returns the Cobra "is names" such as ['public', 'static'] that correspond to the properties of the JavaMember.
+        """
+        isNames = List<of String>(8)
+        if mi.isDefault,     isNames.add('internal') # pkgPrivate/internal  and protected 
+        # actually
+        #if mi.isProtected
+        #   isNames.add('protected')
+        #   isNames.add('internal')     # TODO: address this later
+        if mi.isProtected,   isNames.add('protected')
+        if mi.isPrivate,     isNames.add('private')
+        if mi.isPublic,      isNames.add('public')
+        if mi.isStatic,      isNames.add('shared')
+        if mi.isAbstract,    isNames.add('abstract')
+        if mi.isFinal,       isNames.add('readonly')
+        return isNames
+            
+    def _attribsForJavaMemberInfo(mi as JavaMemberInfo) as AttributeList
+        return AttributeList()  # TODO:
+
+
+    def _badJvmRelatedType(t as JavaClassType?) as bool
+        """
+        Returns true if the given type, which comes from a parameter or return value, is unsupported.
+        For example, it's not public or it's nested. Members with bad types are skipped when scanning DLLs.
+        """
+        if t is nil 
+            return false
+
+        if t.isNested and not (t.isPublic or t.isProtected)and not t.isGenericParameter  # TODO: need the generic param check?
+            print 'Type t.name is nested and not public,protected'
+            return true
+
+        # FYI: MS .NET 2.0 (but not Mono 1.2.6) will return true for .isNotPublic for types are "by ref"
+        #if t.isByRef # TODO: or t.isArray
+        #   return _badJvmRelatedType(t.getElementType)
+
+        return false
+
+    def _jvmMemberTypeProxy(jvmType as JavaClassType?) as ITypeProxy
+        return _jvmMemberTypeProxy(jvmType, false)
+
+    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.
+        """
+        if jvmType is nil
+            return .compiler.voidType
+        else if jvmType.isValueType
+            return JvmTypeProxy(jvmType)
+        else
+            # TODO: for generic types, should look at constraints. if constraints don't dictate nilable or not, then need to treat type special during generic construction
+            tp = JvmTypeProxy(jvmType) to ITypeProxy
+            if not notNull
+                tp = NilableTypeProxy(tp)
+            return tp
+
+    def _jvmMemberTypeResultProxy(member as JavaMemberInfo, jvmType as JavaClassType?) as ITypeProxy
+        """
+        Returns a type proxy for a member type such as a method return type, property or field.
+        In Java, reference types are nilable by default.
+        """
+        if jvmType is nil
+            return .compiler.voidType
+        else if jvmType.isValueType
+            return JvmTypeProxy(jvmType)
+        else if jvmType.isValueType or jvmType.isGenericParameter
+            return JvmTypeProxy(jvmType)
+        else
+            notNull = member.isNonNullable
+            t = JvmTypeProxy(jvmType) to ITypeProxy
+            return if(notNull, t, NilableTypeProxy(t))
+
+
+class Class
+    is partial
+
+    def _scanNativeTypeJvm
+        base._scanNativeTypeJvm
+        print 'scanJvmNativeType ', .name
+        _scanJvmIsNames
+        _scanJvmImplements
+        #_scanJvmNestedTypes
+        _scanJvmFields
+        _scanJvmInitializers
+        _scanJvmMethods
+        _scanJvmProperties  # do props last since they are synthesized
+        ##_scanJvmEvents TODO 
+        # TODO: _scanJvmEnums
+        # TODO: scan all other nested types
+        
+    
+class Interface
+    is partial
+
+    def _scanNativeTypeJvm
+        base._scanNativeTypeJvm
+        _scanJvmIsNames
+        _scanJvmImplements
+        #_scanJvmNestedTypes
+        _scanJvmFields
+        _scanJvmMethods
+        _scanJvmProperties
+        #_scanJvmEvents #TODO
+
+
+class Struct
+    is partial
+
+    def _scanNativeTypeJvm
+        base._scanNativeTypeJvm
+        _scanJvmIsNames
+        _scanJvmImplements
+        #_scanJvmNestedTypes
+        _scanJvmFields
+        _scanJvmInitializers
+        _scanJvmMethods
+        _scanJvmProperties
+        #_scanJvmEvents
+
+
+class Extension
+    is partial
+
+    def _scanNativeTypeJvm
+        # this only for Cobra specific extensions. Example: class Extend_String_1939
+        base._scanNativeTypeJvm
+        _scanJvmIsNames
+        #_scanJvmImplements
+        #_scanJvmNestedTypes
+        #_scanJvmFields
+        #_scanJvmInitializers
+        #_scanJvmProperties
+        _scanJvmMethods
+        #_scanJvmEvents
+
+    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool) as List<of Param> is override
+        # the first argument is implicit in an Extension
+        results = base._scanJvmParams(jparams, isVariMethod)
+        return results[1:]
+        
+    def jvmExtnNativeType(nativeType as NativeType) as NativeType
+        # the real extended type is the type of the first argument of any method
+        for methInfo in _jvmType.getMethods 
+            nativeType = JvmNativeType(methInfo.getParameters[0])
+            break
+        return nativeType
+
+        
+
+class EnumDecl
+    is partial
+
+    def _setUnderlyingTypeJvm
+        pass
+
+    def _scanNativeTypeJvm
+        # TODO: read attribs
+        _needScanNativeType = false
+        _storageType = .compiler.anyIntType # tmp ??
+        
+        /# 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.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

@@ +1 @@
+# Backend for generating Java code to run on a JVM - Currently this is cross-compile only fm .net/mono.
+use System.Diagnostics
+
 class JvmBackEnd inherits BackEnd
 
+    var _objectTypeProxy as AbstractTypeProxy?
+    var _typeTypeProxy   as AbstractTypeProxy?
+
     cue init(compiler as Compiler)
         base.init(compiler)
+        _name = 'java-jvm'
+        _rtlName = 'CobraLang.jar'
+        
+        _tagToTypeName = { 
+            'Object': 'java.lang.Object',
+            'Type'  : 'java.lang.Class<of>',    # java.lang.Type is a marker interface
+            'String'    :       'java.lang.String',
+            'Exception' :       'java.lang.RuntimeException',
 
+            'Delegate'  :       'System.Delegate', #cobra.lang.Delegate
+            'Attribute' :       'java.lang.annotation.Annotation',
+            #'ICloneable':      'System.ICloneable', #cobra.lang.ICloneable
+            'IEnumerable':      'java.lang.Iterable',
+            'IEnumerator':      'java.lang.Iterator',
+            'IEnumerable<of>' : 'java.lang.Iterable<of>',
+            'IEnumerator<of>' : 'java.lang.Iterator<of>',
+            'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator',
+            'ICollection':      'java.util.Collection<of Object>',  # non generic collection interface
+            '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<of,>': 'java.util.Map<of,>',
+            'Dictionary<of,>' : 'java.util.HashMap<of,>',
+            'Set<of>':          'java.lang.HashSet<of>',
+
+            'bool'  :  'java.lang.Boolean',  # boolean
+            'char'  :  'java.lang.Character',# char
+            'decimal': 'java.lang.Double',  # ??
+            'single': 'java.lang.Float',    # float 
+            'double': 'java.lang.Double',   # double    
+            'sbyte' : 'java.lang.Byte',     # byte
+            'int16' : 'java.lang.Short',    # short 
+            'int32' : 'java.lang.Integer',  # int       
+            'int64' : 'java.lang.Long',     # long
+            'byte'  : 'java.lang.Short',    # short   # rest are unsigned - use next widest
+            'uint16': 'java.lang.Integer',  # int   
+            'uint32': 'java.lang.Long',     # long
+            'uint64': 'java.lang.Long',     # long
+            
+            }
+        
     def makePhases(phases as IList<of Phase>) is override
+        # TODO
+        #phases.add(ApplyExtendedClasses(.compiler) # ?? done here or earlier
+        #phases.add(AggregatePartialClassesCodePhase(.compiler)
         phases.add(GenerateJavaCodePhase(.compiler))
         phases.add(CompileJavaCodePhase(.compiler))
         
     def computeOutName as String is override
         return .compiler.computeOutNameJava 
         
+    def genNativeModule(filename as String, verbosity as int) as Module? is override
+        m as Module?
+        if filename.endsWith('.java')
+            if verbosity, print 'Noting  [filename] as JavaModule'  # extra space to line up with 'Parsing [filename]'
+            m = JavaModule(filename, verbosity)
+        return m
+        
+    def setupRunProcess(baseExe as String, fullExe as String) as Process is override
+        p = Process()
+        p.startInfo.fileName = 'java'
+        clPath = Path.getDirectoryName(CobraCore.exePath) to !
+        clPath = Path.combine(clPath, 'CobraLang.jar')
+        classpath = Environment.getEnvironmentVariable('CLASSPATH')
+        cpSep = if(CobraCore.isRunningOnUnix, ':', ';')
+        classpath = '.[cpSep][clPath][cpSep][classpath]'
+        # TODO: additional classpaths for  references 
+        args = '-ea -cp "[classpath]"'
+        args += ' [baseExe]'
+    
+        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)
+        # java uses lowercase for package names - Should Cobra stay capitalised and we remap it ??
+        ns.addUseDirective(UseDirective(useToken, ['java', 'lang']))
+        #ns.addUseDirective(UseDirective(useToken, ['System', 'Collections', 'Generic'])) # generics built in
+        ns.addUseDirective(UseDirective(useToken, ['java', 'io']))
+        ns.addUseDirective(UseDirective(useToken, ['java', 'util']))
+        ns.addUseDirective(UseDirective(useToken, ['java', 'text']))
+        ns.addUseDirective(UseDirective(useToken, ['cobra', 'lang']))
+        
+    def fixLibExtension(libRef as String) as String is override
+        """
+        Augment given lib reference string with .jar backend extension if not already have one
+        """
+        or require libRef.length
+        and ensure result.endsWith('.jar')
+        if not libRef.endsWith('.jar')
+            libRef += '.jar'
+        return libRef
+    
+    def loadLibReference(reference as String) as bool is override
+        """
+        Load referenced library (jar file)
+        """
+        # Currently with cross compile fm .Net cant do this (easily) as not in a java environ
+        # (can we use Ikvm for this to bootstrap?)
+        # so what we will do is test for the existance of the jarfile in some sensible places
+        # (cwd, classpath, default install rt and extensions dir) and if it is found return true
+        #
+        #return .compiler.javaLoadReference(reference)
+        # -> reference -> jarFile -> JarSig(jarFile) -> javaReadJar
+        assert reference.endsWith('.jar')
+        return .compiler.jvmLoadReference(reference)   # in ScanJvmType
+    
+    def readSystemTypes is override
+        #pass   # TODO
+        # 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
+        # items in a jar file.
+        
+        # JarSig is a holder for jarfile extended with info on contained classes.
+        # javaReadJar loads info on contained classes into Cobra
+        # rt.jar is only one we need
+        .compiler.javaReadJar(JarSig('rt.jar'))
+    
+    def fixNilableMemberSigs is override
+        #.compiler.javafixNilableMemberSigs
+        print '++ TODO jvmBackEnd.fixNilableMemberSigs'
+        pass # TODO
+        
+    def installNativeMethods(box as Box, nativeType as NativeType) is override
+        #.compiler.installJvmNativeMethods(box, nativeType)
+        print '++ TODO jvmBackEnd.installNativeMethods'
+        pass # TODO
 
+    def cobraNameForNativeBoxName(nativeBoxName as String) as String is override
+        return JvmTypeProxy.cobraNameForJvmBoxName(nativeBoxName)
+    
+    # Types
+    get objectTypeProxy as AbstractTypeProxy  is override
+        """Type proxy for BE root of Object hierarchy."""
+        if  not _objectTypeProxy
+            _objectTypeProxy = JvmTypeProxy(JarSig.classByNameCache['java.lang.Object'])
+        return _objectTypeProxy to !
+            
+    get typeTypeProxy  as AbstractTypeProxy  is override
+        """Type proxy for BE notion of a class describing a Type."""
+        if  not _typeTypeProxy
+            _typeTypeProxy = JvmTypeProxy(JarSig.classByNameCache['java.lang.Class'])
+        return _typeTypeProxy to !  
+        
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is override
+        return JvmTypeProxy(type)
+    
+    def nativeType(type as dynamic) as NativeType  is override
+        return JvmNativeType(type)
+    
+    def nativeTypeByName(qualifiedNameOrTag as String) as NativeType is override
+        #map 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))
+        /#
+        These are the type tags used directly by the compiler code.
+            
+            bool        'Java.lang.Boolean'
+            char        'java.lang.Char'
+            decimal     '??System.Decimal'  
+            decimal     'java.lang.Float'   
+            single      'java.lang.Float'       
+            double      'java.lang.Double'      
+            sbyte       'java.lang.Byte'        
+            int16       'java.lang.Short'       
+            int32       'java.lang.Int'     
+            int64       'java.lang.Long'    
+            # java not have unsigned types (:-( use next largest signed Type
+            byte        'java.lang.Short' #& 0x7f       
+            uint16      'java.lang.Int'     
+            uint32      'java.lang.Long'        
+            uint64      'java.lang.Long'        
+        #/
+        
+    def addArrayInterfaces(interfaces as List<of ITypeProxy>) is override
+        pass
+        #iclone = .compiler.libraryType('ICloneable') # ICloneable not supported
+        #interfaces.insert(0, iclone to ITypeProxy)
+        
+        
+        
 class GenerateJavaCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/BackEndJvm/JavaCompilationMessage.cobra

@@ -11 +11 @@
         assert msg.lineNum == 30
 
     def willSkipMessage(msg as String) as bool is shared
-        return not '.java:' in msg
-
+        #return not '.java:' in msg
+        return false 
+        
     var _fileName as String?
     var _lineNum as int?
     var _isError as bool
@@ -24 +25 @@
         line = line.trim
         _isError = true
         i = line.indexOf('.java:')
-        _fileName = line[:i]
-        i += '.java:'.length
-        j = line.indexOf(':', i)
-        lineStr = line[i:j]
-        try
-            _lineNum = int.parse(lineStr)
-        catch
-            pass
-        success
-            _lineNum = compiler.cobraLineNumForCurly(.fileName, _lineNum to !)
-        if compiler.verbosity or Utils.isDevMachine, line += ' (javac)'
+        if i >= 0
+            _fileName = line[:i]
+            i += '.java:'.length
+            j = line.indexOf(':', i)
+            lineStr = line[i:j]
+            try
+                _lineNum = int.parse(lineStr)
+            catch
+                pass
+            success 
+                _lineNum = compiler.cobraLineNumForCurly(.fileName, _lineNum to !)
+                if compiler.verbosity or Utils.isDevMachine, line += ' (javac)'
         _message = _cleanUp(line)
 
     def _cleanUp(line as String) as String

Source/BackEndJvm/JavaGenerator.cobra

@@ -1 +1 @@
 """
+Generate Java source code file for cobra AST.
+    
 The code in this file should not .throwError, record warnings, etc.
 All of that happens during .bindFoo phases.
 """
@@ -10 +12 @@
 
 class Compiler is partial
 
+    # run prior to compilation to determine an output filename for the java source
+    # 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
         outName =''
         if .options.boolValue('test')
@@ -40 +46 @@
 
     def writeJavaTestInvocation
         # TODO
-        pass
+        print 'TODO: writeJavaTestInvocation'
 
     def compileJava
         .compileJava('')
@@ -53 +59 @@
             options = .options
 
             # locate the Java compiler
-            compilerPath = options.getDefault('native-compiler', '') to String
-            if compilerPath <> ''
+            # 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'
                 if File.exists(compilerPath)
                     pass
                 else if File.exists(compilerPath+'.exe')
@@ -63 +71 @@
                     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 = '-'
             
-            # exeNames
+            # exeNames - javaTool
             outName = .computeOutNameJava
+            
+            # compute backEndOptions
+            backEndOptions = '-d .'     # Put namespaced classfiles in own hierarchy
 
-            # compute backEndOptions
-            backEndOptions = ''
             # -optimize isn't supported by JVM, but it could potentially be used by Cobra itself
             
             # TODO:
 #           for refer in .loadedReferences  # don't take the library references from options, because the references can grow
-#               backEndOptions += ' "[optChar]r:[refer]"'
+#               backEndOptions += ' "[optChar]r:[refer]"')
 
             debug = options.getDefault('debug', '') to String
             if debug.length
@@ -87 +98 @@
             # TODO: not until the java backend is more mature
             # backEndOptions += ' -nowarn'
             
-            backEndOptions += ' ' + extraJavacOptions
+            backEndOptions += extraJavacOptions
             
             nativeArgs = .options.getDefault('native-compiler-args', '') to String
             if nativeArgs.length
                 if nativeArgs.length > 2 and nativeArgs[0]=="'" and nativeArgs[nativeArgs.length-1]=="'"
-                    # on Windows, you should really use double quotes instead of single, but
-                    # we try to compensate here.
+                    # on Windows, you should really use double quotes instead of single, but we try to compensate here.
                     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 = ':'
+
+            libclassPath = ''
             for libPath in .options.getStringList('library-directory')
-                backEndOptions += ' ' + '-classpath "[libPath]"'
+                libclassPath += '[cpSep][libPath]"'
 
-            # Cobra.Lang.dll is in the same directory as cobra.exe
-            libPath = Path.getDirectoryName(CobraCore.exePath) to !
-            backEndOptions += ' ' + '-classpath "[libPath]"'
-
-            # .java files
+            # Cobra.Lang.dll is in the same directory as cobra.exe, 
+            # 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, 'CobraLang.jar')
+            backEndOptions += ' -classpath "[ccPath][libclassPath]"'
+                
+            # TODO: add libPaths/classpaths for referenced namespaces
+            
+            # .java files fm first class name in each module
             javaFileNameList = List<of String>()
             for module in _modules[1:]
                 if module.javaFileName.length
                     javaFileNameList.add(module.javaFileName)
 
+            # 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
+                outName = Utils.forceExtension(outName, '.class')
+                _fullExeFileName = outName
+                        
             # compilation command
             if _verbosity
                 print 'Compiling to produce [outName]'
+            if _verbosity >= 2
+                print 'compiler =', compilerPath
+                print '    compilerOptions =', backEndOptions
+                print '    nativeArgs =', nativeArgs
+                print '    outName =', .fullExeFileName
+                print '    baseExeFileName =', .baseExeFileName
+                print '    javaFileNameList =', javaFileNameList
 
-            # TODO: need to encapsulate this in CobraCore to avoid .NET dependency
-            p = System.Diagnostics.Process()
-            p.startInfo.fileName = compilerPath
-            javaFileNames = (for fileName in javaFileNameList get '"' + fileName + '"').join(' ')
-            p.startInfo.arguments = '[backEndOptions] [javaFileNames]'
-            if _verbosity >= 2
-                print '[p.startInfo.fileName] [p.startInfo.arguments]'
-            output = CobraCore.runAndCaptureAllOutput(p)
-            # TODO: check p.exitCode, especially if output is empty
+            output = _execAndCapture(compilerPath, backEndOptions, javaFileNameList)
             _parseJavaCompilerOutput(output)
 
             if .errors.count
                 _exitFromErrors
 
             _deleteIntermediateFiles
-
+            
+    # 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()
+        p.startInfo.fileName = binaryPath
+        #options = optionList.join(' ')
+        fileNames = (for fileName in fileNameList get '"' + fileName + '"').join(' ') # MSW quoting
+        p.startInfo.arguments = '[options] [fileNames]'
+        if _verbosity >= 2
+            print '[p.startInfo.fileName] [p.startInfo.arguments]'
+        output = CobraCore.runAndCaptureAllOutput(p)
+        # TODO: check p.exitCode, especially if output is empty
+        return output       
+            
     def _parseJavaCompilerOutput(output as String)
         for line in output.split(c'\n')
             line = line.trim
@@ -142 +186 @@
                 _addMessage(JavaCompilationMessage(line, this))
             
 
+    def _getFixedMainType as String
+        """
+        Fixup mainMethodType for java so that any pkg path (namespace) is all lowercase.
+        We force this in NameSpace.writeJavaDef.
+        """
+        javaMain = .mainMethodTypeName
+        exeParts = javaMain.split('.').toList
+        if exeParts.count >1
+            javaPkg = exeParts[0:-1].join('.').toLower 
+            javaMain = '[javaPkg].[exeParts.last]'  
+        #trace .mainMethodTypeName, javaMain
+        return javaMain 
 ##
 ## Node
 ##
@@ -239 +295 @@
 
     get javaFileName as String is override
         if _javaFileName == '' and not _fileName.endsWith('SystemInterfaces.cobra')
-            _javaFileName = _fileName + '.java'
+            #java source files are persnickety about naming wrt classname contents.
+            filename = _fileName
+            if filename.endsWith('.cobra') or filename.endsWith('.COBRA'), filename = filename[:-6]
+
+            #use first className in File
+            classFileName = _firstClassName
+            if classFileName.length
+                filename = classFileName    
+            _javaFileName = filename + '.java'
         return _javaFileName
-
+        
+    def _firstClassName as String
+        """Find first class name declared in the Module."""
+        classFileName = ''
+        for decl in .topNameSpace.declsInOrder
+            if decl inherits Class
+                classFileName = decl.name
+                break   
+            if decl inherits NameSpace
+                ns = decl
+                for decl1 in ns.declsInOrder
+                    if decl1 inherits Class
+                        classFileName = decl1.name
+                        break
+        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]\n')
-            sw.write('// Generated by Cobra\n')  # TODO: put version number here
+            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')
 
-            # TODO DELME sw.write('using Cobra.Lang = Cobra.Lang[.compiler.embedRunTimeSuffix];\n')
-            
             .topNameSpace.writeJavaDef(sw)
             d = sw.curlyToCobraLineNum
         return d
@@ -276 +353 @@
 class Container<of TMember> is partial
 
     get javaInit as String  # TODO: is abstract
+        """
+        Initial (default) value for a type (in java).
+        """
         return ''
         
     get javaNameComponent as String
@@ -300 +380 @@
     get _computeJavaRef as String
         if .parent
             s = .parent.javaRef
-            # TODO: delme
-            #if s.length and not s.endsWith('::')  # C# has weird "global::" name
-            #   s += '.'
             s += .javaName
         else
             s = .javaName
         return s
 
     def writeJavaIsNames(sw as CurlyWriter)
-        # TODO: look up Java access levels
-        
+        # java access levels:
+        # static, public, protected, private, (package-private), internal, abstract, final
         # TODO: cache this somewhere
         accessLevels = ['public', 'protected', 'internal', 'protected internal', 'private']
         # CC: accessLevels = 'public,protected,internal,protected internal,private'.split(c',')
-            # same names in both Cobra and C#
 
         # TODO:
         # if isNames is nil
@@ -323 +399 @@
         isNames.addRange(_isNames)
         if .defaultAccessLevel.length
             found = false
-            for level as String in accessLevels  # CC: axe as
+            for level in accessLevels  
                 if level in isNames
                     found = true
             if not found
                 isNames.insert(0, .defaultAccessLevel)
         isNameJava = {
             # only have to specify the ones that are different
-            'shared': 'static',
-            'nonvirtual': '',
+            'shared'    : 'static',
+            # virtual/override, nonvirtual/new only on methods and props??
+            #'nonvirtual': '',  # n/a - final is similar but cannot override (new)
+            #'new'      : '',   # n/a - cant override a final 
+            #'virtual'   : '',  # default
+            #'override'  : '',  # n/a - TODO mark with annotation
+            #'readonly' : 'final' # Not applicable to boxes
+            # 'public'
+            #'protected': '',
+            #'private', 
+            'internal' : '',    # goes to nothing which is protected+package-private which is not quite the same 
+            # 'abstract'
+            # 'partial' : '??'  # wot to do about this ???
         }
         sep = ''
         for name in isNames
@@ -374 +461 @@
         else
             return value to String
 
-    get javaInit as String is override  # TODO: remove when not a type
-        assert false
-        return ''
+    #get javaInit as String is override  # TODO: remove when not a type
+    #   assert false
+    #   return ''
 
     get javaRef as String is override
         return .fullName + .javaSuffix
 
     get javaQualifier as String
         ensure result.endsWith('.')
-        return .fullName + .javaSuffix + '.'
+        # TODO : Fix this with correct Namespace setup for java
+        #if .fullName == 'System'
+        #   return 'java.lang.'
+        javaName =  .fullName.toLower # java idiom is all lowercase for packages
+        return  javaName + .javaSuffix + '.'
     
     def writeJavaDef(sw as CurlyWriter) is override
         assert not .isUnified
         base.writeJavaDef(sw)
-        # TODO: how to handle namespaces in Cobra
-        #if not .isRoot
-        #   sw.writeAndIndent('namespace [.name][.javaSuffix] {\n\n')
-        for ud in _useDirectives
+        if not .isRoot
+            javaName = .name.toLower # java idiom is all lowercase for packages
+            sw.write('package [javaName][.javaSuffix]; \n\n')
+        for ud in _useDirectives  # imports
             ud.writeJavaDef(sw)
         for decl in _declsInOrder
             if decl inherits Box
@@ -461 +552 @@
         """
         # TODO: update doc string to reflect Java accurately
         Returns a string that refers to this type including any necessary parameter declaration
-        specification such as Java 'params' or 'out'. Invoked by Param.writeJavaDef.
+        specification such as 'params' or 'out'. Invoked by Param.writeJavaDef.
         """
 
 
@@ -482 +573 @@
         return name
 
     get javaRef as String
+        #print 'cobratype - [.javaName]'
         return .javaName
 
     get javaParamRef as String
@@ -496 +588 @@
     get javaInit as String is override
         return 'false'
 
+    get javaName as String is override
+        #return _nativeType.fullName
+        return 'boolean'
 
 class CharType is partial
 
     get javaInit as String is override
-        return '(char)0'
+        return '(character)0'
 
 
 class DynamicType is partial
@@ -515 +610 @@
 class FloatType is partial
 
     get javaName as String is override
-        return _nativeType.fullName
+        #return _nativeType.fullName
+        return 'float'
 
 
 class IntType is partial
 
     get javaName as String is override
-        return _nativeType.fullName
+        #return _nativeType.fullName
+        return 'int'    # java.lang.Integer
+        # TODO byte = int8 , short = int16, int = Int32, long = int64
 
-
 class NilableType is partial
 
     get javaInit as String is override
@@ -560 +657 @@
 class StreamType is partial
 
     get javaInit as String is override
-        return 'new Cobra.Lang.EmptyStream<[.theWrappedType.javaRef]>()'
+        return 'new cobra.lang.EmptyStream<[.theWrappedType.javaRef]>()'
 
     get javaRef as String is override
         assert .didBindInh and .didBindInt
@@ -658 +755 @@
         else
             java = .javaName
         if .parentNameSpace and not .parentNameSpace.isRoot
+            #trace .parentNameSpace.javaQualifier
             java = .parentNameSpace.javaQualifier + java
         else if .parentBox
+            trace .parentBox.javaRef
             java = .parentBox.javaRef + '.' + java
+        #trace java
         return java
 
     def writeJavaDef(sw as CurlyWriter)
@@ -769 +869 @@
             expr.writeJavaDef(sw)
             sw.write(')\n')
             sw.indent
-            sw.write('throw new Cobra.Lang.InvariantException([expr.javaSourceSite(.name, "invariant", javaThis)], ')
+            sw.write('throw new cobra.lang.InvariantException([expr.javaSourceSite(.name, "invariant", javaThis)], ')
             expr.writeJavaBreakdown(sw)
             sw.write('[javaThis], null);\n')
             sw.dedent
@@ -809 +909 @@
     def writeJavaInheritance(sw as CurlyWriter) is override
         sw.write(' extends ')
         if _baseClass
+            #trace _baseClass
             sw.write(_baseClass.javaRef)
             didWrite = true
         if didWrite
@@ -872 +973 @@
 
 
 class Struct is partial
-
+    # public class, public final fields, public methods?
     get javaInit as String is override
         return ''  # blank to indicate there is no valid init
 
@@ -975 +1076 @@
 
 class Param is partial
 
-    def writeJavoDef(sw as CurlyWriter)
+    def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
-        if .type.isReference and not .type inherits NilableType
-            sw.write(r'[Cobra.Lang.NotNull] ')
+        # TODO
+        #if .type.isReference and not .type inherits NilableType
+        #   sw.write(r'[Cobra.Lang.NotNull] ') 
         branch .direction
             on Direction.In, pass
-            on Direction.InOut, sw.write('ref ')
-            on Direction.Out, sw.write('out ')
+            on Direction.InOut, sw.write('/*inOut*/')   # default
+            on Direction.Out, sw.write('/*out*/')       # TODO
         sw.write('[.type.javaParamRef] [.javaName]')
 
     def writeJavaDefSansReferenceLabels(sw as CurlyWriter)
@@ -1021 +1123 @@
 
     def writeJavaNotNull(sw as CurlyWriter)
         if .resultType.isReference and not .resultType inherits NilableType
-            sw.writeLine(r'[' + .javaNotNullPrefix + 'Cobra.Lang.NotNull]')
+            sw.writeLine(r'[' + .javaNotNullPrefix + 'cobra.lang.NotNull]')
 
     get javaNotNullPrefix as String
-        # TODO
-        # 2007-12-22 Writing the attribute like [return: NotNull] is problematic because MemberInfo.getCustomAttributes()
-        # will not see it. At least not on Novell Mono 1.2.4. I don't know if that is a bug or a "feature".
-        #return 'return: '
+        # TODO make an annotation on BoxMember
         return ''
 
     def writeJavaTest(sw as CurlyWriter)
@@ -1058 +1157 @@
         # if isNames is nil
         #   isNames = _isNames
         
-        # TODO:
         isNameJava = {
             # only have to specify the ones that are different
             'shared': 'static',
-            'nonvirtual': '',
+            'nonvirtual': '',   # n/a - final is similar but cannot override (new)
+            'new'       : '',   # n/a - cant override a final 
+            'virtual'   : '',   # default
+            'override'  : '',   # n/a - TODO mark with annotation
+            'readonly' : 'final',
+            #   'public', 'protected', 'private', 
+            'internal' : ''     # goes to nothing which is package-private which is not quite the same 
+            # 'abstract'
         }
         wroteNames = Set<of String>()
         sep = ''
@@ -1091 +1196 @@
     # TODO:
     
     get javaName as String is override
-        return .name.capitalized
+        return .name #.capitalized
 
     def writeJavaDef(sw as CurlyWriter) is override
         base.writeJavaDef(sw)
@@ -1105 +1210 @@
 
 class BoxField is partial
 
-    get _backEndName as String
-        name = .name
-        if not name.startsWith('_')
-            name = name.capitalized
-        return name
+    # java idiom uses same (sensible) naming  style as cobra
+    #get _javaBackEndName from name
+    get _javaBackEndName as String
+        return .name
 
 
 class BoxConst is partial
@@ -1120 +1224 @@
         .writeJavaIsNames(sw)
         sw.write('const ')
         sw.write(_type.javaRef)
-        sw.write(' [_backEndName] = ')
+        sw.write(' [_javaBackEndName] = ')
         _initExpr.writeJavaDef(sw)
         sw.write(';\n')
 
@@ -1128 +1232 @@
 class BoxVar is partial
 
     get javaAssignmentNames as List<of String>
-        return [_backEndName]
+        return [_javaBackEndName]
         # return List<of String>(_useBackEndNameStack)
 
     get javaName as String is override
         if _ifInheritsStack.count
             if _type.isReference
-                return '(([_ifInheritsStack.peek.javaRef])[_backEndName])'
-            else
+                return '(([_ifInheritsStack.peek.javaRef])[_javaBackEndName])'
+            else    # TODO fix this - .Net specific
                 # could it be a subclass? no. value types are structs and cannot be subclassed so this must be `if i` where `i` is nullable struct
-                return '[_backEndName].Value'  # Nullable<of T>.Value
+                return '[_javaBackEndName].Value'  # Nullable<of T>.Value
         else
             return .name
         # return _useBackEndNameStack.peek to !
@@ -1147 +1251 @@
         .writeJavaAttribs(sw)
         .writeJavaIsNames(sw)
         sw.write(_type.javaRef)
-        sw.write(' [_backEndName]')
+        sw.write(' [_javaBackEndName]')
         if _initExpr
             sw.write(' = ')
             _initExpr.writeJavaDef(sw)
@@ -1179 +1283 @@
     def innerWriteJavaDef(sw as CurlyWriter)
         pass
     
-    def writeJavaImp(sw as CurlyWriter)
+    def writeJavaImp(sw as CurlyWriter, skipFirst as bool)
         .compiler.codeMemberStack.push(this)
         try
             sw.writeAndIndent('{\n')
@@ -1201 +1305 @@
                         javaInit = param.type.javaInit
                         if not javaInit.length
                             # TODO/HACK: yes we need something like this (or a way to convice C# that the out param reference in `finally` really is okay),
-                            # but it should be something less hackish, like an attribute
                             javaInit = 'DateTime.Today'
                         sw.write('[param.javaName] = [javaInit];')
                 if _backEndResultVarName.length  # set in _bindImp
@@ -1210 +1313 @@
                         sw.write('= [_returnType.javaInit]')
                     sw.write(';\n')
                 sw.writeAndIndent('try {\n')
-            for stmt in _stmts, stmt.writeJavaStmt(sw)
+            for stmt in _stmts 
+                if skipFirst
+                    skipFirst = false
+                    continue
+                stmt.writeJavaStmt(sw)
             if willEnsure
                 if not stmt inherits ReturnStmt and not stmt inherits ThrowStmt
                     sw.write('_lh_canEnsure = true;\n')
@@ -1330 +1437 @@
         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.Lang.CobraCore._willCheckNil && [param.javaName]==null) throw new System.ArgumentNullException("[param.name]");\n')
+                sw.write('if (cobra.lang.CobraCore._willCheckNil && [param.javaName]==null) throw new System.ArgumentNullException("[param.name]");\n')
 
     def writeJavaDSTHead(sw as CurlyWriter)
         if not .canHaveDetailedStackTrace
             return
         # could be a neat option, -trace-methods, but maybe done with events:
         # sw.writeLine('Console.WriteLine(">> [.parentBox.name].[.name]");')
-        sw.write('Cobra.Lang.CobraImp.PushFrame("[.parentBox.name]", "[.name]", [Utils.javaStringLiteralFor(.token.fullPathName)], [.token.lineNum]')
+        sw.write('cobra.lang.CobraImp.pushFrame("[.parentBox.name]", "[.name]", [Utils.javaStringLiteralFor(.token.fullPathName)], [.token.lineNum]')
         if not .isShared
             sw.write(', "this", [.compiler.curBox.javaThis]')
         for param in .params
@@ -1353 +1460 @@
         # this catch all clashes with yield statements. which is why .canHaveDetailedStackTrace returns false if a method has a yield statement.
         sw.dedentAndWrite('} catch (java.lang.Exception) {\n')
         sw.indent
-        sw.write('Cobra.Lang.CobraImp.CaughtUncaughtException();\n')
+        sw.write('cobra.lang.CobraImp.CaughtUncaughtException();\n')
         sw.write('throw;\n')
         sw.dedentAndWrite('} finally {\n')
         sw.indent
-        sw.write('Cobra.Lang.CobraImp.PopFrame();\n')
+        sw.write('cobra.lang.CobraImp.popFrame();\n')
         sw.dedentAndWrite('}\n')
 
 
@@ -1366 +1473 @@
     def innerWriteJavaDef(sw as CurlyWriter)
         base.innerWriteJavaDef(sw)
         .writeJavaAttribs(sw)
-# delme     first = if(_stmts.count, _stmts[0], nil)
-# delme     callInitializer as String? = nil
-/#
-delme
+        
+        .writeJavaIsNames(sw)
+        sw.write(' [.parentBox.rootName]')
+        .writeJavaParams(sw)
+        
+        .writeJavaImp(sw, _hasCallInitializer)  # Initializer Body
+        
+        if _requirePart, _requirePart.writeJavaMethod(sw)
+        if _ensurePart, _ensurePart.writeJavaMethod(sw)
+        if .compiler.includeTests
+            .writeJavaTest(sw)
+
+    def writeJavaImpHeader(sw as CurlyWriter)
+        base.writeJavaImpHeader(sw)
+
+        first = if(_stmts.count, _stmts[0], nil)
+        callInitializer as String? = nil
         if first inherits DotExpr
             if first.left inherits ThisOrBaseLit
                 if (firstRight = first.right) inherits IDotRightExpr
@@ -1378 +1498 @@
                         args = firstRight.args
                         Stmt.inInitCall = true
                         didSetInInitCall = true
-#/
-        .writeJavaIsNames(sw)
-        sw.write(' [.parentBox.rootName]')
-        .writeJavaParams(sw)
-/#
-delme
-        if callInitializer
-            sw.writeAndIndent('\n')
-            sw.write(': [callInitializer](')
-            sep = ''
-            for arg in args
-                sw.write(sep)
-                arg.writeJavaDef(sw)
-                sep = ', '
-            sw.write(') ')
-            sw.dedent
+            if args.count == 0
+                sw.writeLine('//super() - default noarg initialiser call happens here')
+            else
+                sw.write('[callInitializer](')
+                sep = ''
+                for arg in args
+                    sw.write(sep)
+                    arg.writeJavaDef(sw)
+                    sep = ', '
+                    sw.write(');')
             if didSetInInitCall
                 assert Stmt.inInitCall  # make sure it wasn't reset somewhere else
                 Stmt.inInitCall = false
-#/
-        .writeJavaImp(sw)
-        if _requirePart, _requirePart.writeJavaMethod(sw)
-        if _ensurePart, _ensurePart.writeJavaMethod(sw)
-        if .compiler.includeTests
-            .writeJavaTest(sw)
 
-    def writeJavaImpHeader(sw as CurlyWriter)
-        base.writeJavaImpHeader(sw)
         if .isStructMember and .compiler.options['contracts'] <> 'none'
             sw.write('\n_ih_invariantGuard = 0;\n\n')  # otherwise C# complains: Field "STRUCTNAME._ih_invariantGuard" must be fully assigned before control leaves the constructor
         
-
+            
+    def _hasCallInitializer as bool
+        callInitializer as String? = nil
+        first = if(_stmts.count, _stmts[0], nil)
+        if first inherits DotExpr
+            if first.left inherits ThisOrBaseLit
+                if (firstRight = first.right) inherits IDotRightExpr
+                    if firstRight.name == 'init'
+                        callInitializer = (first.left to ThisOrBaseLit).asJava
+        return callInitializer <> nil
+                    
+            
 class Method is partial
 
     get javaGenericParams as String is override
@@ -1437 +1554 @@
             name = _implementsType.javaRef + '.' + name
         .writeJavaIsNames(sw)
         sw.write('[returnType.javaRef] [name][.javaGenericParams]')
-        .writeJavaParams(sw)
+        if .isMain  
+            sw.write(r'(String[] args)')
+        else
+            .writeJavaParams(sw)
         if .genericParams.count
             sw.indent
             for param in .genericParams
@@ -1448 +1568 @@
             sw.write(';\n')
         else
             if .isAbstract, sw.writeLine(';')
-            else, .writeJavaImp(sw)
+            else, .writeJavaImp(sw, false)
             if _requirePart, _requirePart.writeJavaMethod(sw)
             if _ensurePart, _ensurePart.writeJavaMethod(sw)
             if .compiler.includeTests, .writeJavaTest(sw)
@@ -1457 +1577 @@
         base.writeJavaImpHeader(sw)
         if .isMain
             if .compiler.hasExceptionReportOption
-                sw.writeLine('try { // Exception Report')
+                sw.writeLine('try { // Exception Report') 
                 sw.indent
-            else if .compiler.options.boolValue('debugging-tips')
-                sw.writeLine('try { // -debugging-tips')
+            else if .compiler.options.boolValue('debugging-tips') 
+                sw.writeLine('try { // -debugging-tips  - turn off with -d/-debug (see cobra -h)')
                 sw.indent
         if .isMain and .compiler.options.boolValue('include-tests')
-            sw.writeLine('Cobra.Lang.CobraCore.RunAllTests();  // turn off with -include-tests:no (see cobra -h)')
+            sw.writeLine('cobra.lang.CobraCore.runAllTests();  // turn off with -include-tests:no (see cobra -h)')
 
     def writeJavaImpFooter(sw as CurlyWriter)
         base.writeJavaImpFooter(sw)
         if .isMain
             if .compiler.hasExceptionReportOption
                 sw.dedent
-                sw.writeLine('} catch (java.lang.Throwable _lh_exceptionReportThrowable) { Cobra.Lang.CobraCore.HandleUnhandledException(_lh_exceptionReportThrowable); }')
+                sw.writeLine('} catch (java.lang.Throwable _lh_exceptionReportThrowable) { cobra.lang.CobraCore.HandleUnhandledException(_lh_exceptionReportThrowable); }')
             else if .compiler.options.boolValue('debugging-tips')
                 sw.dedent
                 sw.writeLine('} catch (java.lang.Throwable _lh_debuggingTipsThrowable) {')
                 sw.indent
-                sw.writeLine('Cobra.Lang.CobraCore.PrintDebuggingTips();')
-                sw.writeLine('throw _lh_debuggingTipsThrowable.fillInStackTrace();')
+                sw.writeLine('cobra.lang.CobraCore.printDebuggingTips();')
+                #sw.writeLine('throw _lh_debuggingTipsThrowable.fillInStackTrace();')
+                sw.writeLine('_lh_debuggingTipsThrowable.printStackTrace();')
                 sw.dedent
                 sw.writeLine('}')
 
     get javaName as String is override
-        return .name.capitalized
+        return .name #.capitalized
 
+# Java, for its sins, does not have support for properties built into the language...
+# efforts to correct this stupidity seem to be mired in language navel gazing plus associated 
+# belly button lint picking followed by mastubatory dick waving to find the most obscure and difficult 
+# corner cases which then leads to it being then dropped in the 'too hard' basket
+# Historically and currently it instead uses a convention which leads to a whole lot of obfuscating boilerplate code
+#   Its obviously too difficult to just copy C# (turnabout is fair play), accept and then evolve any edge misses 
 
 class ProperDexer is partial
 
@@ -1579 +1706 @@
             if not Path.isPathRooted(fileName)
                 fileName = Path.combine(Environment.currentDirectory, fileName)
             fileName = Utils.javaStringLiteralFor(fileName)
-            return 'new Cobra.Lang.SourceSite([fileName], [tok.lineNum], [boxName], [memberName], [javaThis])'
+            return 'new cobra.lang.SourceSite([fileName], [tok.lineNum], [boxName], [memberName], [javaThis])'
 
     get javaThis as String
         if _inInitCall  # C# won't allow 'this' in a base constructor call -- TODO
@@ -1593 +1720 @@
 
     def writeJavaSetLine(sw as CurlyWriter)
         if _canSetLine and .token.lineNum > 0
-            sw.write('Cobra.Lang.CobraImp._curFrame._lineNum = [.token.lineNum];\n')
+            sw.write('cobra.lang.CobraImp._curFrame._lineNum = [.token.lineNum];\n')
 
     def writeJavaStmt(sw as CurlyWriter)
         assert .didBindImp
@@ -1608 +1735 @@
         base.writeJavaDef(sw)
         if not .compiler.options.boolValue('include-asserts')
             return
-        sw.write('if (Cobra.Lang.CobraCore._willCheckAssert && !')
+        sw.write('if (cobra.lang.CobraCore._willCheckAssert')
+        # TODO - implement cobra assertions - needs cobra assertException + Sourcesite
+        /# 
+        sw.write(' && !')
         _expr.writeJavaDef(sw)
-        sw.write(') ')
+        sw.write(')\n')
         sw.indent
-        sw.write('throw new Cobra.Lang.AssertException([.javaSourceSite], ')
+        
+        # TODO later Implement SourceSite and CobraLang AssertException 
+        sw.write('throw new cobra.lang.AssertException([.javaSourceSite], ')
         _expr.writeJavaBreakdown(sw)
         sw.write('[.javaThis], ')
         if _info
@@ -1621 +1753 @@
             sw.write('null')
         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]')
+        if _info
+            sw.write(' : ')
+            _info.writeJavaDef(sw)
+        else        # Tmp till get java asserts
+            sw.write(' : ')
+            sw.write('" assert ')
+            _expr.writeJavaDef(sw)
+            sw.write(' FAILED"')
+            
+        sw.write(';\n')
+        sw.dedent
 
 
 class BlockStmt is partial
@@ -1661 +1813 @@
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
         if _expr.type.isDynamic
-            # if the expression is dynamic, then use an if-else ladder with CobraImp.Equals(
+            # if the expression is dynamic, then use an if-else ladder with CobraImp.equals(
             sw.writeLine('// branch [_expr.toCobraSource]')
             
             varName = '_lh_branch_[.serialNum]'
@@ -1675 +1827 @@
                 sep = ''
                 for e in onPart.exprs
                     sw.write(sep)
-                    sw.write('Cobra.Lang.CobraImp.Equals([varName], ')
+                    sw.write('cobra.lang.CobraImp.equals([varName], ')
                     e.writeJavaDef(sw, false)
                     sw.write(')')
                     sep = ' || '
@@ -1737 +1889 @@
         sw.write('// exactly what is expected\n')
         sw.write('[gotRightExceptionVarName] = true;\n')
         sw.dedentAndWrite('}\n')
-        if _exceptionType inherits Box and not (_exceptionType to Box).isSystemExceptionClass
+        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.Lang.ExpectException(typeof([exceptionTypeRef]), [wrongExceptionVarName]);\n')
+            sw.write('throw new cobra.lang.ExpectException(typeof([exceptionTypeRef]), [wrongExceptionVarName]);\n')
             sw.dedentAndWrite('}\n')
-        sw.write('if (![gotRightExceptionVarName]) throw new Cobra.Lang.ExpectException([exceptionTypeRef].getClass(), null);\n')
+        sw.write('if (![gotRightExceptionVarName]) throw new cobra.lang.ExpectException([exceptionTypeRef].getClass(), null);\n')
 
 
 class ForStmt is partial
@@ -1758 +1910 @@
         varName = _var.javaName
         trackLocals = .compiler.willTrackLocals
         if trackLocals
-            sw.write('for (Cobra.Lang.CobraImp.SetLocal("[.var.name]", [varName]=')
+            sw.write('for (cobra.lang.CobraImp.setLocal("[.var.name]", [varName]=')
         else
             sw.write('for ([varName]=')
         _start.writeJavaDef(sw)
         if trackLocals
             sw.write(')')
         if _var.type.isDynamic
-            sw.write('; Cobra.Lang.CobraImp.DynamicCompare([varName], ')
+            sw.write('; cobra.lang.CobraImp.dynamicCompare([varName], ')
             _stop.writeJavaDef(sw, false)
             sw.write(')[if(_dir==1, "<", ">")]0')
             opName = if(_dir==1, 'op_Addition', 'op_Subtraction')
-            sw.write('; [varName]=Cobra.Lang.CobraImp.DynamicOp("[opName]", [varName], ')
+            sw.write('; [varName]=cobra.lang.CobraImp.dynamicOp("[opName]", [varName], ')
             if _step, _step.writeJavaDef(sw, false)
             else, sw.write('1')
             sw.write(')')
@@ -1800 +1952 @@
         # TODO: this is the old numeric for loop behavior. 
         varName = _var.javaName
         trackLocals = .compiler.willTrackLocals
-        if trackLocals, sw.write('for (Cobra.Lang.CobraImp.SetLocal("[.var.name]", [varName]=')
+        if trackLocals, sw.write('for (cobra.lang.CobraImp.setLocal("[.var.name]", [varName]=')
         else, sw.write('for ([varName]=')
         _start.writeJavaDef(sw)
         if trackLocals
             sw.write(')')
-        sw.write('; Cobra.Lang.CobraImp.DynamicCompare([varName], ')
+        sw.write('; cobra.lang.CobraImp.dynamicCompare([varName], ')
         _stop.writeJavaDef(sw, false)
         sw.write(')[if(_dir==1, "<", ">")]0')
         opName = if(_dir==1, 'op_Addition', 'op_Subtraction')
-        sw.write('; [varName]=Cobra.Lang.CobraImp.DynamicOp("[opName]", [varName], ')
+        sw.write('; [varName]=cobra.lang.CobraImp.dynamicOp("[opName]", [varName], ')
         if _step, _step.writeJavaDef(sw, false)
         else, sw.write('1')
         sw.write(')')
@@ -1875 +2027 @@
             sw.write('int [javaDir] = [javaStep] < 0 ? -1 : +1;\n')
 
         sw.write('for(')
-        if trackLocals, sw.write('Cobra.Lang.CobraImp.SetLocal("[.var.name]", [javaVar] = [javaStart])')
+        if trackLocals, sw.write('cobra.lang.CobraImp.setLocal("[.var.name]", [javaVar] = [javaStart])')
         else, sw.write('[javaVar] = [javaStart]')       
         if isSimpleStep, sw.write('; [javaVar] < [javaStop] ; ')
         else, sw.write('; ([javaDir]==1) ? [javaVar] < [javaStop] : [javaVar] > [javaStop]; ')
-        if trackLocals, sw.write('Cobra.Lang.CobraImp.SetLocal("[.var.name]", [javaVar] += [javaStep])')
+        if trackLocals, sw.write('cobra.lang.CobraImp.setLocal("[.var.name]", [javaVar] += [javaStep])')
         else, sw.write('[javaVar] += [javaStep]')       
         sw.write(') ')
 
@@ -1902 +2054 @@
         # TODO: the javaRef of a type is not qualified and there is no using System.Collections;
         # _what.writeJavaDefInContext(sw, false)
         if _what.type.isDynamic
-            sw.write('Cobra.Lang.CobraImp.GetEnumerable(')
+            sw.write('cobra.lang.CobraImp.getEnumerable(') # TODO shld be getIterable ??
             _what.writeJavaDef(sw, false)
             sw.write(')')
         else
@@ -1911 +2063 @@
         sw.write(')')
         stmt = '[.var.javaName] = [helperName]'
         if .compiler.willTrackLocals
-            stmt = 'Cobra.Lang.CobraImp.SetLocal("[.var.name]", [stmt])'
+            stmt = 'cobra.lang.CobraImp.setLocal("[.var.name]", [stmt])'
         stmt += ';\n'
         _block.writeJavaDef(sw, stmt)
 
@@ -1966 +2118 @@
 
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
-        if _destination
+        if _destination # java Writer
             _destination.writeJavaDef(sw, true)
-            methodName = if(_stop, 'Write', 'WriteLine')
+            methodName = if(_stop, 'write', 'writeLine')
             sw.write('.[methodName](')
         else
-            methodName = if(_stop, 'PrintStop', 'PrintLine')
-            sw.write('Cobra.Lang.CobraImp.[methodName](')
+            methodName = if(_stop, 'printStop', 'printLine')
+            sw.write('cobra.lang.CobraImp.[methodName](')
         sep = ''
         for arg in _args
-            sw.write('[sep]Cobra.Lang.CobraImp._printStringMaker.MakeString(')
+            sw.write('[sep]cobra.lang.CobraImp._printStringMaker.makeString(')
             arg.writeJavaDef(sw)
             sw.write(')')
             sep = '+" "+'
@@ -1986 +2138 @@
 
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
-        sw.write('Cobra.Lang.CobraImp.PushPrintTo(')
+        sw.write('cobra.lang.CobraImp.pushPrintTo(')
         _destination.writeJavaDef(sw, false)
         sw.write(');\n')
         sw.write('try')
         _block.writeJavaDef(sw)
         sw.write('finally {\n')
         sw.indent
-        sw.write('Cobra.Lang.CobraImp.PopPrintTo();\n')
+        sw.write('cobra.lang.CobraImp.popPrintTo();\n')
         sw.dedent
         sw.write('}\n')
 
@@ -2002 +2154 @@
 
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
-        name = .name.capitalized
+        name = .name #.capitalized
         localName = '_lh_event_[.serialNum]'
         sw.writeLine('// raise [.name] ...')
         sw.write('{ [_eventType.javaRef] [localName] = this.[name]; if ([localName]!=null) [localName](')
@@ -2085 +2237 @@
         base.writeJavaDef(sw)
         branch .direction
             on Direction.In,    pass
-            on Direction.Out,   sw.write('out ')  # TODO
-            on Direction.InOut, sw.write('ref ')  # TODO
+            on Direction.Out,   sw.write('/*out*/')  # TODO
+            on Direction.InOut, sw.write('/*ref*/ ')  # TODO
         .writeJavaDef(sw, true)
 
     def writeJavaDef(sw as CurlyWriter, parens as bool)
+        #print 'Expr.writeJavaDef', this
         pass
 
     def writeJavaStmt(sw as CurlyWriter) is override
@@ -2120 +2273 @@
 class NameExpr is partial
 
     get asJava as String
-        return _definition.javaName
+        #print 'Dbg: NameExpr::', _definition.javaName      
+        return _definition.javaName     
 
 
 class AsExpr is partial
@@ -2130 +2284 @@
         sw.write('// [_name] as [_type.name]\n')
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        #print .asJava
         sw.write(.asJava)
-
-
+        
 class AnonymousMethodExpr is partial
 
     # TODO
@@ -2152 +2306 @@
         name = .name
         if _definition inherits BoxMember and (_definition to BoxMember).binaryName
             name = (_definition to BoxMember).binaryName to !
-        else
-            name = name.capitalized
+            # Tmp while remapping .Net libs 
+            if name.startsWithNonLowerLetter
+                name = Utils.cobraNameForNativeMemberName(name) 
+        #else
+        #   name = name.capitalized
+        #trace name
         sw.write('[name]')
         if _genericArgTypes and _genericArgTypes.count
             sw.write('<')
@@ -2214 +2372 @@
         # recall that this cannot be the right side of "foo.bar" since that is a MemberExpr
         java = .javaQualification + .javaName
         if _requiresGetClass, java = java + '.getClass()'
+        #print 'Dbg: IdExpr::', java
         sw.write(java)
 
     get javaQualification as String
@@ -2224 +2383 @@
         else
             pn = .definition.parentNameSpace
             if pn, qual = pn.javaQualifier
+        #print 'Dbg: IdExpr.qual::', qual
         return qual
         
     get javaName as String
@@ -2233 +2393 @@
         if .superNode inherits DotExpr
             assert this is not (.superNode to DotExpr).right  # should be a CallExpr or MemberExpr instead
         defi = .namedDefinition
+        #print 'Dbg: IdExpr.name::', defi.javaName
         return defi.javaName
 
     def _requiresGetClass as bool
@@ -2296 +2457 @@
 
         # tpart:
         src = Utils.javaStringLiteralFor(tpart.toCobraSource)
-        sw.write(', [src], new Cobra.Lang.CobraDirectString(')
+        sw.write(', [src], new cobra.lang.CobraDirectString(')
         cond.writeJavaDefForBreakdown(sw)
-        sw.write(' ? Cobra.Lang.CobraCore.ToTechString(')
+        sw.write(' ? cobra.lang.CobraCore.toTechString(')
         tpart.writeJavaDefForBreakdown(sw)
         sw.write(') : "(not-evaluated)")')
 
         # fpart:
         src = Utils.javaStringLiteralFor(fpart.toCobraSource)
-        sw.write(', [src], new Cobra.Lang.CobraDirectString(')
+        sw.write(', [src], new cobra.lang.CobraDirectString(')
         cond.writeJavaDefForBreakdown(sw)
-        sw.write(' ? "(not-evaluated)" : Cobra.Lang.CobraCore.ToTechString(')
+        sw.write(' ? "(not-evaluated)" : cobra.lang.CobraCore.toTechString(')
         fpart.writeJavaDefForBreakdown(sw)
         sw.write('))')
 
@@ -2317 +2478 @@
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
         if _target.type.isDynamic
-            sw.write('Cobra.Lang.CobraImp.GetIndexerValue(')
+            sw.write('cobra.lang.CobraImp.getIndexerValue(')
             _target.writeJavaDef(sw, false)
             for expr in _args
                 sw.write(', ')
@@ -2380 +2541 @@
         _expr.writeJavaBreakdownItems(sw)
 
 
+class TruthExpr
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        lparen = if(parens, '(', '')
+        rparen = if(parens, ')', '')
+        branch _treatment
+            on Treatment.AsIs
+                _expr.writeJavaDef(sw, parens)
+            on Treatment.InvokeRuntime
+                sw.write('CobraLangInternal.CobraImp.IsTrue(')
+                _expr.writeJavaDef(sw, false)
+                sw.write(')')               
+            on Treatment.CompareToZero
+                sw.write('[lparen]0!=')
+                _expr.writeJavaDef(sw, true)
+                sw.write(rparen)
+            on Treatment.CompareToZeroChar
+                sw.write("[lparen]'\\0'!=")
+                _expr.writeJavaDef(sw, true)
+                sw.write(rparen)
+            on Treatment.CompareToNull
+                sw.write('[lparen]null!=')
+                _expr.writeJavaDef(sw, true)
+                sw.write(rparen)
+
+    def writeJavaBreakdownItems(sw as CurlyWriter) is override
+        # leaving out the base class is intentional:
+        # base.writeJavaBreakdownItems(sw, isFirstExpr)
+        _expr.writeJavaBreakdownItems(sw)
+        
+    
+class TypeExpr
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        javaRef = _containedType.javaRef 
+        # handle the case of "X.X" where namespace and class are both called "X".
+        # C# chokes on it because the first "X" is considered to be the type
+        #if .curBox.name + '.' in javaRef
+        #   javaRef = 'global::' + javaRef
+        if _requiresTypeOf()
+            sw.write('typeof(')
+            sw.write(javaRef)
+            sw.write(')')
+        else
+            sw.write(javaRef)
+
+/#  def _requiresTypeOf as bool
+        # Cobra never requires that you wrap a type reference in typeof(Foo).
+        # C# requires typeof() in a variety of circumstances and won't accept it in a variety of others.
+        superNode = .superNode
+        if superNode is nil
+            return false
+        else
+            if superNode inherits DotExpr
+                return false
+            if superNode inherits PostCallExpr
+                # could be Type(foo) or _bar(Type)
+                # in C#, the second requires `typeof` and the first won't take it
+                if superNode.expr is this
+                    return false
+            if superNode inherits BinaryOpExpr
+                if this is superNode.right
+                    if superNode inherits InheritsExpr or superNode inherits AbstractToExpr
+                        return false
+            return true
+            #/
+            
+    def writeJavaDefForBreakdown(sw as CurlyWriter) is override
+        requiresTypeOf = _requiresTypeOf # using C# version currently - chop ?
+        if not requiresTypeOf, sw.write('typeof(')
+        .writeSharpDef(sw)
+        if not requiresTypeOf, sw.write(')')
+
+        
+class UnaryOpExpr
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if _op == 'PLUS'
+            if parens
+                sw.write('(')
+            _expr.writeJavaDef(sw, false)
+            if parens
+                sw.write(')')
+            return
+        if _expr.type.isDynamic
+            specs = OperatorSpecs.unaryOpSpecsByCobraText
+            assert specs.containsKey(.token.text)
+            spec = specs[.token.text]
+            opText = Utils.javaStringLiteralFor(spec.opMethodName)
+            sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+            _expr.writeJavaDef(sw, false)
+            sw.write(')')
+            return
+        if parens
+            sw.write('(')
+        branch _op
+            on 'MINUS'
+                sw.write('-')
+            on 'TILDE'
+                sw.write('~')
+            on 'NOT'
+                sw.write('!')
+            else
+                throw FallThroughException(_op)
+        _expr.writeJavaDef(sw)
+        if parens
+            sw.write(')')
+
+    def writeJavaBreakdownItems(sw as CurlyWriter)
+        base.writeJavaBreakdownItems(sw)
+        sw.write(', +1')
+        _expr.writeJavaBreakdownItems(sw)
+        sw.write(', -1')
+
+        
+        
+class Literal
+    is partial
+
+    def asJava as String
+        return '/* TODO_Literal */'
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        sw.write(.asJava)
+
+
+class AtomicLiteral
+    is partial
+
+    get willWriteJavaBreakdownItems as bool is override
+        return false
+
+class IntegerLit is partial
+
+    def asJava as String is override
+        s = ''
+        if (info = .token.info) inherits int
+            branch info
+                on - 8, s = 'byte'   # java.lang.Byte
+                on + 8, s = 'short'  # unsigned Byte uint8
+                on -16, s = 'short'  #'Int16'
+                on +16, s = 'int'    # unsigned short UInt16'
+                on -32, s = 'int'    # int32
+                on +32, s = 'long'   # unsigned int32
+                on -64, s = 'long'
+                on +64, s = 'long'   # unsigned int64
+                else, throw FallThroughException(info)
+        if s.length <= 2
+            return _value.toString + s
+        else
+            return '([s])[_value.toString]'
+        
+class BoolLit
+    is partial
+
+    def asJava as String is override
+        return if(_value, 'true', 'false')
+
+
+class CharLit
+    is partial
+
+    def asJava as String is override
+        if _value[0] to int == 39, return "'\\''"  # single quote
+        else, return "'" + _value.toString + "'"
+            
+        
+class NilLiteral
+    is partial
+
+    def asJava as String is override
+        return 'null'
+
+class StringLit is partial
+
+    def asJava as String is override
+        return Utils.javaStringLiteralFor(_string)
+    
+class StringSubstLit is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if _items.count>1
+            sw.write('cobra.lang.CobraImp._printStringMaker.makeString(')
+        sep = ''
+        for item in _items
+            sw.write(sep)
+            if item inherits StringLit
+                item.writeJavaDef(sw, true)  # CC: axe the "true" when the bug about overload groups crossing inheritance is fixed
+            else if item inherits FormattedExpr
+                sw.write('cobra.lang.CobraImp._printStringMaker.makeString(')
+                item.expr.writeJavaDef(sw)
+                sw.write(',')
+                sw.write(Utils.javaStringLiteralFor(item.format))
+                sw.write(')')
+            else
+                sw.write('cobra.lang.CobraImp._printStringMaker.makeString(')
+                item.writeJavaDef(sw, false)
+                sw.write(')')
+            sep = ','
+        if _items.count>1
+            sw.write(')')
+
+class BaseLit is partial
+
+    def asJava as String is override
+        return 'super'
+
+
+class ThisLit is partial
+
+    def asJava as String is override
+        return .compiler.curBox.javaThis
+
+
+class VarLit is partial
+
+    def asJava as String is override
+        return _name
+
+        
+            
 ##
+## Binary Expressions
+##
+
+class BinaryOpExpr is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('(')
+        _writeJavaDef(sw)
+        if parens, sw.write(')')
+
+    def _writeJavaDef(sw as CurlyWriter)
+        sw.write('/* TODO_BinaryOp */')
+        # pass
+
+    def writeJavaBreakdownItems(sw as CurlyWriter)
+        base.writeJavaBreakdownItems(sw)
+        sw.write(', +1')
+        _writeJavaBreakdownItemsLeft(sw)
+        _writeJavaBreakdownItemsRight(sw)
+        sw.write(', -1')
+
+    def _writeJavaBreakdownItemsLeft(sw as CurlyWriter)
+        _left.writeJavaBreakdownItems(sw)
+
+    def _writeJavaBreakdownItemsRight(sw as CurlyWriter)
+        _right.writeJavaBreakdownItems(sw)
+
+        
+class AbstractAssignExpr is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if _trackLocal
+            sw.write('CobraLangInternal.CobraImp.SetLocal("[_trackName]", ')
+        else if parens
+            sw.write('(')
+        _writeJavaDef(sw)
+        if _trackLocal or parens
+            sw.write(')')
+
+
+class AssignExpr is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        # TODO:
+        # if trackLocal:
+        #   out.write('CobraLangInternal.CobraImp.SetLocal("%s", ' % .left.name)
+        if _left inherits IndexExpr
+            if _left.target.type.isDynamic
+                # assigning to an indexer of a dynamically typed target requires special code gen
+                sw.write('CobraLangInternal.CobraImp.SetIndexerValue(')
+                _left.target.writeJavaDef(sw, false)
+                sw.write(', ')
+                _right.writeJavaDef(sw, false)
+                for expr in _left.args
+                    sw.write(', ')
+                    expr.writeJavaDef(sw, false)
+                sw.write(')')
+                return
+        handled = false
+        if _left inherits IdentifierExpr
+            names = _left.javaAssignmentNames
+            if names and names.count
+                names.reverse
+                for i in names.count
+                    sw.write(if(i==0, '', '='))
+                    assert names[i].length
+                    sw.write(names[i])
+            else
+                assert _left.javaName <> ''
+                sw.write(_left.javaName)
+            handled = true
+        if not handled
+            # `obj.foo = bar` where `obj` is dynamic, requires special handling
+            if _left inherits DotExpr
+                if _left.left.type.isDynamic
+                    assert _left.right inherits MemberExpr
+                    sw.write('CobraLangInternal.CobraImp.setPropertyValue(')
+                    _left.left.writeJavaDef(sw, false)
+                    sw.write(', ')
+                    sw.write(Utils.javaStringLiteralFor((_left.right to MemberExpr).name))
+                    sw.write(', ')
+                    _right.writeJavaDef(sw)
+                    sw.write(')')
+                    return
+        if not handled
+            # for something like "p.total = 0", cannot generate "(p.Total)=0" because then C# sees
+            # the left hand side as an r-value instead an l-value/target. hence the false below.
+            _left.writeJavaDef(sw, false)
+        sw.write('=')
+        _right.writeJavaDefInContext(sw)
+        # handle the case where a type got backed up because of assignment inside of an if-inherits
+        if _backUpIfInheritsStack
+            assert _left.definition inherits IVar
+            _left.definition.ifInheritsStack = Stack<of IType>(_backUpIfInheritsStack)
+
+class CompareExpr
+    is partial
+
+    var _cobraToJava = {
+        'EQ': '==',
+        'NE': '!=',
+        'GT': '>',
+        'LT': '<',
+        'GE': '>=',
+        'LE': '<=',
+        'IS': '==',
+        'ISNOT': '!=',
+    }
+    
+    def _writeJavaDef(sw as CurlyWriter) is override
+        left = _left
+        right = _right
+        op = _op
+        # Compute the java operation which will be an operator or method call
+        if op=='EQ' or op=='NE'
+            if not left.type.isReference and not right.type.isReference
+                # struct/value types
+                #if not left.type inherits PrimitiveType and not right.type inherits PrimitiveType
+                #   # user-defined structs
+                #   op = '.Equals('
+                #else
+                #   # primitives like ints and decimals (even mixed like someDecimal == someInt)
+                #   op = _cobraToJava[_op]
+                op = _cobraToJava[_op]
+            else
+                done = false
+                stringType = .compiler.stringType
+                if left.isKindOf(stringType) and right.isKindOf(stringType)  # TODO: check for static comparison operations instead
+                    op = _cobraToJava[_op]
+                    done = true
+                else if left.type inherits Box  # TODO: try skipping on requiring that the type is a Box
+                    leftBox = left.type to Box
+                    compareTo = leftBox.memberForName('compareTo')
+                    if compareTo and compareTo.isMethod and compareTo.resultType.isDescendantOf(.compiler.anyIntType) and right.type.isDescendantOf(leftBox)  # need last condition to prevent someString.CompareTo(someChar)
+                        op = '.compareTo('
+                        done = true
+                if not done
+                    assert op in ['EQ', 'NE']
+                    assert op == .token.which
+                    op = '.equals('
+        else if op=='IS' or op=='ISNOT'
+            if left.type inherits PrimitiveType and right.type inherits PrimitiveType
+                op = _cobraToJava[_op]
+            else if left.type.isReference and right.type.isReference
+                op = if(op=='IS', ' instanceof ', '! instanceof ')
+            else
+                # non-trivial situation.. fall back to runtime support
+                op = if(op=='IS', 'CobraLangInternal.CobraImp.Is(', 'CobraLangInternal.CobraImp.IsNot(')
+        else
+            if left.type.isDynamic or right.type.isDynamic
+                sw.write('CobraLangInternal.CobraImp.DynamicCompare(')
+                left.writeJavaDef(sw, false)
+                sw.write(', ')
+                right.writeJavaDef(sw, false)
+                sw.write(')[_cobraToJava[_op]]0')
+                return
+            else
+                done = false
+                if left.type inherits Box  # TODO: try skipping on requiring that the type is a Box
+                    leftBox = left.type to Box
+                    compareTo = leftBox.memberForName('compareTo')
+                    if compareTo and compareTo.isMethod and compareTo.resultType.isDescendantOf(.compiler.anyIntType) and left.type == right.type  # need last condition to prevent someString.CompareTo(someChar)
+                        op = '.compareTo('
+                        done = true
+                if not done
+                    op = _cobraToJava[_op]
+        # Write the Java code
+        if op.length <= 2
+            left.writeJavaDef(sw)
+            sw.write(op)
+            right.writeJavaDef(sw)
+        else if op == '.equals('
+            if _op == 'NE', sw.write('!(')
+            left.writeJavaDef(sw)
+            sw.write(op)
+            right.writeJavaDef(sw, false)
+            sw.write(')')
+            if _op == 'NE', sw.write(')')
+        else if op == '.compareTo('
+            left.writeJavaDef(sw)
+            sw.write(op)
+            right.writeJavaDef(sw, false)
+            sw.write(') [_cobraToJava[_op]] 0')
+        else if op.endsWith('(')
+            sw.write(op)
+            left.writeJavaDef(sw)
+            sw.write(',')
+            right.writeJavaDef(sw)
+            sw.write(')')
+        else
+            throw FallThroughException(op)
+
+class ChainedCompareExpr is partial
+    
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('(')
+        .writeJavaDef(sw)
+        if parens, sw.write(')')
+    
+    def writeJavaDef(sw as CurlyWriter) is override
+        sw.write('CobraLangInternal.CobraCore.ChainedComparison(')
+        _items[0].writeJavaDef(sw)
+        itemIndex = 1
+        for operation in _operations
+            sw.write(', "[operation]", ')
+            _items[itemIndex].writeJavaDef(sw)
+            itemIndex += 1
+        sw.write(')')
+        
+    
+class DotExpr
+    is partial
+
+/#  def needsContextCast as bool  # in SharpGenerator
+        r = base.needsContextCast
+        if not r
+            r = .left.type.isDynamic
+            # Why isn't the base implementation sufficient?
+            # Because for `d.getType` where `d` is dynamic, the type of `d.getType` is *not*.
+            # It`s System.Type because `getType` is recognized as an Object method.
+            # This would confuse the code generation into thinking that `d.getType` is a statically typed expression.
+        return r
+#/
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if _left.receiverType.isDynamic
+            # handle dynamic typing
+            if _dotRightExpr.definition
+                sw.write('(' + _dotRightExpr.type.javaRef + ')')
+            if _right inherits MemberExpr
+                sw.write('CobraLangInternal.CobraImp.GetPropertyValue(')
+                _left.writeJavaDef(sw, not _left inherits DotExpr)
+                sw.write(', ')
+                sw.write(Utils.javaStringLiteralFor(_right.name)) # was .capitalized
+                sw.write(')')
+            else if _right inherits CallExpr
+                sw.write('CobraLangInternal.CobraImp.InvokeMethod(')
+                _left.writeJavaDef(sw, not _left inherits DotExpr)
+                sw.write(', ')
+                sw.write(Utils.javaStringLiteralFor(_right.name))   # was .capitalized
+                for arg in _right.args
+                    sw.write(', ')
+                    arg.writeJavaDef(sw, false)
+                sw.write(')')
+            else
+                throw FallThroughException(_right)
+        else
+            # Given Cobra "A.B.C()" where C is a class/type/struct, then the java needs to be "new A.B.C()"
+            # (But stuff like this makes me wonder if the ASTs should be doing some transformations, like collapsing qualified types.)
+            if _dotRightExpr.memberDefinition inherits BoxMember
+                backing = _dotRightExpr.definition.sharedMethodBacking
+                if backing
+                    # example:  Cobra: c.isUpper   C#: char.IsUpper(c)
+                    # also used for extension methods under .NET 2.0
+                    sw.write(backing+'(')
+                    if not (_dotRightExpr.memberDefinition to BoxMember).sharedMethodBackingIsAlias  # guard against Cobra "decimal.parse('5.0')" --> C# "Decimal.Parse(decimal, "5.0")"
+                        _left.writeJavaDef(sw, false)
+                        sep = ', '
+                    else
+                        sep = ''
+                    if _right inherits CallExpr
+                        for arg in _right.args
+                            sw.write(sep)
+                            arg.writeJavaDefInContext(sw)
+                            sep = ', '
+                    sw.write(')')
+                    return
+            # handle static typing
+            # don't write 'this' for shared members
+            writeThis = true
+            if _left inherits ThisLit
+                writeThis = not _dotRightExpr.memberDefinition.isShared
+            else if .curCodeMember inherits Initializer and _right inherits IDotRightExpr and (_right to IDotRightExpr).name == 'init' and _left inherits ThisOrBaseLit
+                Stmt.inInitCall = true
+                didSetInInitCall = true
+                writeThis = false
+            if writeThis
+                if _left.needsContextCast
+                    _left.writeJavaDefInContext(sw)
+                else
+                    _left.writeJavaDef(sw, not _left inherits DotExpr)
+                sw.write('.')
+            #print 'Dbg: dotExpr::', _left.toCobraSource, _right.toCobraSource
+            _right.writeJavaDef(sw, false)
+            if didSetInInitCall
+                Stmt.inInitCall = false
+
+    def _writeJavaBreakdownItemsLeft(sw as CurlyWriter) is override
+        _left.writeJavaBreakdownItems(sw)
+
+
+
+class CoalesceExpr
+    is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        # (L != null ? L : R )
+        sw.write('((')
+        _left.writeJavaDef(sw)
+        sw.write(') != null ? ')
+        _left.writeJavaDef(sw)
+        sw.write(' : ')
+        _right.writeJavaDef(sw)
+        
+class CoalesceAssignExpr
+    is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        # L = (L != null ? L : R )
+        _left.writeJavaDef(sw)
+        sw.write(' = ')
+        sw.write('((')
+        _left.writeJavaDef(sw)
+        sw.write(') != null ? ')
+        _left.writeJavaDef(sw)
+        sw.write(' : ')
+        _right.writeJavaDef(sw)
+
+        
+class MemberExpr
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        assert .superNode inherits DotExpr
+        if _definition inherits BoxMember
+            name = _definition.binaryName
+        #if name is nil
+        #   name = _name.capitalized
+        if name is nil
+            name = _name
+        #print 'Dbg: MemberExpr::', name
+        sw.write(name)
+        if _definition and (_definition.isMethod or _name=='toString') and not _isReference  # TODO: axe the 'toString' check
+            sw.write('()')
+
+    def writeJavaBreakdownItems(sw as CurlyWriter) is override
+        pass
+
+class SharpExpr
+    is partial
+
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('(')
+        if _sharpSource
+            sw.write(_sharpSource)
+        else
+            sw.write(_expr.token.value)
+        if parens, sw.write(')')
+
+##
 ## Temporary
 ##
 
@@ -2391 +3126 @@
     def writeJavaTestInvocation(sw as CurlyWriter)
         pass
 
-class IntegerLit is partial
-
-    def asJava as String
-        return 'TODO'
-
 class EnumMember is partial
 
     def writeJavaTestInvocation(sw as CurlyWriter)
@@ -2404 +3134 @@
 class Extension is partial
 
     get javaKeyWord as String is override
-        return ''
+        return 'TODO_Extension'
     
     get javaInvariantVisibility as String is override
         return ''
@@ -2422 +3152 @@
     shared
 
         def javaStringLiteralFor(args as vari dynamic) as String
-            # TODO:
-            for arg in args, return arg
-            return ''
+            sb = StringBuilder()
+            for arg in args 
+                sb.append(Utils.sharpStringLiteralFor(arg to String))
+            return sb.toString
 
 class ThisOrBaseLit is partial
 
-    def asJava as String
+    def asJava as String is override
         return 'this'
-
+        
 class ContractPart is partial
 
     def writeJavaMethod(args as vari dynamic)
         pass
+        
+    
+class JavaBackEndUtils
+    # copied fm SharpGenerator and keywds corrected:  chg entire method Vars.cobra:AbstractLocalVar,_init
+    shared
+
+        var _backEndKeyWordList = 'assert boolean break byte case catch char class const continue default do double else extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while'.split
+            # C#    'abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while'.split
+        var _backEndKeyWordSet = Set<of String>()
+
+        def isBackEndKeyWord(word as String) as bool
+            """
+            Returns true if the given word is a keyword in Java6
+            """
+            require
+                word.length
+            test
+                assert .isBackEndKeyWord('byte')
+                assert .isBackEndKeyWord('if')
+                assert .isBackEndKeyWord('while')
+                assert not .isBackEndKeyWord('total')
+            body
+                if _backEndKeyWordSet.count == 0
+                    for word in _backEndKeyWordList
+                        _backEndKeyWordSet.add(word)
+                return word in _backEndKeyWordSet
+
+        def backEndNameForLocalVarName(name as String) as String
+            if .isBackEndKeyWord(name)
+                return '$' + name  # Java supports $ as a prefix 
+            return name
+        

Source/Enums.cobra

@@ +1 @@
+
 class EnumDecl
     is partial
     inherits Container<of EnumMember>
@@ -25 +26 @@
         _idToken = Token.empty
         _attribs = AttributeList()
         _nativeType = nativeType
-        _storageTypeNode = ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).clrType))  # TODO: fix native
+        #_storageTypeNode = ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).backEndType))  # TODO: fix native
+        _callNativeScanMethod('UnderlyingType')
         _needScanNativeType = true
-
-    def _scanClrType
-        # TODO: read attribs
-        _needScanNativeType = false
-        clrType = (_nativeType to ClrNativeType).clrType # TODO: fix native
-        isByte  = Enum.getUnderlyingType(clrType).name == 'Byte'
-        is64    = Enum.getUnderlyingType(clrType).name == 'Int64'
-        isU32   = Enum.getUnderlyingType(clrType).name == 'UInt32'
-        isU64   = Enum.getUnderlyingType(clrType).name == 'UInt64'
-        values  = Enum.getValues(clrType)
-        i = 0
-        for name in Enum.getNames(clrType)
-            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
-
+        
+    def _callNativeScanMethod(tag as String)
+        """
+        Call a backend scan method for native type scan operation desired and backend in use.
+        """
+        _needScanNativeType = true
+        # This is icky too - method to call needs to be set directly via backend somehow rather than this check and call code   
+        # TODO: change to use strategy object set when init backend.
+        assert .compiler
+        assert tag in ['ScanNativeType', 'UnderlyingType']
+        backEnd = .compiler.backEnd
+        branch backEnd.name
+            on 'c#-clr'
+                branch tag
+                    on 'UnderlyingType',  _setUnderlyingTypeClr # sets _storageTypeNode
+                    on 'ScanNativeType',  _scanNativeTypeClr
+            on 'java-jvm'
+                branch tag
+                    on 'UnderlyingType',  _setUnderlyingTypeJvm # sets _storageTypeNode
+                    on 'ScanNativeType',  _scanNativeTypeJvm
+            on 'objc'
+                print 'objc back end need method for [tag]'
+                assert false, 'Missing backEnd infrastructure for [backEnd.getType.name]'
+                #branch on tag
+                #   on 'UnderlyingType',  _setUnderlyingTypeObjc
+                #   on 'ScanNativeType',  _scancNativeTypeObjc
+            else 
+                throw FallThroughException('No nativeScanMethod code for backend [backEnd.name] [backEnd.getType.name]')
+        #TODO: remove all direct uses of ClrNativeType, ClrTypeProxy
+        
     get attributes as AttributeList is override
         return _attribs
 
@@ -99 +93 @@
             return base.isUsed
         set
             base.isUsed = value
-            if _needScanNativeType
-                _scanClrType
+            if _needScanNativeType, _callNativeScanMethod('ScanNativeType')
 
     get nativeType from var
     
@@ -117 +110 @@
             _storageType = _storageTypeNode.realType
             if not _storageType.isDescendantOf(.compiler.anyIntType)
                 .throwError('The enumeration storage type must be a primitive integer type such as int8, uint8, int16, uint16, int, uint, int64 or uint64.')
-        if _needScanNativeType
-            _scanClrType
+        if _needScanNativeType, _callNativeScanMethod('ScanNativeType')
 
     def _bindImp is override
         base._bindImp
@@ -132 +124 @@
         return name
 
     def memberForName(name as String) as IMember?
-        if _needScanNativeType
-            _scanClrType
+        if _needScanNativeType, _callNativeScanMethod('ScanNativeType')
         m = base.memberForName(name)
         if m is nil
             objClass = .compiler.objectType

Tests/320-misc-two/800-attributes/130-attributes-tricky-names.cobra

@@ -8 +8 @@
 with no warnings or errors.
 """
 use System.Xml
-use System.Xml.Linq
 use System.Xml.Serialization
 
 class Season has Serializable