Ticket #275: java-jvm-part1.patch

Source/TypeProxies.cobra

@@ -3 +3 @@
     """
     An ITypeProxy is a node that represents/stands-in for a type.
     Its .realType property returns that type, often by locating it among symbols.
-    Implemented by CobraType, AbstractTypeIdentifier, NilableTypeProxy and ClrTypeProxy.
+    Implemented by CobraType, AbstractTypeIdentifier, NilableTypeProxy and the backEnd TypeProxies.
     """
 
     # TODO: See above NOTE and consider adding name below. Also see _bindBase in Boxes.cobra which would benefit from .name
@@ -110 +110 @@
         return VariType(_innerType.realType)
 
 
-class ClrTypeProxy inherits AbstractTypeProxy
+class NativeTypeProxy inherits AbstractTypeProxy is abstract
     """
-    Acts as an ITypeProxy where the CLR type is known.
-    Typically used when scanning DLLs.
+    TypeProxy specifically for a BackEnd provided Type otherwise same as an AbstractTypeProxy
+        Specific implementation will be provided by the backend e.g. {Clr,Jvm}TypeProxy
     """
 
-    shared
-
-        var _cobraNameForSharpGenericNameCache = Dictionary<of String, String>()
-
-        def cobraNameForSharpBoxName(name as String) as String
-            """
-            Returns 'Foo' for 'Foo' and 'Foo<of,>' for 'Foo`2'
-            In other words, works for generic and non-generic classes, structs and interfaces.
-            Does *not* work for arrays, pointers, etc.
-            """
-            if '`' not in name
-                return name
-            if _cobraNameForSharpGenericNameCache.containsKey(name)
-                return _cobraNameForSharpGenericNameCache[name]
-            else
-                parts = name.split(c'`')
-                count = int.parse(parts[1])
-                cobraName = parts[0] + '<of'
-                for i in count-1, cobraName += ','
-                cobraName += '>'
-                _cobraNameForSharpGenericNameCache[name] = cobraName
-                return cobraName
-
-    var _clrType as Type
-
-
-    cue init(nativeType as NativeType)  # TODO: HACK
-        .init((nativeType to ClrNativeType).clrType)
-
-    cue init(clrType as Type)
-        base.init
-        _clrType = clrType
-
-    def addMinFields
-        base.addMinFields
-        .addField('clrType', _clrType)
-
-    get realType as IType is override
-        return _realTypeWithCache(_clrType)
-
-    def _realTypeWithCache(clrType as Type) as IType
-        t = (.compiler to Compiler).typeForClrType(clrType)
-        if t is nil
-            t = _realTypeWithoutCache(clrType, 0)
-            (.compiler to Compiler).addTypeForClrType(t to !, clrType)
-        return t to !
-    
-    def _realTypeWithoutCache(clrType as Type, 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.
-        clrPrimitiveToIType = .compiler.clrPrimitiveToITypeCache
-        if clrPrimitiveToIType is nil or clrPrimitiveToIType.count == 0
-            clrPrimitiveToIType = _makePrimitiveTypesDict
-        basicType as IType?
-        if clrPrimitiveToIType.tryGetValue(clrType, out basicType)
-            return basicType to !
-        
-        # handle wrapped types, like arrays and pointers, with recursive calls
-        if clrType.isArray
-            # assert clrType.name.endsWith(r'[]') # could be [,] so TODO: handle multidim arrays
-            return .typeProvider.arrayType(_realTypeWithCache(clrType.getElementType to !))
-        else if clrType.isNested and not clrType.isGenericParameter
-            declaringType = _realTypeWithCache(clrType.declaringType to !)
-            potential = declaringType.memberForName(clrType.name)
-            if potential is nil
-                # comes up on MS Windows .NET 2.0 for multiple types when using System.Windows.Forms
-                # error: Cannot locate nested CLR type "System.Windows.Forms.UnsafeNativeMethods+IOleControl" (simple name is "IOleControl").
-                if 'NativeMethods' in clrType.toString
-                    return _hack(clrType)
-                .throwError('Cannot locate nested CLR type "[clrType]" (simple name is "[clrType.name]").')
-            else if potential inherits IType
-                return potential
-            else
-                .throwError('Located CLR type spec "[clrType]" but got a [potential.englishName] instead of a type.')
-        else if clrType.isPointer
-            assert clrType.name.endsWith('*')
-            # TODO: handle pointer types
-            return _realTypeWithCache(clrType.getElementType to !)
-        else if clrType.isByRef
-            assert clrType.name.endsWith('&')
-            # TODO: handle ref types
-            return _realTypeWithCache(clrType.getElementType to !)
-
-        # generic parameters
-        if clrType.isGenericParameter
-            return GenericParam(ClrNativeType(clrType))
-
-        typeName = _computeTypeName(clrType)
-        missing = false
-        curNS = _computeNameSpace(clrType, level, out missing)
-        if missing
-            # since the CLR 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 CLR type "[clrType.fullName]" or its assembly "[clrType.assembly]". Please report to the Cobra discussion forums (http://cobra-language.com/).')
-
-            (.compiler to dynamic).readAssembly(clrType.assembly)
-            return _realTypeWithoutCache(clrType, 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 clrType.isGenericType and not clrType.isGenericTypeDefinition
-                    # So we have something like ICollection<of KeyValuePair<of TKey,TValue>> which is all CLR 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.
-                    member = _typeForArgsOfGeneric(clrType, member)
-            return member
-        else
-            msg = 'Cannot locate CLR type "[clrType]".'
-            if clrType.namespace and clrType.namespace.startsWith('System.')
-                # TODO: On .NET 2.0 only \Tests\110-basics-two\550-collection-equality.cobra
-                # fails with: Cannot locate CLR type "System.Collections.KeyValuePairs[]".
-                # Figure out why.
-                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 _makePrimitiveTypesDict as Dictionary<of System.Type, IType>
-        clrPrimitiveToIType = Dictionary<of System.Type, IType>()
-        for bt in .compiler.basicTypes
-            if bt.systemAliasProxy
-                key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType # TODO: cleanup
-                clrPrimitiveToIType[key] = bt
-        assert clrPrimitiveToIType.count == 0 or clrPrimitiveToIType.count > 9
-        return clrPrimitiveToIType
-
-    def _computeTypeName(clrType as Type) as String
-        typeName = clrType.name
-        if '`' in typeName
-            # generic like IComparable`1
-            assert r'[' not in typeName
-            typeName = .cobraNameForSharpBoxName(typeName)
-        else if typeName[typeName.length-1].isLetterOrDigit
-            pass
-        else
-            .throwError('Cannot locate CLR type "[clrType]".')
-        return typeName
-
-    def _computeNameSpace(clrType as Type, level as int, missing as out bool) as NameSpace
-        missing = false
-        if clrType.namespace is nil, return .compiler.globalNS
-        nameParts = clrType.namespace.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 CLR type "[clrType.fullName]", but it is a [possible.englishName].')
-                i += 1
-        return curNS    
-
-    def _typeForArgsOfGeneric(clrType as Type, member as IType) as IType
-        args = List<of IType>()
-        for genArg in clrType.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 _hack(clrType as Type) as IType
-        if clrType.isInterface
-            return ClrTypeProxy(sharp'typeof(System.ICloneable)').realType
-        else
-            return ClrTypeProxy(Object).realType
-
-
 ##
 ## Type Identifiers
 ##

Source/BackEndObjC/ObjcBackEnd.cobra

@@ +1 @@
+use System.Diagnostics
+
 class ObjcBackEnd inherits BackEnd
 
     cue init(compiler as Compiler)
@@ -2 +4 @@
         base.init(compiler)
+        _name = 'objc'  
+        _rtlName = 'Cobra.Lang.dll'
+        _tagToTypeName = {  # TODO
+            'Object': '',
+            'Type'  : '',
+            }
 
@@ -9 +17 @@
 
     def computeOutName as String is override
         return .compiler.computeOutNameObjc
+        
+    def genNativeModule(filename as String, verbosity as int) as Module? is override
+        m as Module?
+        if filename.endsWith('.objc') # ??
+            if verbosity, print 'Noting  [filename] as ObjCModule'  # extra space to line up with 'Parsing [filename]'
+            assert false, 'Need code for an ObjCModule' 
+            #m = ObjCModule(filename, verbosity)
+        return m
 
+    def setupRunProcess(baseExe as String, fullExe as String) as Process is override
+        p = Process()
+        p.startInfo.fileName = baseExe
+        return p
+        
+    def setDefaultUseDirectives(ns as NameSpace) is override
+        useToken = Token('(implicit)', 1, 1, 1, 'USE', 'use', nil)
+        # these arent correct for ObjC but are here as a placeholder/reminder
+        ns.addUseDirective(UseDirective(useToken, ['System']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'Collections', 'Generic']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'IO']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'Text']))
+        ns.addUseDirective(UseDirective(useToken, ['Cobra', 'Lang']))
+    
+    def fixLibExtension(libRef as String) as String is override
+        """
+        Augment given lib reference string with .dll backend extension if not already have one
+        """
+        or require libRef.length
+        and ensure result.endsWith('.dll')
+        if not libRef.endsWith('.dll')
+            libRef += '.dll'
+        return libRef
+    
+    def loadLibReference(reference as String) as bool is override
+        return false    # TODO
+    
+    def readSystemTypes is override
+        pass
+    
+    def fixNilableMemberSigs is override
+        pass
 
+    def installNativeMethods(box as Box, nativeType as NativeType) is override
+        pass
+
+    def cobraNameForNativeBoxName(nativeBoxName as String) as String is override
+        return nativeBoxName # TODO
+        
+    # Types
+    get objectTypeProxy as AbstractTypeProxy  is override
+        """Type proxy for BE root of Object hierarchy."""
+        return ClrTypeProxy(Object)  # Tmp pending ObjcTypeProxy
+            
+    get typeTypeProxy  as AbstractTypeProxy  is override
+        """Type proxy for BE notion of a class describing a Type."""
+        return ClrTypeProxy(Type)  # Tmp pending ObjcTypeProxy
+        
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is override
+        assert false, 'ObjcBackEnd ObjcNativeTypeProxy NYI'
+        return ClrTypeProxy(type)  # Tmp pending ObjcTypeProxy
+    
+    def nativeType(type as dynamic) as NativeType  is override
+        assert false, 'ObjcBackEnd ObjcNativeType NYI'
+        return ClrNativeType(type) # Tmp pending ObjcNativeType
+    
+    def nativeTypeByName(qualifiedName as String) as NativeType is override
+        assert false, 'ObjcBackEnd ObjcNativeType and objcTypeByName NYI'
+        return ClrNativeType(.compiler.clrTypeByName(qualifiedName))
+    
+    def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override
+        assert false, 'ObjcBackEnd addArrayInterfaces NYI'
+        
+    
+        
 class GenerateObjcCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/Compiler.cobra

@@ -29 +29 @@
 
     cue init(obj as Object)
         base.init('Not expecting invocation.')
+        
+class LoadReferenceException inherits Exception
+    """
+    Thrown when Loading a reference fails for some reason.
+        FileNotFoundException, FileLoadException
+    """
+    var fileName =''
+    var tag=''
+    
+    cue init(tag as String, fileName as String, msg as String)
+        base.init(msg)
+        .tag = tag
+        .fileName = fileName
+        
+    def toString as String is override
+        return '[.tag] [.fileName] [.message]'  
 
-
 enum PlatformEnum
     Microsoft
     Novell
 
-
-class BackEnd is abstract
+    
+# Should this be in BackEndCommon ?
+class BackEnd is abstract 
     """
-    Subclasses will often inspect the compiler for various options such as .willWriteTestInvocation.
+    Holder for items specific to the backEnd implementation
     """
-
+    
+    var _tagToTypeName = Dictionary<of String, String>()
+        """ Map from Typename tags used in compiler to backend specific qualified Type name"""
+    
     cue init(compiler as Compiler)
         base.init
+        _name = ''
+        _rtlName = 'rtl'
         __compiler = compiler
 
+    get name from var as String
+    
+    get cobraRuntimeLibFile from _rtlName as String 
+
     get compiler from __compiler as Compiler
-
+    
+    get tagToTypeName from var
+        """ Map from TypeName tags used in compiler to backend specific qualified TypeName"""
+    
+    def resolveTypeTag(qualifiedNameOrTag as String) as String
+        if qualifiedNameOrTag.contains('.')         
+            qualifiedName = qualifiedNameOrTag
+        else    
+            qualifiedName = .tagToTypeName[qualifiedNameOrTag]  # type tag to backend qualifiedName
+        return qualifiedName
+        
     def makePhases(phases as IList<of Phase>) is abstract
         """
         Given a list of core phases for compilation complete it with additions (or even removals and
@@ -57 +92 @@
         """
         Return binary output name for compilation of files for this backend.
         """
+        
+    def genNativeModule(filename as String, verbosity as int) as Module? is abstract    
+        """
+        Check if a filename is a Native module and if so return the Native module type for it
+        otherwise return nil.
+        """
+    
+    def setupRunProcess(baseExe as String, fullExe as String) as Process is abstract
+        """
+        Create and initialise the process to run the compiled program post compilation
+        setup varies on the backend (.Clr/Jvm) and platform.
+        """
+    
+    def setDefaultUseDirectives(ns as NameSpace) is abstract
+        """
+        Set the default Use directives into the given Namespace (usually topNamespace) for this backend.
+        """
+    
+    def fixLibExtension(libRef as String) as String is abstract
+        """
+        Augment given lib reference string with backend extension if not already have one.
+        """
+    
+    def loadLibReference(reference as String) as bool is abstract
+        """
+        Load the given lib reference file  using the current backend paradigms. 
+        Return true if reference found and loaded correctly, false otherwise
+        """
+    
+    def readSystemTypes is abstract
+        """ Read and Load System Types for backend for Compiler to make available"""
+            
+        
+    def fixNilableMemberSigs is abstract
+        """         
+        Most backends dont natively support nilablility, this marks/fixes the common backend
+        class signatures that should be marked nilable.
+        """
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) is abstract
+        """
+        Setup so that static methods (on Primitives and some others) get installed/treated as normal methods
+        on the instance.
+        """
+            
+    # Native Types access
+    def cobraNameForNativeBoxName(name as String) as String is abstract
+        """
+        Returns name from backend library entries converted to cobra naming form.
+        """
+    
+    get objectTypeProxy as AbstractTypeProxy is abstract
+        """BE TypeProxy for root of back end Object hierarchy."""
 
+    get typeTypeProxy as AbstractTypeProxy is abstract
+        """BE TypeProxy for BE notion of a class describing a Type."""
 
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is abstract
+        """
+        Return a Proxy placeHolder for a BackEnd Native Type.
+        """
+        
+    def nativeType(type as dynamic) as NativeType is abstract
+        """
+        Return a Native Type wrapped so we can use it without explicitly knowing what it is anywhere
+        else but the providing back end. Used by the backends to generate Types from Libraries.
+        """
+    
+    def nativeTypeByName(qualifiedName as String) as NativeType is abstract
+        """
+        Return a Native Type corresponding to the fully qualified name.
+        Abstract Type Literal tags used in the compiler directly can also be obtained through this
+        otherwise the qualified names are expected to conform to the platform back end naming. 
+        """
+    
+    def addArrayInterfaces( interfaces as List<of ITypeProxy>) is abstract
+        """Add any additional interfaces the backends support that an ArrayType may need to have."""
+            
+    
+class BasicBackEnd inherits BackEnd
+    """ Stub BackEnd for tests. """
+    
+    cue init(compiler as Compiler)
+        base.init(compiler)
+        _name = 'c#-clr(basic)'
+        _rtlName = 'cobraRTL.libext'
+        
+        _tagToTypeName = {
+            'Object': 'System.Object',
+            'Type'  : 'System.Type',
+        }
+        
+    def makePhases(phases as IList<of Phase>) is override
+        pass
+        
+    def computeOutName as String  is override
+        return 'BasicOut'
+        
+    def genNativeModule(filename as String, verbosity as int) as Module?  is override
+        return nil
+    
+    def setupRunProcess(baseExe as String, fullExe as String) as Process  is override
+        p = Process()
+        p.startInfo.fileName = 'echo' 
+        p.startInfo.arguments = 'basic BackEnd process - [baseExe]'
+        return p        
+    
+    def setDefaultUseDirectives(ns as NameSpace)  is override
+        pass
+    
+    def fixLibExtension(libRef as String) as String is override
+        if not libRef.endsWith('.libext')
+            libRef += '.libext'
+        return libRef   
+    
+    def loadLibReference(reference as String) as bool is override
+        return true
+    
+    def readSystemTypes is override
+        pass
+    
+    def fixNilableMemberSigs is override
+        pass
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) is override
+        pass
+        
+    # Native Type access
+    def cobraNameForNativeBoxName(name as String) as String is override
+        return name + '_BBE'
+    
+    # Types
+    get objectTypeProxy as AbstractTypeProxy is override
+        return ClrTypeProxy(Object) # for testing
+            
+    get typeTypeProxy  as AbstractTypeProxy is override
+        return ClrTypeProxy(Type )# for testing
+
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy is override
+        return ClrTypeProxy(type) #TODO: fix this to something non BE specific Tmp
+        
+    def nativeType(type) as NativeType is override
+        return ClrNativeType(type) #TODO: fix this to something non BE specific Tmp
+    
+    def nativeTypeByName(qualifiedName as String) as NativeType is override
+        return ClrNativeType(System.Object) #TODO: fix this to something non BE specific Tmp
+    
+    def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override
+        pass
+        
 class Compiler implements ITypeProvider, IWarningRecorder, IErrorRecorder, ICompilerForNodes is partial
     """
     General notes:
@@ -70 +253 @@
     """
 
     var _backEnd as BackEnd?
-
+    
     var _nextSerialNum as int is shared
     var _serialNum as int
     var _verbosity as int
@@ -99 +282 @@
     var _intermediateFileNames as List<of String>
     var _loadedReferences as List<of String>
 
-    var _clrTypeCache as Dictionary<of String, System.Type>
 
-
     # caches
-    var _clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>?
+    #var _clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>?
+    var _primitiveToITypeCache as IDictionary<of dynamic, IType>?
 
-
     cue init
         .init(0, nil)
 
@@ -134 +315 @@
         _warnings = List<of SourceException>()
         _intermediateFileNames = List<of String>()
         _loadedReferences = List<of String>()
-        _clrTypeCache = Dictionary<of String, System.Type>()
         if initialModules
             if false # TODO: not working yet
                 for mod in initialModules
@@ -157 +337 @@
     get includeTests as bool
         return .options.boolValue('include-tests')
 
-    get clrPrimitiveToITypeCache from var
+    get primitiveToITypeCache from var
         """
-        Returns a cache mapping CLR types to their corresponding ITypes.
-        Populated and used by ClrTypeProxy.
+        Returns a cache mapping BackEnd types to their corresponding ITypes.
+        Populated and used by the backend TypeProxy implementations ( {Clr,Jvm,...}TypeProxy)
         """
+    set primitiveCache as IDictionary<of dynamic, IType>
+        assert value.count <> 0
+        _primitiveToITypeCache = value
 
     get globalNS from var
 
@@ -467 +650 @@
         if not opts.containsKey('reference')
             opts['reference'] = List<of String>()
         refs = opts['reference'] to List<of String>
-        libName = 'Cobra.Lang.dll'  # TODO: why is this hard coded? What is this method used for?
+        libName = .backEnd.cobraRuntimeLibFile
         if libName not in refs
             if .verbosity, print 'Adding reference to [libName]'
             refs.add(libName)
@@ -480 +663 @@
         Returns a new Process with startInfo.fileName and p.startInfo.arguments set appropriately
         for the produced executable and the current options and any provided argsList.
         """
-        p = Process()
         baseExeFileName = exeName ? .baseExeFileName
         fullExeFileName = exeName ? .fullExeFileName
-        branch .platform
-            on PlatformEnum.Microsoft
-                p.startInfo.fileName = baseExeFileName
-            on PlatformEnum.Novell
-                p.startInfo.fileName = 'mono'
-                args = ''
-                # mono also needs --debug when running
-                if .options.getDefault('debug', '') not in ['', '-']
-                    args += '--debug '
-                args += '"[fullExeFileName]"'
-                p.startInfo.arguments = args + ' '
-            else
-                throw FallThroughException(.platform)
+        p = .backEnd.setupRunProcess(baseExeFileName, fullExeFileName)
 
         if argList and argList.count
             args = p.startInfo.arguments ? ''
@@ -637 +807 @@
             _passThroughType = PassThroughType()
         return _passThroughType to !
 
-    get typeType as IType
-        return _libraryType('System.Type')
-
     get unspecifiedType as UnspecifiedType
         if _unspecifiedType is nil
             _unspecifiedType = UnspecifiedType()
@@ -677 +844 @@
         if _nilableDynamicType is nil
             _nilableDynamicType = .nilableType(.dynamicType)
         return _nilableDynamicType to !
+# -- end of ITypeProvider
 
+/#
+overrides replacing above for mixin of BasicTypeProvider
+    class Compiler ... includes BasicTypeProvider
+        
+    var _nilableDynamicType as NilableType?
+    
+    get numberType as AbstractNumberType is override
+        if _numberType is nil
+            branch .options['number'] to String
+                on 'decimal', _numberType = .decimalType
+                on 'float',   _numberType = .floatType
+                on 'float32', _numberType = .floatType(32)
+                on 'float64', _numberType = .floatType(64)
+                else, throw FallThroughException(.options['number'])
+        return _numberType to !
 
+
+    def nilableType(type as IType) as NilableType is override
+        if type inherits NilableType, return type
+        if _nilableTypes is nil
+            _nilableTypes = Dictionary<of INode, NilableType>()
+        if _nilableTypes.containsKey(type)
+            return _nilableTypes[type]
+        else
+            _nilableTypes[type] = nt = NilableType(type)
+            nt.bindInh
+            if not .isBindingInh, nt.bindInt
+            return nt
+
+    def defaultType as IType is override
+        return .nilableDynamicType
+
+    def nilableDynamicType as NilableType
+        if _nilableDynamicType is nil
+            _nilableDynamicType = .nilableType(.dynamicType)
+        return _nilableDynamicType to !
+#/      
+
+
+    get typeType as IType
+        #return _libraryType('System.Type')
+        #return _libraryType(.backEnd.tagToTypeName['Type'])
+        return .libraryType('Type')
+
     ## More type stuff
 
     def readSystemTypes
-        # TODO: support targeting a specific CLR version, but not below 2.0
-        .readAssembly(Assembly.load('mscorlib.dll') to !)
+        .backEnd.readSystemTypes
 
-        # TODO: .readAssembly(Assembly.loadFrom('System.dll') to !)
-        #       gives: Unhandled Exception: System.IO.FileNotFoundException: Could not load file or assembly 'System.dll' or one of its dependencies. The system cannot find the file specified.
-
-        t = System.Diagnostics.Process.getType
-        .readAssembly(t.assembly) # System.dll
-
     def fixLibExtensions(references as List<of String>)
         i = 0
         for reference in List<of String>(references)
-            references[i] = reference.fixLibExtension
+            references[i] = .backEnd.fixLibExtension(references[i])
             i += 1
             
     def printRefs(references as List<of String>)
@@ -742 +946 @@
         # sharp'curDomain.ReflectionOnlyAssemblyResolve += _resolveEvent'
 
         for reference in references
-            if not .loadReference(reference)
+            if not .loadReference(reference, false)
                 _addMessage(SourceException('Cannot locate assembly reference "[reference]".'))
 
     def refsForPackage(pkgName as String) as List<of String>
@@ -798 +1002 @@
         # see .loadReference which sets up the indented writer
         (CobraCore.printDestination to IndentedWriter).dedent
 
-    def loadReference(reference as String) as bool
+    def loadReference(reference as String, addExtn as bool) as bool
         """
         Attempts to load the given library reference.
         On success, adds reference to .loadedReferences and returns true.
         On failure, returns false, but does not add any warnings or errors.
         This method is used by Compiler and UseDirective.
         """
+        if addExtn
+            reference = .backEnd.fixLibExtension(reference)
         v, rv = .verbosity, .referenceVerbosity
         if v, print 'Loading reference:', reference
         if rv
@@ -824 +1030 @@
 
     def _loadReference(reference as String) as bool
         try
-            return __loadReference(reference)
-        catch fnfe as System.IO.FileNotFoundException
-            # example: Could not load file or assembly 'NHibernate, Version=2.1.0.1001,
+            return .backEnd.loadLibReference(reference)
+        catch lre as LoadReferenceException
+            # example: 'FileNotFoundException fileName Could not load file or assembly 'NHibernate, Version=2.1.0.1001,
             # Culture=neutral, PublcKeyToken=aa95f207798dfdb4' or one of its dependencies. The
             # system cannot find the file specified.
-            if .referenceVerbosity, print '[fnfe] in _loadReference("[reference]")'
+            if .referenceVerbosity, print '[lre] in _loadReference("[reference]")'
             return false
-        catch fle as System.IO.FileLoadException
-            if .referenceVerbosity, print '[fle] in _loadReference("[reference]")'
-            return false
 
-    def __loadReference(reference as String) as bool
-        require
-            reference.endsWith('.dll') or reference.endsWith('.exe')
-            reference not in ['.dll', '.exe']
-        ensure
-            result implies .loadedReferences[.loadedReferences.count-1] == reference
-            not result implies .loadedReferences.count == old .loadedReferences.count
-        body
-            rv = .referenceVerbosity
-            assert not (reference.startsWith('-r') and '-r' in reference[2:])
-            if false
-                # Does not work on Novell Mono. See notes above.
-                referredAss = Assembly.reflectionOnlyLoadFrom(reference)
-                # TODO: handle all the exceptions from Assembly.loadFrom
-            else
-                if File.exists(reference)
-                    # try current directory
-                    if rv, print '"[reference]" found as file. Will Assembly.loadFrom().'
-                    referredAss = Assembly.loadFrom(reference)
-                    if rv, print 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
-                else
-                    # TODO: the problem with -lib: in both Cobra and C# is that it has no effect on runtime,
-                    # you must still register the DLLs in the GAC or copy them into the same dir as the .exe
-                    # because the -lib: paths are not passed into executable.
-                    # So should Cobra copy the .dll's into the target directory (if their paths are not in MONO_PATH)?
-                    if rv, print 'File does not exist.'
-                    searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
-                    # TODO: ?: searchPaths.add(Path.getDirectoryName(Assembly.getExecutingAssembly.location))  # try Cobra's directory - also should be added to .options.'library-directory' not to a local var
-                    found = false
-                    for searchPath in searchPaths
-                        if rv, print 'Checking lib path: "[searchPath]"'
-                        combinedPath = Path.combine(searchPath, reference)
-                        if File.exists(combinedPath)
-                            if rv, print '"[reference]" found as file. Will Assembly.loadFrom().'
-                            referredAss = Assembly.loadFrom(combinedPath)
-                            if rv, print 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
-                            found = true
-                            break
-                    if rv
-                        if searchPaths.count
-                            if not found, print 'Did not find "[reference]" in lib paths'
-                        else
-                            print 'No lib paths to search.'
-                    if not found
-                        # try system wide (GAC)
-                        if reference.endsWith('.dll'), reference = reference[:-4]
-                        if rv, print 'Will load with partial name "[reference]"'
-                        referredAss = Utils.loadWithPartialName(reference)
-                        if rv, print 'Load with partial name returned: [CobraCore.toTechString(referredAss)]'
-                        if referredAss is nil, return false
-                        # 2009-08-03 CE: Removed this code:
-                        # reference = referredAss.location
-                        # To address this:
-                        # http://cobra-language.com/forums/viewtopic.php?f=4&t=501
-                        # See also: ../Tests/720-libraries/100-microsoft/110-winforms-native-compiler.cobra
-                        #           Note the -native-compiler option in that test which triggers this.
-                        # Also, it doesn't see right to have to use the full path of a GAC-based assembly anyway.
-                        # But still have to end in .dll or .exe:
-                        reference += if(referredAss.location.endsWith('.exe'), '.exe', '.dll')
-                # TODO: handle all the exceptions from Assembly.loadFrom
-            if referredAss
-                if _willReadDependencies
-                    for dependency in referredAss.getReferencedAssemblies
-                        if rv
-                            print '>> Loading dependency: [dependency]'
-                            .indentPrint
-                            try
-                                .loadAssembly(dependency)
-                            finally
-                                .outdentPrint
-                                print '<< Loading dependency: [dependency]'
-                        else
-                            .loadAssembly(dependency)
-                if rv, print 'Will read assembly: [referredAss]'
-                try
-                    .readAssembly(referredAss, reference <> 'Cobra.Lang.dll')
-                catch readExc as Exception
-                    if rv, print 'Caught exception during read assembly: [readExc]'
-                    throw
-                if rv, print 'Did read assembly: [referredAss]'
-                # reassert the preconditions. there have been bugs in the past
-                assert reference.endsWith('.dll') or reference.endsWith('.exe')
-                assert reference not in ['.dll', '.exe']
-                .loadedReferences.add(reference)
-                if rv, print 'Returning true for __loadReference("[reference]").'
-                return true
-            else
-                if rv, print 'Returning false for __loadReference("[reference]").'
-                return false
-
-    var _didLoadAssemblies = Set<of String>()
-
-    def loadAssembly(assName as AssemblyName)
-        if .referenceVerbosity
-            print '>> loadAssembly [assName]'
-            .indentPrint
-            try
-                _loadAssembly(assName)
-            finally
-                .outdentPrint
-                print '<< loadAssembly [assName]'
-        else
-            _loadAssembly(assName)
-
-    def _loadAssembly(assName as AssemblyName)
-        rv = .referenceVerbosity - 1
-        if rv < 0, rv = 0
-        if assName.toString in _didLoadAssemblies
-            if rv, print 'Already loaded.'
-            return
-        _didLoadAssemblies.add(assName.toString)
-        try
-            if rv, print 'Will Assembly.load([assName])'
-            ass = Assembly.load(assName)     # Will not pick up the assembly from the same directory.
-            if rv, print 'Did Assembly.load with result: [ass]'
-        catch fnfe as FileNotFoundException  # In fact, will get a FileNotFoundException!
-            if rv, print 'Did Assembly.load with exception: [fnfe]. Will try .loadReference'
-            .loadReference(assName.name + '.dll')
-            # TODO: compare the the name loaded to the name given with AssemblyName.referenceMatchesDefinition
-            return
-        catch exc as Exception
-            msg = 'Could not open assembly "[assName]" due to: [exc.getType.name]: [exc.message]'
-            if rv, print msg
-            throw SourceException(msg)
-        if _willReadDependencies
-            for dependency in ass.getReferencedAssemblies
-                if rv
-                    print '>> Loading dependency: [dependency]'
-                    .indentPrint
-                    try
-                        .loadAssembly(dependency)
-                    finally
-                        .outdentPrint
-                        print '<< Loading dependency: [dependency]'
-        try
-            .readAssembly(ass)
-        catch readExc as Exception
-            if rv, print 'Caught exception during read assembly: [readExc]'
-            throw
-
-
+    def fixNilableMemberSigs
+        .backEnd.fixNilableMemberSigs
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) 
+        .backEnd.installNativeMethods(box, nativeType)
+        
     ##
     ## Binding
     ##
@@ -1177 +1245 @@
     ##
     ## Important system library types
     ##
-
+    # ILibTypeProvider
+    
     get objectType as IType
         # for ITypeProvider
-        return _libraryClass('System.Object')
+        return _libraryClass('Object')
 
     def objectClass as Class
         # for stronger typing
-        return _libraryClass('System.Object')
+        return _libraryClass('Object')
 
     def stringType as Class
-        return _libraryClass('System.String')
+        return _libraryClass('String')
 
     def exceptionType as Class
-        return _libraryClass('System.Exception')
+        return _libraryClass('Exception')
 
     def delegateType as Class
-        return _libraryClass('System.Delegate')
+        return _libraryClass('Delegate')
 
     def attributeType as Box
-        return _libraryBox('System.Attribute')
+        return _libraryBox('Attribute')
 
     def enumerableType as Box
-        return _libraryBox('System.Collections.IEnumerable')
+        return _libraryBox('IEnumerable')
 
     def enumeratorType as Box
-        return _libraryBox('System.Collections.IEnumerator')
+        return _libraryBox('IEnumerator')
 
     def enumerableOfType as Box
-        return _libraryBox('System.Collections.Generic.IEnumerable<of>')
+        return _libraryBox('IEnumerable<of>')
 
     def enumeratorOfType as Box
-        return _libraryBox('System.Collections.Generic.IEnumerator<of>')
+        return _libraryBox('IEnumerator<of>')
 
     def dictEnumeratorType as Box
-        return _libraryBox('System.Collections.IDictionaryEnumerator')
+        return _libraryBox('IDictionaryEnumerator')
         
     def collectionType as Box
-        return _libraryBox('System.Collections.ICollection')
+        return _libraryBox('ICollection')
 
     def collectionOfType as Box
-        return _libraryBox('System.Collections.Generic.ICollection<of>')
+        return _libraryBox('ICollection<of>')
 
     def ilistType as Box
-        return _libraryBox('System.Collections.IList')
+        return _libraryBox('IList')
         
     def ilistOfType as Box
-        return _libraryBox('System.Collections.Generic.IList<of>')
+        return _libraryBox('IList<of>')
         
     def listOfType as Class
-        return _libraryClass('System.Collections.Generic.List<of>')
+        return _libraryClass('List<of>')
 
     def idictionaryType as Box
-        return _libraryBox('System.Collections.IDictionary')
+        return _libraryBox('IDictionary')
         
     def idictionaryOfType as Box
-        return _libraryBox('System.Collections.Generic.IDictionary<of,>')
+        return _libraryBox('IDictionary<of,>')
 
     def dictionaryOfType as Class
-        return _libraryClass('System.Collections.Generic.Dictionary<of,>')
+        return _libraryClass('Dictionary<of,>')
 
     def setOfType as Class
-        return _libraryClass('Cobra.Lang.Set<of>')
+        return _libraryClass('Set<of>')
 
-    def libraryType(qualifiedName as String) as IType
+    def libraryType(qualifiedNameOrTag as String) as IType
         """
         Implemented for ITypeProvider, but use the more specific methods such as .stringType instead.
         """
-        return _libraryType(qualifiedName)
+        return _libraryType(.backEnd.resolveTypeTag(qualifiedNameOrTag))
 
     var _libraryTypeCache = Dictionary<of String, IType>()
 
     def _libraryType(qualifiedName as String) as IType
         """
+        find qualified Type name in (cache or) Library/namespace Decls structures. 
         Used to retrieve types such as System.String.
         Example:
             _libraryType('System.String')
         """
+        assert qualifiedName.length
         type as IType?
         if _libraryTypeCache.tryGetValue(qualifiedName, out type)
             return type to !
@@ -1263 +1334 @@
         return type to !
 
     def _libraryType(names as vari String) as IType
+        #print names
         ns as IContainer = _globalNS
         thing as IContainer? = nil
         for name in names
+            #print (thing ? ns)
             possible = (thing ? ns).declForName(name)
             assert possible, name
             if possible inherits IContainer
@@ -1282 +1355 @@
         else
             throw FallThroughException('found [name], but it is not an IType. it is [thing]')
 
-    def _libraryBox(qualifiedName as String) as Box
+    def _libraryBox(qualifiedNameOrTag as String) as Box
         """
         Returns a box from the standard library such as 'System.Object' or 'System.Collections.Generic.IEnumerable<of>'.
         """
-        return _libraryType(qualifiedName) to Box
+        return _libraryType(.backEnd.resolveTypeTag(qualifiedNameOrTag)) to Box
 
-    def _libraryClass(qualifiedName as String) as Class
+    def _libraryClass(qualifiedNameOrTag as String) as Class
         """
         Returns a class from the standard library such as 'System.Object' or 'System.Collections.Generic.Dictionary<of,>'.
         """
-        return _libraryType(qualifiedName) to Class
+        return _libraryType(.backEnd.resolveTypeTag(qualifiedNameOrTag)) to Class
 
 
     ##
@@ -1302 +1375 @@
     def embedRunTimeSuffix as String
         return .options.embedRunTimeSuffix
 
+    #special type proxies for common Types -  Object and Type
+    def objectTypeProxy as AbstractTypeProxy 
+        """
+        Type proxy for BE notion of a class for the root of Object hierarchy
+            e.g. Object in dotNet
+        """
+        #return ClrTypeProxy(Object)
+        return .backEnd.objectTypeProxy
+
+    def typeTypeProxy as AbstractTypeProxy 
+        """
+        Type proxy for BE notion of a class for a Type
+            e.g. System.Type in dotNet, java.lang.class in Java
+        """
+        #return ClrTypeProxy(Type)
+        return .backEnd.typeTypeProxy
+        
     def nativeType(qualifiedName as String) as NativeType
-        return ClrNativeType(_clrType(qualifiedName))
+        return .backEnd.nativeTypeByName(qualifiedName)
 
-    def _clrType(qualifiedName as String) as System.Type
-        # eventually this method will be key in targeting different versions of the CLR
-        # suppose you are on .NET 3.0 and want to target .NET 2.0
-        t as System.Type?
-        _clrTypeCache.tryGetValue(qualifiedName, out t)
-        if t is nil
-            t = sharp'System.Type.GetType(qualifiedName)' # to System.Type
-            _clrTypeCache[qualifiedName] = t to passthrough  # "to passthrough" instead of "to !" to avoid non-nil check
-        return t to passthrough
-
     def suggestionFor(name as String) as String? is shared
         require name.length
         # CC: return _unknownSuggestions.getDefault(name, nil)
@@ -1452 +1532 @@
             on 'jvm',  _backEnd = JvmBackEnd(this)
             on 'objc', _backEnd = ObjcBackEnd(this)
             else, throw FallThroughException(.options.get('back-end'))
+            
 
-
 class InternalError
     inherits SourceException
     """
@@ -1510 +1590 @@
 
     cue init
         base.init(0)
-
+        _backEnd = BasicBackEnd(this)
+        
     pro verbosity as int is override
         get
             return 0
@@ -1521 +1602 @@
         return lineNum
 
 
-extend String
-
-    def fixLibExtension as String
-        require .length
-        ensure result.endsWith('.dll') or result.endsWith('.exe')
-        if not .endsWith('.dll') and not .endsWith('.exe')
-            return this + '.dll'
-        else
-            return this

Source/Expr.cobra

@@ -1153 +1153 @@
                         definition = curBox.symbolForName(_name, true)
                         if definition
                             .throwError('You must refer to non-underscored members with a leading dot (.). Member name is "[_name]".')
+            # hops              
+            #print _name, canBeUndottedMember, _definition
+            if _definition is nil and _name == 'java'  # TODO hops: handle thru .findDefinition
+                #_definition = NameSpace(.token.copy('ID', 'java'), 'java')
+                _definition = .compiler.passThroughType
+                #print _name    
             if _definition is nil and (not _superNode inherits BinaryOpExpr or .binarySuperNode.op<>'ASSIGN')
                 .throwUnknownIdError
                 throw FallThroughException()

Source/Boxes.cobra

@@ -35 +35 @@
     var _nativeType as NativeType?
     var _needScanNativeType as bool
     var _membersToUnNil as String?
-    var _defaultMemberName as String?
-        """
-        An Indexer in CLR is known by being a property with arguments whose name matches the .memberName of a box-level DefaultMemberAttribute.
-        """
 
     cue init(token as IToken, idToken as IToken, name as String, paramList as List<of IType>, isNames as String*, attribs as AttributeList, baseInterfaceNodes as List<of ITypeProxy>, docString as String?)
         base.init(token, name, isNames, docString)
@@ -60 +56 @@
         ensure .needScanNativeType
         _nativeType = t
         _needScanNativeType = true
-        _scanGenericArgs
+        _callNativeScanMethod('ScanGenericArgs')    
 
+    def _callNativeScanMethod(tag as String)
+        """
+        Call a backend scan method for native type scan operation desired and backend in use.
+        """
+        # This is icky - 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', 'ScanGenericArgs', 'prepSysObjClass'] # turn these into an Enum
+        backEnd = .compiler.backEnd
+        branch backEnd.name
+            on 'c#-clr'
+                branch tag
+                    on 'ScanNativeType',  _scanNativeTypeClr
+                    on 'ScanGenericArgs', _scanGenericArgsClr
+                    on 'prepSysObjClass', _prepSystemObjectClassClr
+        
+            on 'java-jvm'
+                branch tag
+                    on 'ScanNativeType',  _scanNativeTypeJvm
+                    on 'ScanGenericArgs', _scanGenericArgsJvm
+                    on 'prepSysObjClass', _prepSystemObjectClassJvm
+            on 'objc'
+                print 'objc back end need method for [tag]'
+                assert false, 'Missing backEnd infrastructure for [backEnd.getType.name]'
+                    #branch on tag
+                    #   on 'ScanNativeType',  _scanObjcNativeType
+                    #   on 'ScanGenericArgs', _scanObjcGenericArgs
+                    #   on 'prepSysObjClass', _prepSystemObjectClassObjc
+            else 
+                throw FallThroughException('No nativeScanMethod code for backend [backEnd.name] [backEnd.getType.name]')
+                
+        
     def addMinFields
         base.addMinFields
         .addField('didBindInh', .didBindInh)
@@ -194 +222 @@
 
     # TODO: cache
     get isSystemObjectClass as bool is override
-        # TODO-BACKEND
-        return _baseClass is nil and .name == 'Object' and .parentNameSpace and .parentNameSpace.fullName == 'System'
+        #return _baseClass is nil and .name == 'Object' and .parentNameSpace and .parentNameSpace.fullName == 'System'
+        return _nativeType and _nativeType.isSystemObjectClass
 
     get isSystemTypeClass as bool is override
-        # TODO-BACKEND
-        return .name == 'Type' and .parentNameSpace and .parentNameSpace.fullName == 'System'
+        #return .name == 'Type' and .parentNameSpace and .parentNameSpace.fullName == 'System'
+        return _nativeType and _nativeType.isSystemTypeClass
 
-    get isSystemExceptionClass as bool
-        # TODO-BACKEND
-        return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'System'
-
     pro membersToUnNil from var
 
     get nativeType from var
@@ -568 +592 @@
         return r
 
     ## Binding
-
+    def _scanNativeType
+        #print '_scanNativeType ', .name
+        _callNativeScanMethod('ScanNativeType')     
+        
     def _stackPush
         base._stackPush
         if .compiler, .compiler.boxStack.push(this)
@@ -647 +674 @@
         # Therefore, everthing below has already happened for a constructed box's generic def.
         base._bindInt
         if .isSystemObjectClass
-            .prepSystemObjectClass
+            _callNativeScanMethod('prepSysObjClass')
         errorCount = .compiler.errors.count
-        if _needScanNativeType
-            _scanNativeType
+        if _needScanNativeType, _scanNativeType
         if _baseClass
             _baseClass.bindInt
         for interf in _baseInterfaces
@@ -694 +720 @@
                         ct.completeMemberConstructionIfNeeded
                         ct.bindInt
 
-    def prepSystemObjectClass
-        # TODO: fix native
-        # Pretend .NET is a bit more OO, consistent and elegant.
-        # C#'s typeof(X) is X.getType in Cobra.
-        existing = .declForName('getType') to BoxMember
-        overload = MemberOverload(existing)
-        .registerOverload(overload)
-        meth = Method(TokenFix.empty, TokenFix.empty, this, 'getType', List<of Param>(), ClrTypeProxy(Type), nil, ['shared'], AttributeList(), 'Returns the Type instance that defines this type.')
-        meth.sharedMethodBacking = 'typeof'
-        overload.addMember(meth)
-
     def _bindBase
         # invoked by _bindInt
         _baseClass = .compiler.objectClass
@@ -1180 +1195 @@
         base.init(token, idToken, name, paramList, isNames, attribs, implementsNodes, addsProxies, docString)
         _baseNode = baseNode
 
-    cue init(nativeType as NativeType)
+    cue init(nativeType as NativeType, backend as BackEnd)
         # TODO: fix native
-        base.init(TokenFix.empty, TokenFix.empty, ClrTypeProxy.cobraNameForSharpBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
+        base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
         if nativeType.baseType
-            _baseNode = ClrTypeProxy(nativeType.baseType to ClrNativeType)  # TODO: fix native. Change to NativeTypeProxy
+            _baseNode = backend.nativeTypeProxy(nativeType.baseType to !)
         _initNativeType(nativeType)
-
+        
     def addRefFields
         base.addRefFields
         .addField('baseNode', _baseNode)
@@ -1336 +1351 @@
                             init.changeToPublic
                             break
 
+    get isSystemObjectClass as bool is override
+        return _nativeType and _nativeType.isSystemObjectClass
+
+    get isSystemTypeClass as bool is override
+        return _nativeType and _nativeType.isSystemTypeClass
+
     def _finishOverloads
         # deal with inheritance and overloads
         assert _baseClass or .isSystemObjectClass
@@ -1428 +1449 @@
     cue init(token as IToken, idToken as IToken, name as String, paramList as List<of IType>, isNames as String*, attribs as AttributeList, baseNodes as List<of ITypeProxy>, docString as String?)
         base.init(token, idToken, name, paramList, isNames, attribs, baseNodes, docString)
         
-    cue init(nativeType as NativeType)
-        base.init(TokenFix.empty, TokenFix.empty, ClrTypeProxy.cobraNameForSharpBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), nil)
+    cue init(nativeType as NativeType, backend as BackEnd)
+        base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), nil)
         _initNativeType(nativeType)
 
     get canHaveStatements as bool is override
@@ -1467 +1488 @@
     cue init(token as IToken, idToken as IToken, name as String, paramList as List<of IType>, isNames as String*, attribs as AttributeList, baseName as String?, interfaceNodes as List<of ITypeProxy>, addsProxies as List<of ITypeProxy>, docString as String?)
         base.init(token, idToken, name, paramList, isNames, attribs, interfaceNodes, addsProxies, docString)
 
-    cue init(nativeType as NativeType)
-        base.init(TokenFix.empty, TokenFix.empty, ClrTypeProxy.cobraNameForSharpBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
+    cue init(nativeType as NativeType,  backend as BackEnd)
+        base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
         _initNativeType(nativeType)
 
     get englishName as String is override
@@ -1805 +1826 @@
         _name = '(unnamed extension [.serialNum])'
         _extendedBoxProxy = extendedBoxProxy
 
-    cue init(nativeType as NativeType)
+    cue init(nativeType as NativeType,  backend as BackEnd)
         # this only for Cobra specific extensions. Example: class Extend_String_FileName
-        base.init(TokenFix.empty, TokenFix.empty, ClrTypeProxy.cobraNameForSharpBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), nil)
+        base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), nil)
         _initNativeType(nativeType)
         # the real extended type is not this type, but the type of the first argument of any method
-        for methInfo in .clrType.getMethods  # TODO: fix native. break this out to a method
-            nativeType = ClrNativeType(methInfo.getParameters[0].parameterType)
-            break
-        _extendedBoxProxy = ClrTypeProxy(nativeType)
+        branch backend.name
+            on 'c#-clr',    nativeType = .clrExtnNativeType(nativeType)     # ScanClrType
+            on 'java-jvm',  nativeType = .jvmExtnNativeType(nativeType)     # ScanJvmType
+            on 'objc'
+                print 'objc back end need method objcExtnNativeType'
+                assert false, 'Missing backEnd infrastructure for [backend.getType.name]'
+            else 
+                throw FallThroughException('No extnNativeType code for backend [backend.name] [backend.getType.name]')
+        #nativeType = backEnd.determineExtnNativeType(nativeType)
+        _extendedBoxProxy = backend.nativeTypeProxy(nativeType)
         (.compiler.curModule to AssemblyModule).addMustBindInh(this)
 
     get extendedBox from var

Source/Cobra.Lang/java/CobraCore.java

@@ +1 @@
+/*
+ * CobraCore.java
+ * 
+ * Java code implementation of RTL support code and code
+ * thats needed for simple cobra apps (in java) prior to 
+ * cobra library code generated into java.
+ * 
+ * Eventually contents of this file will be all cobra.
+ */
+package cobra.lang;
+
+public class CobraCore {
+    
+    public static Boolean _willCheckInvariant = true;
+    public static Boolean _willCheckRequire = true;
+    public static Boolean _willCheckEnsure = true;
+    public static Boolean _willCheckAssert = true;
+    public static Boolean _willCheckNil = true;
+
+    public static int noOp(/* allowNull */ Object... args) { 
+        /* """
+    No operation. Primarily used in Cobra's own test suite to consume a local variable to avoid undesired warnings.
+    Takes any number of values and returns an undefined value of type `dynamic?` for maximum flexibility.
+    """ */
+
+    return 0;
+    }
+    
+    /*
+        def runAllTests
+    """
+    Run all Cobra `test` sections in all assemblies using reflection to locate them.
+    """
+    if CobraImp.showTestProgress, listener = Cobra.Lang.Test.TextWriterListener(Console.out)
+    else, listener = Cobra.Lang.Test.TextWriterOnlyOnFailureListener(Console.out)
+    tr = Cobra.Lang.Test.TestRunner(listener)
+    tr.runAllTests
+    if listener.testFailures, CobraCore.exit(1)
+     */
+    public static void runAllTests()
+    {
+        CobraImp.printLine("stub:running all tests...");
+    }
+    
+    public static void printDebuggingTips()
+    {
+        CobraImp.printLine("An unhandled exception has occurred.");
+        CobraImp.printLine();
+        CobraImp.printLine( "Cobra debugging tips:");
+        CobraImp.printLine( "    To get file name and line number information for the stack frames, use:");
+        CobraImp.printLine( "        cobra -debug foo.cobra");
+        CobraImp.printLine( "    To get a post-mortem, HTML-formatted report with more details about your objects:");
+        CobraImp.printLine( "        cobra -debug -exception-report foo.cobra");
+        CobraImp.printLine( "    For even more information, try:");
+        CobraImp.printLine( "        cobra -debug -exception-report -detailed-stack-trace foo.cobra");
+        CobraImp.printLine( "    Or use the abbreviations:");
+        CobraImp.printLine( "        cobra -d -er -dst foo.cobra");
+        // TODO: CobraImp.printLine( "    See also: http://cobra-language.com/docs/debugging");
+        CobraImp.printLine();
+    }
+}
+

Source/Cobra.Lang/java/AssertException.java

@@ +1 @@
+/* 
+ * java code for cobra assert exception ( placeholder currently)
+ * in process of Converting from cobra to java code
+ * Initially using java assertion till this is working
+ */
+
+package cobra.lang;
+
+import java.util.List;
+
+
+class AssertException extends Exception implements IHasSourceSite, HasAppendNonPropertyKeyValues
+//      has DetailedStackTrace(false)
+{
+    Object _this;
+    Object _info;   /* dynamic */
+    SourceSite _sourceSite;
+    java.util.List<Object> _expressions;
+    
+    AssertException(SourceSite sourceSite, java.util.List<Object> expressions /*dynamic */, Object thiss, Object info /*dynamic? */)
+    {
+        this(sourceSite, expressions, thiss, info, nil)
+    }
+
+    AssertException(SourceSite sourceSite, java.util.List<Object> expressions /*dynamic */, Object thiss, Object info /*as dynamic?*/, Exception innerExc)
+    {
+        super('assert', innerExc)
+        _sourceSite = sourceSite
+        _expressions = expressions
+        _this = thiss
+        _info = info
+    }
+// UNFINISHED
+    
+    Object getThis { return _this; }
+    
+    Object getInfo { return _info; }
+        
+    SourceSite getSourceSite { return _sourceSite; }
+    
+    List<Object> getExpressions { return _expressions; }
+
+    @Override
+    String getMessage()
+    {
+            nl = System.properties.newLine
+            StringBuilder sb = new StringBuilder(nl);
+            sb.append('sourceSite = [.sourceSite][nl]');
+            sb.append('info       = [.makeString(.info)][nl]');
+            sb.append('this       = [.makeString(.this)][nl]');
+            int indentLevel = 1;
+            int i = 1;
+            List<Object> exprs = _expressions;
+            while (i < exprs.size) {
+                Object item = exprs.get(i));
+                if (item == +1) {
+                    indentLevel += 1;
+                    i += 1;
+                }
+                else if (item == -1) {
+                    indentLevel -= 1;
+                    i += 1;
+                }
+                else {
+                    String source = (String)item;
+                    Object value = exprs.get(i+1);
+                    dirStr = value to? CobraDirectString
+                    valueString = if(dirStr, dirStr.string, .makeString(value))
+                    sb.append(String(' ', indentLevel*4))
+                    sb.append('[source] = [valueString][nl]');
+                    i += 2;
+                }
+            }
+
+          return sb.toString
+      }
+    
+      String makeString(Object obj /*dynamic? */)
+      {
+            String s;
+            try {
+                s = CobraCore.techStringMaker.makeString(obj);
+            } 
+            catch (Exception e) {
+                s = 'CobraCore.techStringMaker.makeString exception: ' + e.message;
+            }
+            return s;
+        }
+
+        def appendNonPropertyKeyValues(target as HasAppendKeyValue )
+            # Invoked by the Cobra Exception Report and CobraMain-ObjectExplorer-WinForms
+            # By adding the expression breakdown as entries in the view,
+            # object values will be clickable which will lead to their own detailed view.
+            indentLevel = 0
+            target.appendKeyValue('expression breakdown:', Html(''))
+            i, exprs = 1, _expressions
+            while i < exprs.count
+                item = exprs[i]
+                if item == +1
+                    indentLevel += 1
+                    i += 1
+                else if item == -1
+                    indentLevel -= 1
+                    i += 1
+                else
+                    source = item to String
+                    value = exprs[i+1]
+                    target.appendKeyValue(String(c' ', indentLevel*4)+source, value)
+                    i += 2
+
+        def populateTreeWithExpressions(tree as ITreeBuilder)
+            # Invoked by the Object Explorer, but any tool could use this by implementing ITreeBuilder.
+            # By adding the expression breakdown as entries in the view,
+            # object values will be clickable which will lead to their own detailed view.
+            i, exprs = 1, _expressions
+            while i < exprs.count
+                item = exprs[i]
+                if item == +1
+                    tree.indent
+                    i += 1
+                else if item == -1
+                    tree.outdent
+                    i += 1
+                else
+                    source = item to String
+                    value = exprs[i+1]
+                    tree.appendKeyValue(source, value)
+                    i += 2
+
+
+
+
+
+/*
+    ## Exceptions about dynamic
+
+    class DynamicOperationException inherits Exception
+        """
+        The base class for all dynamic operation exceptions.
+        """
+
+        cue init(message as String?)
+            .init(message, nil)
+
+        cue init(message as String?, innerExc as Exception?)
+            base.init(message, innerExc)
+
+    class CannotEnumerateException inherits DynamicOperationException
+        
+        # CC: axe init()s
+
+        cue init(message as String?)
+            .init(message, nil)
+
+        cue init(message as String?, innerExc as Exception?)
+            base.init(message, innerExc)
+        
+        
+    class UnknownMemberException inherits DynamicOperationException
+
+        var _obj as Object
+        var _name as String
+        var _type as Type
+
+        cue init(obj as Object, name as String, type as Type)
+            .init(obj, name, type, nil)
+
+        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
+            base.init('obj=[CobraCore.toTechString(obj)], name=[CobraCore.toTechString(name)], type=[type]', innerExc)
+            _obj = obj
+            _name = name
+            _type = type
+
+
+    class CannotReadPropertyException inherits UnknownMemberException
+
+        # CC: axe init()s
+
+        cue init(obj as Object, name as String, type as Type)
+            .init(obj, name, type, nil)
+
+        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
+            base.init(obj, name, type, innerExc)
+
+
+    class CannotWritePropertyException inherits UnknownMemberException
+
+        # CC: axe init()s
+
+        cue init(obj as Object, name as String, type as Type)
+            .init(obj, name, type, nil)
+
+        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
+            base.init(obj, name, type, innerExc)
+
+
+    class CannotSliceTypeException inherits UnknownMemberException
+
+        # CC: axe init()s
+
+        cue init(obj as Object, name as String, type as Type)
+            .init(obj, name, type, nil)
+
+        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
+            base.init(obj, name, type, innerExc)
+
+
+    class CannotInTypeException inherits UnknownMemberException
+
+        # CC: axe init()s
+
+        cue init(obj as Object, name as String, type as Type)
+            .init(obj, name, type, nil)
+
+        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
+            base.init(obj, name, type, innerExc)
+
+
+    class CannotCompareException inherits DynamicOperationException
+
+        var _a
+        var _b
+
+        cue init(a, b)
+            .init(a, b, nil)
+
+        cue init(a, b, innerExc as Exception?)
+            base.init('a=[a], b=[b]', innerExc)
+            #base.init('a=[CobraCore.toTechString(a)], a.getType=[a.getType.name], b=[CobraCore.toTechString(b)], b.getType=[b.getType.name]', innerExc)
+            _a = a
+            _b = b
+
+
+    ## Assertions, contracts, etc.
+
+    class AssertException inherits Exception implements IHasSourceSite, HasAppendNonPropertyKeyValues
+        has DetailedStackTrace(false)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
+            .init(sourceSite, expressions, thiss, info, nil)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
+            base.init('assert', innerExc)
+            _sourceSite = sourceSite
+            _expressions = expressions
+            _this = thiss
+            _info = info
+
+        get this from var as Object
+    
+        get info from var as dynamic?
+        
+        get sourceSite from var as SourceSite
+    
+        get expressions from var as IList<of dynamic>
+
+        get message as String? is override
+            nl = Environment.newLine
+            sb = StringBuilder(nl)
+            sb.append('sourceSite = [.sourceSite][nl]')
+            sb.append('info       = [.makeString(.info)][nl]')
+            sb.append('this       = [.makeString(.this)][nl]')
+            i = indentLevel = 1
+            exprs = _expressions
+            while i < exprs.count
+                item = exprs[i]
+                if item == +1
+                    indentLevel += 1
+                    i += 1
+                else if item == -1
+                    indentLevel -= 1
+                    i += 1
+                else
+                    source = item to String
+                    value = exprs[i+1]
+                    dirStr = value to? CobraDirectString
+                    valueString = if(dirStr, dirStr.string, .makeString(value))
+                    sb.append(String(c' ', indentLevel*4))
+                    sb.append('[source] = [valueString][nl]')
+                    i += 2
+
+            return sb.toString
+    
+        def makeString(obj as dynamic?) as String
+            try
+                s = CobraCore.techStringMaker.makeString(obj)
+            catch e as Exception
+                s = 'CobraCore.techStringMaker.makeString exception: ' + e.message
+            return s
+
+        def appendNonPropertyKeyValues(target as HasAppendKeyValue )
+            # Invoked by the Cobra Exception Report and CobraMain-ObjectExplorer-WinForms
+            # By adding the expression breakdown as entries in the view,
+            # object values will be clickable which will lead to their own detailed view.
+            indentLevel = 0
+            target.appendKeyValue('expression breakdown:', Html(''))
+            i, exprs = 1, _expressions
+            while i < exprs.count
+                item = exprs[i]
+                if item == +1
+                    indentLevel += 1
+                    i += 1
+                else if item == -1
+                    indentLevel -= 1
+                    i += 1
+                else
+                    source = item to String
+                    value = exprs[i+1]
+                    target.appendKeyValue(String(c' ', indentLevel*4)+source, value)
+                    i += 2
+
+        def populateTreeWithExpressions(tree as ITreeBuilder)
+            # Invoked by the Object Explorer, but any tool could use this by implementing ITreeBuilder.
+            # By adding the expression breakdown as entries in the view,
+            # object values will be clickable which will lead to their own detailed view.
+            i, exprs = 1, _expressions
+            while i < exprs.count
+                item = exprs[i]
+                if item == +1
+                    tree.indent
+                    i += 1
+                else if item == -1
+                    tree.outdent
+                    i += 1
+                else
+                    source = item to String
+                    value = exprs[i+1]
+                    tree.appendKeyValue(source, value)
+                    i += 2
+
+
+    class InvariantException inherits AssertException
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
+            .init(sourceSite, expressions, thiss, info, nil)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
+            base.init(sourceSite, expressions, thiss, info, innerExc)
+
+
+    class RequireException inherits AssertException
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
+            .init(sourceSite, expressions, thiss, info, nil)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
+            base.init(sourceSite, expressions, thiss, info, innerExc)
+
+        pro next from var as RequireException?
+
+
+    class EnsureException inherits AssertException
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
+            .init(sourceSite, expressions, thiss, info, nil)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
+            base.init(sourceSite, expressions, thiss, info, innerExc)
+
+
+    class NonNilCastException inherits AssertException
+
+        # it's unfortunate that we have to choose between inheriting AssertException or NullReferenceException
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
+            .init(sourceSite, expressions, thiss, info, nil)
+
+        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
+            base.init(sourceSite, expressions, thiss, info, innerExc)
+
+        get message as String? is override
+            return 'Cast to non-nil failed.[Environment.newLine][base.message]'
+
+
+    ## Misc exceptions
+
+    class ExpectException inherits Exception
+
+        cue init(expectedExceptionType as Type, actualException as Exception?)
+            base.init
+            _expectedExceptionType = expectedExceptionType
+            _actualException = actualException
+    
+        get expectedExceptionType from var as Type
+    
+        get actualException from var as Exception?
+
+        get message as String? is override
+            sb = StringBuilder()
+            sb.append('Expecting exception: [_expectedExceptionType.name], but ')
+            if _actualException
+                sb.append('a different exception was thrown: [_actualException]')
+            else
+                sb.append('no exception was thrown.')
+            return sb.toString
+
+
+    class FallThroughException inherits Exception
+
+        cue init
+            .init(nil)
+            pass
+
+        cue init(info as Object?)
+            base.init
+            _info = info
+
+        cue init(info as Object?, innerExc as Exception?)
+            base.init(nil, innerExc)
+            _info = info
+
+        get message as String is override
+            return 'info=[CobraCore.toTechString(_info)]'
+
+        get info from var as Object?
+
+
+    class SliceException inherits SystemException
+
+        cue init(msg as String?)
+            base.init
+*/
+}
+ No newline at end of file

Source/Cobra.Lang/java/mkjar

@@ +1 @@
+#!bash
+# Build script for java sources for cobra
+# Compile java source classes for java cobra RTL
+# copy them and std sig files to Source dir 
+
+[ -d classes ] || mkdir classes
+javac -d classes CobraImp.java CobraCore.java
+[ $? == 0 ] || exit
+jar cvf CobraLang.jar -C classes .
+[ $? == 0 ] || exit
+cp CobraLang.jar ../..
+
+#java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig
+## assume rt.jar, java.util and java.lang sigfiles already exist and are static
+#cp CobraLang.jar.sig rt.jar.sig java.util.sig java.lang.sig ../..

Source/Cobra.Lang/java/PkgSig.java

@@ +1 @@
+/*
+ * Generate a cobra package signature file
+ * compile: javac -cp . PkgSig.java
+ * run:     
+ *   generate sigfile for pkg in CLASSPATH 
+ *       java -cp . PkgSig <pkgname>    # generates to stdout
+ *       e.g java -cp . PkgSig java.lang    
+ *   run generating pkgSig file:  
+ *      java -cp . PkgSig <pkgname>  > <pkgname>.sig
+ *      e.g java -cp . PkgSig java.lang  > java.lang.sig  
+ *   generate sigfile for jarfile - relative pathnames searched for in dirs in CLASSPATH
+ *       java -cp . PkgSig -j <jarfile>    # generates to stdout
+ *       e.g java -cp . PkgSig -j rt.jar  > rt.jar.sig  
+ *           java -cp . PkgSig -j /JavaLibs/bsh-2.0b4.jar 
+ *  
+ * 
+ * TODO 
+ *  add cmdline flag generating pkgSig file w/o redirection:  
+ *      java -cp . PkgSig -cobra <pkgname>
+ *  Cleanup and javadoc this file.
+ * Put a PkgSig version and timestamp in the pkgSigFile
+ */
+
+import java.io.*;
+import java.util.*;
+import java.util.jar.*;
+import java.net.*;
+
+import java.lang.reflect.*;
+
+/**
+ * This abstract class can be used to obtain a list of all classes in a classpath.
+ *
+ * <em>Caveat:</em> When used in environments which utilize multiple class loaders--such as
+ * a J2EE Container like Tomcat--it is important to select the correct classloader
+ * otherwise the classes returned, if any, will be incompatible with those declared
+ * in the code employing this class lister.
+ * to get a reference to your classloader within an instance method use:
+ *  <code>this.getClass().getClassLoader()</code> or
+ *  <code>Thread.currentThread().getContextClassLoader()</code> anywhere else
+ * <p>
+ * @author Kris Dover <krisdover@hotmail.com>
+ * @version 0.2.0
+ * @since   0.1.0
+ * 
+ * Downloaded from:
+ * 
+ * Modified to output just class contents per cobra compiler requirements
+ * Mike Hopkirk Mar-2011
+ */
+public abstract class PkgSig { 
+    
+    static public class ClassComparator implements Comparator<Class> {
+        public int compare( Class cl, Class cl1) {
+        String n0 = cl.getName();
+        String n1 = cl1.getName();
+        return n0.compareTo(n1);
+        }
+    }
+    
+  /**
+   * Convenience for lookup for a single package name.
+   * <p>
+   * @param pkg     String name of a package to look for classes for
+   * @return A Set of Classes 
+   *
+   * @throws ClassNotFoundException if the current thread's classloader cannot load
+   *                                a requested class for any reason
+   */
+    public static Set<Class> findClassesForPkg(String pkg)  throws ClassNotFoundException {
+        ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        assert loader != null;
+        Set<String> pf = new HashSet<String>();
+        System.out.println("# PkgSig file for '" + pkg+ "'");
+        pf.add(pkg);
+        return findClasses(loader, pf, null);
+  }
+    
+   /**
+   * Searches the classpath for all classes matching a specified search criteria, 
+   * returning them in a map keyed with the interfaces they implement or null if they
+   * have no interfaces. The search criteria can be specified via interface, package
+   * and jar name filter arguments
+   * <p>
+   * @param classLoader       The classloader whose classpath will be traversed
+   * @param packageFilter     A Set of fully qualified package names to search for or
+   *                          or null to return classes in all packages
+   * @param jarFilter         A Set of jar file names to search for or null to return
+   *                          classes from all jars
+   * @return A Set of Classes 
+   *
+   * @throws ClassNotFoundException if the current thread's classloader cannot load
+   *                                a requested class for any reason
+   */
+   @SuppressWarnings("unchecked") 
+   public static Set<Class> findClasses(ClassLoader classLoader,
+                                        Set<String> packageFilter,
+                                        Set<String> jarFilter) throws ClassNotFoundException {
+       Set<Class> allClasses = new java.util.concurrent.ConcurrentSkipListSet(new PkgSig.ClassComparator());
+       Object[] classPaths = getClassPaths(classLoader);
+    
+       for (int h = 0; h < classPaths.length; h++) {
+           Enumeration files = null;
+           JarFile module = null;
+           // for each classpath ...
+           File classPath = new File( (URL.class).isInstance(classPaths[h]) ?
+                                  ((URL)classPaths[h]).getFile() : classPaths[h].toString() );
+           if ( classPath.isDirectory() /*&& jarFilter == null*/){   // is our classpath a directory and jar filters are not active?
+               List<String> dirListing = new ArrayList();
+               // get a recursive listing of this classpath
+               recursivelyListDir(dirListing, classPath, new StringBuffer() );
+               // an enumeration wrapping our list of files
+               files = Collections.enumeration( dirListing );
+           } else if( classPath.getName().endsWith(".jar") ) {    // is our classpath a jar?
+               // skip any jars not list in the filter
+               if (! classPath.exists())
+                   continue;
+
+               if ( jarFilter != null && !jarFilter.contains( classPath.getName() ) )
+                   continue;
+
+               try {
+                   // if our resource is a jar, instantiate a jarfile using the full path to resource
+                   module = new JarFile( classPath );
+               } catch (MalformedURLException mue){
+                   throw new ClassNotFoundException("Bad classpath. Error: " + mue.getMessage());
+               } catch (IOException io){
+                   throw new ClassNotFoundException("jar file '" + classPath.getName() + 
+                      "' could not be instantiated from file path. Error: " + io.getMessage());
+               }
+               System.out.println("# jarfile=" + module.getName());
+               // get an enumeration of the files in this jar
+               files = module.entries();
+           }
+      
+           // for each file path in our directory or jar
+           while( files != null && files.hasMoreElements() ){
+               String fileName = files.nextElement().toString();         // get each fileName
+    
+               if ( fileName.endsWith(".class") ) {
+                   processFile(fileName, classLoader, packageFilter, null, allClasses);
+               }
+               else if ( fileName.endsWith(".jar") ) {
+                   if ( jarFilter == null || jarFilter.contains( fileName )) {
+                       String pathName = classPath + File.separator + fileName;
+                       processJarFile(pathName, classLoader, packageFilter, null, allClasses);
+                   }
+               }
+           }
+      
+           // close the jar if it was used
+           if (module != null){
+               try {
+                   module.close();
+               } catch(IOException ioe) {
+                   throw new ClassNotFoundException("The module jar file '" + classPath.getName() +
+                             "' could not be closed. Error: " + ioe.getMessage());
+               }
+           }
+       } // end classpath for loop
+       return allClasses;                                            
+   } // end method
+
+    static private Object[] getClassPaths( ClassLoader classLoader) 
+    {
+        Object[] classPaths;
+        ArrayList<Object> al;
+        try {
+            // get a list of all classpaths fm classloader
+            classPaths = ((java.net.URLClassLoader) classLoader).getURLs();
+        } catch (ClassCastException cce){
+            // or cast failed; tokenize the system classpath
+            classPaths = System.getProperty("java.class.path", "").split(File.pathSeparator);      
+        }
+        al = new ArrayList<Object>(Arrays.asList(classPaths)); 
+        // alternative to above from classpath setting 
+        //classPaths = System.getProperty("java.class.path", "").split(File.pathSeparator);      
+        //al.addAll(Arrays.asList(classPaths)); 
+        //System.out.printf("# java.class.paths\n");
+        //for (Object o : classPaths)
+        //    System.out.printf("#   %s\n", o.toString());
+
+        //classPaths = System.getProperty("java.ext.dirs", "").split(File.pathSeparator);      
+        // calc fm java home - lotta jarfiles under here tho
+        //String jHome =  System.getProperty("java.home", "");
+        //jHome = jHome + File.separator + "lib";
+        //classPaths = new Object[]{jHome}; 
+
+        classPaths = System.getProperty("sun.boot.class.path", "").split(File.pathSeparator);      
+        al.addAll(Arrays.asList(classPaths)); 
+        // Print classpath searching along
+        //System.out.printf("# sun.boot.class.paths\n");
+        //for (Object o : classPaths)
+        //   System.out.printf("#   %s\n", o.toString());
+        //return classPaths;    
+        System.out.printf("# Class paths and boot paths being searched\n");
+        for (Object o : al)
+            System.out.printf("#   %s\n", o.toString());
+        return al.toArray();
+    } 
+    
+    
+  /**
+   * Recursively lists a directory while generating relative paths. This is a helper function for findClasses.
+   * Note: Uses a StringBuffer to avoid the excessive overhead of multiple String concatentation
+   *
+   * @param dirListing     A list variable for storing the directory listing as a list of Strings
+   * @param dir                 A File for the directory to be listed
+   * @param relativePath A StringBuffer used for building the relative paths
+   */
+    private static void recursivelyListDir(List<String> dirListing, File dir, StringBuffer relativePath){
+        int prevLen; // used to undo append operations to the StringBuffer
+    
+        // if the dir is really a directory 
+        if ( dir.isDirectory() ) {
+            File[] files = dir.listFiles();   // get a list of the files in this directory
+            // for each file in the present dir
+            for (int i = 0; i < files.length; i++) {
+                // store our original relative path string length
+                prevLen = relativePath.length();
+                // call this function recursively with file list from present
+                // dir and relateveto appended with present dir
+                recursivelyListDir(dirListing, files[i], relativePath.append( prevLen == 0 ? "" : "/" ).append( files[i].getName() ) );
+                //  delete subdirectory previously appended to our relative path
+                relativePath.delete(prevLen, relativePath.length());
+            }
+        } else {
+            // this dir is a file; append it to the relativeto path and add it to the directory listing
+            dirListing.add( relativePath.toString() );
+        }
+    }
+    
+    
+    @SuppressWarnings("unchecked") 
+    static private void processFile( String fileName, 
+                                ClassLoader classLoader, 
+                                Set<String> packageFilter,
+                                Set<String> suppressFilter,
+                                Set<Class> allClasses)  throws ClassNotFoundException {
+        // convert our full filename to a fully qualified class name without trailing ".class"
+        String className = fileName.replaceAll("/", ".").substring(0, fileName.length() - 6);
+        // debug class list
+        //System.out.println(className);
+        // skip any classes in packages not explicitly requested in our package filter          
+        if ( packageFilter != null) {
+            int li = className.lastIndexOf("."); 
+            if (li < 0 || (li > 0 && !packageFilter.contains(className.substring( 0, li))))
+                //System.out.println("skip " + className + " " + li);
+                return;
+        }     
+                                    
+        // suppress filtered package contents
+        if ( suppressFilter != null) {
+            for (String head : suppressFilter) {
+                if (className.startsWith(head))  {
+                    //System.out.println("suppress " + className);
+                    return;
+                }
+            }
+         }
+                                    
+        // get the class for our class name
+        Class theClass = null;
+        try {
+          theClass = Class.forName(className, false, classLoader);
+        } 
+        catch (NoClassDefFoundError e){
+          System.out.println("Skipping class '" + className + "' for reason " + e.getMessage());
+          return;
+        } 
+        catch (ClassNotFoundException cnfe) {
+          System.out.println("LOAD ERROR: Cannot find/load class '" + className + "'");
+          System.out.println("Ensure the jarfile or class directory containig the class is given in the classpath");
+          System.out.printf("e.g. java -cp '.%smy.jar' PkgSig -j my.jar\n", File.pathSeparator);
+          System.out.printf("     java -cp '.%s./java' PkgSig  com.mySource\n\n", File.pathSeparator);
+          throw cnfe;
+        }
+                                    
+        int m = theClass.getModifiers();
+        //if( java.lang.reflect.Modifier.isPublic(m) )
+        //if( ! java.lang.reflect.Modifier.isPrivate(m) )
+        if(  Modifier.isPublic(m) || Modifier.isProtected(m) )
+            allClasses.add( theClass );
+
+        // skip interfaces
+        //if( theClass.isInterface() ){
+        //  continue;
+        //}
+        //accumulateInterfaces(theClass, classTable);  
+    }
+    
+                        
+    @SuppressWarnings("unchecked") 
+    static private void processJarFile( String fileName, 
+                                ClassLoader classLoader, 
+                                Set<String> packageFilter,
+                                Set<String> suppressFilter,
+                                Set<Class> allClasses)  throws ClassNotFoundException 
+    {
+        JarFile module = null;
+        try {
+            module = new JarFile( fileName );
+        } catch (MalformedURLException mue){
+            throw new ClassNotFoundException("Bad classpath. Error: " + mue.getMessage());
+        } catch (IOException io){
+            throw new ClassNotFoundException("jar file '" + fileName + 
+                      "' could not instantiate Jar from file path. Error: " + io.getMessage());
+        }
+        System.out.println("# jarfile:  "+ module.getName());
+        Enumeration files = module.entries();
+        while( files != null && files.hasMoreElements() ){
+            String fileNameEl = files.nextElement().toString(); 
+            if ( fileNameEl.endsWith(".class") ) {
+                //System.out.println("#file:"+fileNameEl);
+                processFile(fileNameEl, classLoader, packageFilter, suppressFilter, allClasses);
+            }
+        }
+
+      if (module != null) {
+          try {
+              module.close();
+          } catch(IOException ioe) {
+              throw new ClassNotFoundException("The module jar file '" + fileName +
+                "' could not be closed. Error: " + ioe.getMessage());
+          }
+      }
+    }
+    
+    // --- New cobra stuff from here
+
+    public static void usage() {
+        System.out.println("Unknown usage");
+        System.out.printf("usage: pkgSig [-p] <pkgName>\n");
+        System.out.printf("usage: pkgSig -j <jarfile>\n ");
+        System.out.printf("  Display class signatures for a package or contents of a jarfile.\n\n ");
+        System.out.printf("A class signature is the class name, its superclass and signatures for fields and methods of the class.\n");
+        System.out.printf("Packages are searched for in files and jars in classpath.\n");
+        System.out.printf("Jarfiles are specified as relative or absolute pathnames. Relative pathname Jarfiles not found are searched for in the classpath\n");
+        System.out.printf("Output format is suitable for parsing and use by the cobra java backend (cross) compiler.\n");
+        System.exit(2);
+    }
+    
+    public static File lookForJarFile( String fileName, ClassLoader loader) {
+        File jarFile = new File(fileName);
+        if ( jarFile.exists())
+            return jarFile;
+        
+        // search for jarfile in Classpath
+        if ( ! jarFile.isAbsolute() ) {
+            Object[] classPaths = getClassPaths(loader);
+            //for (int h = 0; h < classPaths.length; h++) {
+            for ( Object cpo : classPaths) { // for each classpath ...
+                //System.out.printf("DBG: cpo %s\n", cpo.toString());
+                File classPath = new File((URL.class).isInstance(cpo) ? ((URL)cpo).getFile() : cpo.toString());
+                if ( classPath.getName().endsWith(".jar") ) {     // is our classpath a jar?
+                    if (classPath.getName().endsWith(fileName)) {
+                        jarFile = classPath;
+                        break;
+                    }
+                }
+                else if ( classPath.isDirectory() ) { 
+                    jarFile = new File(classPath, fileName);
+                    //System.out.printf("DBG trying %s\n", jarFile.getAbsolutePath());
+                    if (jarFile.exists())
+                        break;
+               }
+            }
+        }
+        return jarFile;
+    }
+    
+    
+    public static void main( String[] args) throws Exception {
+        if (args.length ==0 )
+              usage();
+
+        if (args.length == 1 ) {  // default -p pkgname [...]
+            if ( args[0].startsWith("-")) usage();
+
+            String pkg = args[0];
+            Set<Class> clsSet = PkgSig.findClassesForPkg(pkg);
+            if (clsSet.size() == 0 )
+            {
+                System.out.printf("No package '%s' found in classPath\n", pkg);
+                System.exit(1);
+            }
+
+            for ( Class cls : clsSet) {
+                    //Class cls = (Class)o;
+                    //System.out.println(cls.getName());
+                ClassSig classSig = new ClassSig(cls);
+                classSig.emit();    
+            }
+        }
+        else if (args[0].equals("-p")) {
+            String pkg = args[1];
+            Set<Class> clsSet = PkgSig.findClassesForPkg(pkg);
+            for ( Class cls : clsSet) {
+                //ClassSig classSig = new ClassSig(cls);
+                //classSig.emit();    
+                new ClassSig(cls).emit();
+            }
+        }
+        else if (args[0].equals("-j")) {
+            ClassLoader loader = Thread.currentThread().getContextClassLoader();
+            assert loader != null;
+            String fileName = args[1];
+            File jarFile = PkgSig.lookForJarFile(fileName, loader);
+            if ( !jarFile.exists()) {
+                System.out.printf("File '%s' does not exist.\n", jarFile.getAbsolutePath());
+                System.exit(1);
+            }
+            
+            //System.out.printf( "DBG: jarfile=%s\n", jarFile.getAbsolutePath());
+        Set<Class> clsSet = new java.util.concurrent.ConcurrentSkipListSet<Class>(new PkgSig.ClassComparator());
+            Set<String> suppressFilter = new HashSet<String>();
+            // Theres upwards of 8000 classes in rt.jar most of which we dont care about
+            // suppress internal implementation classes which shouldnt be using anyway
+            suppressFilter.add("com.sun");
+            suppressFilter.add("com.sunw");
+            suppressFilter.add("sun");
+            suppressFilter.add("sunw");
+            // suppress some biggies we 'probably' wont ever use - may want to revisit these
+            suppressFilter.add("org.omg");
+            suppressFilter.add("javax.swing.plaf");
+            suppressFilter.add("javax.print.attribute.standard");
+            suppressFilter.add("org.jcp.xml.dsig");
+
+            System.out.printf("# PkgSig file for jarfile '%s'\n", jarFile.getAbsolutePath());
+            processJarFile(jarFile.getAbsolutePath(), loader, null, suppressFilter, clsSet);
+        
+            for ( Class cls : clsSet) {
+                new ClassSig(cls).emit();
+            }
+        }
+        else {
+            usage();
+        }
+              
+            
+   }
+}
+
+// This class emits class info in format suitable for cobra compiler to (easily) parse.
+// see Source/BackEndJvm/JvmJarSig.cobra
+// Any changes made here should be in lockstep with that file....
+class ClassSig {
+    Class cls;
+    TypeVariable<?>[] genericParams = {};
+    int indent= 0;
+    
+    public ClassSig(Class cls) {
+        this.cls = cls;
+    }    
+
+    // main entry point
+    public void emit() {
+        // suppress anon inner classes
+        if ( this.cls.getSimpleName().trim().length() == 0 )
+            return;
+        
+              
+        System.out.println("\n" + this.cls.getName());
+        this.indent++;
+        emitClassHeader();
+        emitFields();
+        emitConstructors();
+        emitMethods();
+        this.indent--;
+    }
+    
+    public boolean isPkgPrivate(int m) {
+        // if (!cobraGen)
+        //  return false
+
+        // suppress classes that have only pkgPrivate (default) accessability
+        return (! Modifier.isPublic(m) && !Modifier.isProtected(m) && !Modifier.isPrivate(m));
+    }
+    
+    public void emitClassHeader() {
+        String flags ="";
+        String t ="class";
+        if (this.cls.isInterface()) t ="Interface";
+        else if (this.cls.isEnum()) t ="Enum";
+        printIndent();
+        System.out.printf( "%-30s %s\n", t, "# JavaType");
+        
+        printIndent();
+        System.out.printf("%-30s %s\n", this.cls.getPackage().getName(), "# package");
+        
+        // Name of the class, dotNet form for Generic class
+        String clsName = this.cls.getSimpleName();
+        Class enclClass = this.cls.getEnclosingClass();
+        if ( enclClass != null) {
+            clsName = enclClass.getSimpleName() + "$" + this.cls.getSimpleName();
+            flags += "N";
+        }
+        String gName = this.dotNetGenericsName(this.cls, clsName);
+        if (! gName.isEmpty()) {
+            clsName = gName;
+            //System.out.print(gName);
+            flags += "G";
+        }
+        
+        printIndent();
+        System.out.printf("%-30s %s", clsName, "# name");
+        System.out.println();
+        
+        //Superclass name - Use Generics superclass if have one and display in dotNet form
+        Class superCls = this.cls.getSuperclass();
+        String superName = "-";
+        if ( superCls != null)
+            superName = superCls.getName();
+        if ( superName != "-") {
+            String gSuperName = this.dotNetGenericsSuperName(this.cls);
+            if (! gSuperName.isEmpty() ) {
+                superName = gSuperName;
+            }
+        }
+        printIndent();
+        System.out.printf("%-30s %s", superName, "# superclass");
+        System.out.println();
+
+        //  Interfaces
+        //System.out.printf("%-30s %s\n", '-', " # interfaces");
+        //Class[] interfaces = this.cls.getInterfaces();
+        //emitClassList(interfaces, "interfaces");
+        Type[] gInterfaces = this.cls.getGenericInterfaces();
+        emitTypesList(gInterfaces, " Interfaces");
+
+        // Modifiers
+        //System.out.printf("%-30s %s\n", '-', " # modifiers");
+        int m = this.cls.getModifiers();
+        emitModifiers(m);
+
+        if (this.genericParams.length > 0 )  // is a generic class
+            emitGenericClassParameters(); 
+    }
+    
+    void printIndent() {
+        for (int i=0; i < indent; i++)
+            System.out.print("    ");       // 4 spaces
+    }
+    
+    String dotNetGenericsName( Class cls, String clsName) {
+        // generics class naming like .Net  TypeName`<nTypeParams>
+        String gName="";
+        TypeVariable<?>[] gParams = cls.getTypeParameters();
+        if (gParams.length > 0) { // 0 TypeParameters -> not generic
+            gName = String.format("%s`%d", clsName, gParams.length);
+            //System.out.printf(" gName=%s`%d", clsName, genArgs.length);            
+            this.genericParams = gParams; // copy for later use
+        }
+        return gName;
+    }
+    
+    String dotNetGenericsSuperName( Class cls) {
+        Type gsuperCls = cls.getGenericSuperclass();
+        String gsuperName = "";
+        //gsuperName = gsuperCls.getCanonicalName();
+        if ( gsuperCls instanceof ParameterizedType) {
+            gsuperName = gsuperCls.toString(); // this seems the only way to get the name
+            int idx = gsuperName.indexOf("<"); 
+            gsuperName = gsuperName.substring(0, idx); // break off GenericTypes
+            // System.out.printf(" gSuper=%-30s", gsuperName);
+            //gsuperName = gsuperCls.getCanonicalName();
+            Type[] typeArgs = ((ParameterizedType)gsuperCls).getActualTypeArguments();
+            if (typeArgs.length > 0) { // 0 TypeParameters -> not generic
+                gsuperName = String.format("%s`%d", gsuperName, typeArgs.length);
+            }
+        }
+        return gsuperName;
+    }
+
+    @SuppressWarnings("unchecked") 
+    public void emitFields() {
+        Field[] fields = this.cls.getDeclaredFields();
+        for (java.lang.reflect.Field f : fields) {
+            int m = f.getModifiers();
+            if( java.lang.reflect.Modifier.isPrivate(m) || isPkgPrivate(m))
+                continue;
+            printIndent();
+            
+            //printIndent();
+            //System.out.printf("%s\n", f.getName());
+            System.out.print("var ");
+            System.out.println(f.getName());
+            this.indent++;
+
+            emitModifiers(m);
+
+            if (this.cls.isEnum()) {
+                printIndent();
+                String typeName = f.getType().getName();
+                System.out.printf("%s\n", typeName);
+                if ( f.getType().isEnum()) {
+                    this.indent++;
+                    printIndent();
+                    System.out.printf("%d\n", Enum.valueOf( this.cls, f.getName()).ordinal() );
+                    //System.out.printf("%s\n", Enum.valueOf( this.cls, f.getName()));
+                    this.indent--;
+                }
+            }    
+            else
+            {
+                String gTypeStr = this.makeTypeStr(f.getGenericType());
+                String tag = "# Type";
+                if (gTypeStr.contains("<"))
+                    tag = "# generic Type :G";
+                printIndent();
+                System.out.printf("%-30s %s\n", gTypeStr, tag);
+            }          
+            
+                
+            //TODO attributes
+            //printIndent();
+            //System.out.printf("%s\n", '-');
+            this.indent--;      
+        }
+    }
+            
+    public void emitModifiers(int m) {
+        StringBuilder sb = new StringBuilder();
+        if (Modifier.isStatic(m))    sb.append("static ");
+        if (Modifier.isAbstract(m))  sb.append("abstract ");
+        if (Modifier.isSynchronized(m))  sb.append("synchronized ");
+        if (Modifier.isFinal(m))     sb.append("final ");
+        if (Modifier.isPublic(m))    sb.append("public ");
+        if (Modifier.isProtected(m)) sb.append("protected ");
+        if (Modifier.isPrivate(m))   sb.append("private ");
+        if (! Modifier.isPublic(m) && !Modifier.isProtected(m) && !Modifier.isPrivate(m))
+            sb.append("default ");
+        printIndent();
+        String comment = "# modifiers";
+        if (sb.length() == 0 ) comment = "# no modifiers";
+        System.out.format("%-30s %s\n", sb.toString(), comment);
+    }
+
+    public void emitConstructors() {
+        Constructor[] ctors = this.cls.getDeclaredConstructors();
+        for (Constructor ctor : ctors) {
+            int m = ctor.getModifiers();
+            if( java.lang.reflect.Modifier.isPrivate(m) || isPkgPrivate(m))
+                continue;
+
+            printIndent();
+
+            this.indent++;
+            System.out.print("ctor ");
+            System.out.println(ctor.getName());
+
+            //Class[] parTypes = ctor.getParameterTypes();
+            //emitClassList(parTypes, "parameters");
+            Type[] gparTypes = ctor.getGenericParameterTypes();
+            emitTypesList(gparTypes, "Parameters");
+
+            this.indent--;
+        }
+    }
+
+    public void emitMethods() {
+        Method[] methods = this.cls.getDeclaredMethods();
+        for (Method m : methods) {
+            int mod = m.getModifiers();
+            if( Modifier.isPrivate(mod) || isPkgPrivate(mod) ) continue;
+
+            printIndent();
+            System.out.print("method ");
+            String mName = m.getName();
+            if (m.isVarArgs())
+                mName = mName + "[V]" ;     
+            System.out.println(mName);
+            
+            this.indent++;
+            emitModifiers(mod);
+            
+            //Class retType = m.getReturnType();
+            //String retTypeName = retType.getName();
+            //printIndent();
+            //System.out.printf("%-30s %s\n", retTypeName, "# returnType");
+            String retTypeStr = this.makeTypeStr(m.getGenericReturnType());
+            //if (! retTypeStr.startsWith(retTypeName)) 
+            {
+                printIndent();
+                String tag = "# returnType";
+                if (retTypeStr.contains("<"))
+                    tag = "# generic returnType :G";
+                System.out.printf("%-30s %s\n", retTypeStr, tag);
+            }          
+            
+            //Class[] parTypes = m.getParameterTypes();
+            //emitClassList(parTypes, "parameters");
+            Type[] gparTypes = m.getGenericParameterTypes();
+            emitTypesList(gparTypes, "Parameters");
+            
+            //Class[] exceptions = m.getExceptionTypes();
+            //emitClassList(exceptions, "exceptions");
+            Type[] gExcTypes = m.getGenericExceptionTypes();
+            emitTypesList(gExcTypes, "Exceptions");
+
+            this.indent--;
+        }
+    }
+
+    public void emitClassList(Class[] clsList, String tag) {
+        printIndent();
+        StringBuilder sb = new StringBuilder();
+        String sep = "";
+        for (Class c : clsList) {
+            sb.append(sep);
+            sb.append(c.getName());
+            sep = ",";
+        }
+        if (clsList.length == 0 ) 
+            sb.append("-");
+        
+        String commentPrefix = ((clsList.length == 0 ) ?
+              "# no " :
+              "# ");
+        StringBuilder comment = new StringBuilder(commentPrefix);
+        comment.append(tag);
+        System.out.printf("%-30s %s\n", sb.toString(), comment.toString());
+    }
+
+    public void emitGenericClassParameters() {
+        assert this.genericParams.length > 0 ;
+        //if (this.genericParams.length == 0 )  // not a generic class
+        //    return; 
+        
+        StringBuilder sb = new StringBuilder();
+        String sep = "";
+        for (TypeVariable<?> p : this.genericParams) { // 
+            sb.append(sep);
+            sb.append(p.getName());
+            sep = ",";
+        }
+        //if (this.genericParams.length == 0 ) 
+        //    return; //sb.append("-");
+        
+        String commentPrefix = ((this.genericParams.length == 0 ) ? "# no " : "# ");
+        StringBuilder comment = new StringBuilder(commentPrefix);
+        comment.append(" Generic Parameter list :G");
+        printIndent();
+        System.out.printf("%-30s %s\n", sb.toString(), comment.toString());
+    }
+    
+    public void emitTypesList(Type[] typList, String tag) {
+        StringBuilder sb = new StringBuilder();
+        String sep = "";
+        for (Type t : typList) {
+            sb.append(sep);
+            String tStr = this.makeTypeStr(t);
+            sb.append(tStr);
+            sep = ",";
+        }
+        if (typList.length == 0 ) {
+            //if (isOptional)
+            //    return; 
+            //else
+                sb.append("-");
+        }
+        
+        String commentPrefix = ((typList.length == 0 ) ?
+              "# no " :
+              "# ");
+        StringBuilder comment = new StringBuilder(commentPrefix);
+        comment.append(tag);
+        if (sb.toString().contains("<"))
+            comment.append(" :G");
+
+        printIndent();
+        System.out.printf("%-30s %s\n", sb.toString(), comment.toString());
+    }
+    
+    /*
+     * Cleanup a (Generic) Type name to be 'consistant' with class naming.
+     */
+    public String makeTypeStr(Type t) {
+        String tStr = t.toString();
+        tStr = tStr.replace("class ", "");  // sometimes puts on leading 'type '
+        tStr = tStr.replace("interface ", "");  
+        // possibly others - enum ?
+        tStr = tStr.replace("<?>", "");     // lose generic wildcard
+        if ( tStr.endsWith("[]")) {     // Type makes ' <name>[]' rather than '[L<name>;' for arrays
+            StringBuilder sfx = new StringBuilder();
+            while (tStr.endsWith("[]")) {
+                tStr = tStr.substring(0, tStr.length()-2);
+                sfx = sfx.append("[");
+            }
+            sfx.append("L");
+            sfx.append(tStr);
+            sfx.append(";");       
+            tStr = sfx.toString();
+        }
+        return tStr;
+    }
+}

Source/Cobra.Lang/java/CobraLang.jar.sig

@@ +1 @@
+# PkgSig file for jarfile 'C:\home\hops\src\cobra\wkspace\Source\Cobra.Lang\java\CobraLang.jar'
+# jarfile:  C:\home\hops\src\cobra\wkspace\Source\Cobra.Lang\java\CobraLang.jar
+
+cobra.lang.CobraCore
+    class                          # JavaType
+    cobra.lang                     # package
+    CobraCore                      # name
+    java.lang.Object               # superclass
+    -                              # no  Interfaces
+    public                         # modifiers
+    var _willCheckInvariant
+        static public                  # modifiers
+        java.lang.Boolean              # Type
+    var _willCheckRequire
+        static public                  # modifiers
+        java.lang.Boolean              # Type
+    var _willCheckEnsure
+        static public                  # modifiers
+        java.lang.Boolean              # Type
+    var _willCheckAssert
+        static public                  # modifiers
+        java.lang.Boolean              # Type
+    var _willCheckNil
+        static public                  # modifiers
+        java.lang.Boolean              # Type
+    ctor cobra.lang.CobraCore
+        -                              # no Parameters
+    method noOp[V]
+        static public                  # modifiers
+        int                            # returnType
+        [Ljava.lang.Object;            # Parameters
+        -                              # no Exceptions
+    method runAllTests
+        static public                  # modifiers
+        void                           # returnType
+        -                              # no Parameters
+        -                              # no Exceptions
+    method printDebuggingTips
+        static public                  # modifiers
+        void                           # returnType
+        -                              # no Parameters
+        -                              # no Exceptions
+
+cobra.lang.CobraImp
+    class                          # JavaType
+    cobra.lang                     # package
+    CobraImp                       # name
+    java.lang.Object               # superclass
+    -                              # no  Interfaces
+    public                         # modifiers
+    var _printStringMaker
+        static public                  # modifiers
+        cobra.lang.CobraImp$SimpleStringMaker # Type
+    ctor cobra.lang.CobraImp
+        -                              # no Parameters
+    method printLine
+        static public                  # modifiers
+        void                           # returnType
+        -                              # no Parameters
+        -                              # no Exceptions
+    method printLine
+        static public                  # modifiers
+        void                           # returnType
+        java.lang.String               # Parameters
+        -                              # no Exceptions
+    method printStop
+        static public                  # modifiers
+        void                           # returnType
+        -                              # no Parameters
+        -                              # no Exceptions
+    method printStop
+        static public                  # modifiers
+        void                           # returnType
+        java.lang.String               # Parameters
+        -                              # no Exceptions
+    method makeString
+        static public                  # modifiers
+        java.lang.String               # returnType
+        java.lang.String               # Parameters
+        -                              # no Exceptions
+    method makeString
+        static public                  # modifiers
+        java.lang.String               # returnType
+        [Ljava.lang.String;            # Parameters
+        -                              # no Exceptions
+
+cobra.lang.CobraImp$SimpleStringMaker
+    class                          # JavaType
+    cobra.lang                     # package
+    CobraImp$SimpleStringMaker     # name
+    java.lang.Object               # superclass
+    -                              # no  Interfaces
+    static public                  # modifiers
+    ctor cobra.lang.CobraImp$SimpleStringMaker
+        -                              # no Parameters
+    method makeString
+        public                         # modifiers
+        java.lang.String               # returnType
+        [Ljava.lang.String;            # Parameters
+        -                              # no Exceptions
+    method makeString
+        public                         # modifiers
+        java.lang.String               # returnType
+        java.lang.String               # Parameters
+        -                              # no Exceptions
+    method makeString
+        public                         # modifiers
+        java.lang.String               # returnType
+        int                            # Parameters
+        -                              # no Exceptions
+    method makeString[V]
+        public                         # modifiers
+        java.lang.String               # returnType
+        [Ljava.lang.Object;            # Parameters
+        -                              # no Exceptions

Source/Cobra.Lang/java/00-README

@@ +1 @@
+README for cobra java backend cross compiler devt.
+--------------------------------------------------
+
+Task: Make the cobra compiler generate Java code (a java back end).
+
+Initially (now) this is a cross compiler. The .Net cobra compiler will
+with the correct switch (-back-end:jvm) generate java source for the given
+cobra source, compile it and run it.
+  i.e A cobra to java compiler (compiler running) on .Net
+
+Eventually when I have bootstrapped enough java codegeneration capability
+and worked out a few issues I'll run the cross compiler on the 
+(probably heavily modified) compiler source and build a java version of the 
+compiler. Then we'll have a cobra to java compiler on the jvm.
+
+Supporting that is this directory which provides 
+    - stub code for a java cobra RTL (CobraLang.jar)
+    - A tool to generate descriptions for java library classes (Pkgsig files)
+    - a script to build and copy the various supporting pieces the java backend needs to the compiler Source directory.
+    
+
+The base java version supported is 1.6.
+This one specifically
+java version "1.6.0_24"
+Java(TM) SE Runtime Environment (build 1.6.0_24-b07)
+Java HotSpot(TM) Client VM (build 19.1-b02, mixed mode, sharing)
+ 
+= Caveats =
+
+This backend  is under development 
+ - for any but the most trivial uses it is effectively broken.
+ There are large amounts of (java) code generation missing.
+ It spews debug/diagnostic/conversational/status info all the time.
+ There are bugs.
+ There are missing capabilities.  
+ There are horrible bits 
+ 
+Regardless, the .Net/Mono/C# compilation should continue to run as per the 
+standard source distribution without problems.
+Specifically all the tests should run.
+
+This is a compiler mod only - there is no support for any sort of a
+common/shared/portable system library. 
+
+This is a source modification - no installation support. 
+Run the compiler out of the cobra source directory
+
+I'm developing this in Windows (XP) - it may or may not be working under mono 
+on any other platform.
+
+This is (the/an) initial devt snapshot. 
+Its working(ish) but rough, 
+Things will change
+
+- What To Do -
+
+ If you are brave or foolhardy enough to want to run this and see what 
+ happens, good for you.
+ This is what you will need to do
+
+    1) Apply the patches providing the java backend to the Source tree
+        - get the modified compiler subsequently rebuilt
+        Patch should be on the cobra website http://cobra-language.com
+        Ticket 275: More support for java backend
+            http://cobra-language.com/trac/cobra/ticket/275
+        
+    2) Ensure java and javac executables (1.6) are in your PATH and work.
+    
+    3) Go into this dir and run ./mkJarAll 
+        ( its a bash script - you will need bash or to port the script, 
+            or run the command contents manually) - this builds the 
+        tool and uses that to create the class description info and copies 
+        it to the  right places in the  cobra source tree)
+    4) find a test cobra script and compile it
+
+- How to build and run a cobra program generating a java app -
+
+    cobra -back-end:jvm -v:2 -verbosity-ref:1 -kif file.cobra
+
+    -v:2 - display some compile run info
+    -verbosity-ref:1   display (std) info about reading jarfiles
+    -kif - leave the generated java files around after compilation
+    file.cobra - the cobra source file to compile
+    
+If you are lucky you'dll get a whole lot of compiler output at the end of 
+which you'll see a javac invocation followed by a successful execution 
+of the translated cobra program.
+
+If you are unlucky you'll see error lines from the javac compilation phase cos
+the cobra program exercises something thats not implemented (java codegen wise).
+
+If you are really unlucky something in the compiler will break and the
+cobra compiler will barf some sort of exception.
+
+
+
+- Status - 
+ Jul-2011 - We can build and run simple (single file) programs. 
+    (Up to about 032-* of the files in Tests/100-*. 
+        Maybe more but thats what I've tried so far)
+    We seem to be understanding references to java classes in library (jar) files. 
+
+- Other -
+
+Post issues/questions/comments/etc if you have them to Cobra Programming Language Forum
+http://cobra-language.com/forums/viewforum.php
+theres an existing topic 'Java Back End' or open new ones.
+
+
+
+- hops
+

Source/Cobra.Lang/java/CobraImp.java

@@ +1 @@
+/*
+ * CobraImp.java
+ * Native java support code RTL
+ *
+ *  Currently only stubbed, minimal native code impl.
+ */
+package cobra.lang;
+
+import java.lang.*;
+
+ 
+public class CobraImp {
+    // simple minimal StringMaker pending cobra compilation of StringMaker.cobra
+    public static class SimpleStringMaker {
+        
+        public String makeString(String[] args) {
+            StringBuilder sb = new StringBuilder();
+        for (Object arg : args)
+        sb.append(arg);
+            return sb.toString();
+    }
+        public String makeString(String s) {
+            return s;
+    }
+        public String makeString(int i) {
+            return new Integer(i).toString();
+    }
+        
+        public String makeString(Object... args) {
+            StringBuilder sb = new StringBuilder();
+        for (Object arg : args)
+        sb.append(arg.toString());
+            return sb.toString();
+    }
+    }
+    //static public StringMaker _printStringMaker;
+    static public SimpleStringMaker _printStringMaker = new SimpleStringMaker();
+    
+    static {
+    //  _printToStack = new Stack<TextWriter>();
+    //  PushPrintTo(Console.Out);
+    //_printStringMaker = new SimpleStringMaker();
+    //  _printStringMaker = new PrintStringMaker();
+    //  _techStringMaker = new TechStringMaker();
+    //  PromoteNumerics = NumericTypeInfo.PromoteNumerics;
+    }
+    
+    static public void printLine() {
+    //_printToStack.Peek().WriteLine();
+        System.out.println();
+    }
+
+    static public void printLine(String s) {
+    //  _printToStack.Peek().WriteLine(s);
+        System.out.println(s);
+    }
+
+    static public void printStop() {
+    }
+
+    static public void printStop(String s) {
+    //  _printToStack.Peek().Write(s);
+        System.out.print(s);
+    }
+
+    static public String makeString(String[] args) {
+        return _printStringMaker.makeString(args);
+    }
+          
+    static public String makeString(String s) {
+        return s;
+    }
+
+}
+

Source/Cobra.Lang/java/mkjarAll

@@ +1 @@
+#!bash
+# Build script for java sources for cobra (on MSWindows (XP))
+# Compile java source classes for java cobra RTL
+# copy them and std sig files to Source dir 
+
+echo 'making RTL from java sources'
+[ -d classes ] || mkdir classes
+javac -d classes CobraImp.java CobraCore.java
+[ $? == 0 ] || exit
+jar cvf CobraLang.jar -C classes .
+[ $? == 0 ] || exit
+cp CobraLang.jar ../..
+
+if [ ! -e PkgSig.class ]; then 
+    echo 'building PkgSig app'
+    javac -cp . PkgSig.java
+fi
+
+echo 'Gen pkgSig file for CobraLang.jar'
+java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig
+
+echo 'Gen pkgSig file for rt.jar'
+java -cp .  PkgSig -j rt.jar > rt.jar.sig
+echo 'Gen pkgSig file for java.lang'
+java -cp .  PkgSig  java.lang > java.lang.sig
+echo 'Gen pkgSig file for java.util'
+java -cp .  PkgSig  java.util > java.util.sig
+
+echo 'copy .sig files to compiler directory'
+cp CobraLang.jar.sig rt.jar.sig java.util.sig java.lang.sig ../..

Source/Container.cobra

@@ -167 +167 @@
         ensure
             result implies result.name==name
         body
+            #print _declsByName.keys
             return if(_declsByName.containsKey(name), _declsByName[name], nil)
 
     def declForName(name as String) as IMember?

Source/BinaryOpExpr.cobra

@@ -534 +534 @@
 
     # TODO: handle the real equals and does not equal
 
-    var _cobraToSharp = {
-        'EQ': '==',
-        'NE': '!=',
-        'GT': '>',
-        'LT': '<',
-        'GE': '>=',
-        'LE': '<=',
-        'IS': '==',
-        'ISNOT': '!=',
-    }
-    
     var _items as List<of Expr>
     var _operations as List<of String>
 

Source/Module.cobra

@@ -27 +27 @@
         base.addMinFields
         .addField('fileName', _fileName)
 
-
+# Would be better named LibModule or similar
 class AssemblyModule inherits Module is partial
     """
-    An assembly module represents a .dll
+    An assembly module represents a .dll, jarfile or libraryish thing
+    Basically a holder for a filename (location) and a namespace for its contents
     """
     
     var _topNameSpace as NameSpace
     var _mustBindInhList = List<of INameSpaceMember>()
 
-    cue init(ass as Assembly, globalNS as NameSpace)
-        .init(ass, 0, globalNS)
+    #cue init(ass as Assembly, globalNS as NameSpace)
+    #   .init(ass, 0, globalNS)
 
-    cue init(ass as Assembly, verbosity as int, globalNS as NameSpace)
-        base.init(ass.location, verbosity, '')
-        _topNameSpace = NameSpace(globalNS, '(top namespace for assembly [ass])')
+    #cue init(ass as Assembly, verbosity as int, globalNS as NameSpace)
+    #   base.init(ass.location, verbosity, '')
+    #   _topNameSpace = NameSpace(globalNS, '(top namespace for assembly [ass])')
 
+    cue init(location as String, globalNS as NameSpace)
+        .init(location, 0, globalNS)
+
+    cue init(location as String, verbosity as int, globalNS as NameSpace)
+        base.init(location, verbosity, '')
+        _topNameSpace = NameSpace(globalNS, '(top namespace for assemblyModule at [location])')
+
     def addMustBindInh(what as INameSpaceMember)
         require .compiler.curModule is this
         _mustBindInhList.add(what)

Source/Node.cobra

@@ -1188 +1188 @@
     ## More types
     # TODO: move up to ITypeProvider?
 
-    get clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>?
+    #get clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>?
+    get primitiveToITypeCache as IDictionary<of dynamic, IType>?
 
     get basicTypes as IList<of PrimitiveType>
 
@@ -1215 +1216 @@
     def setOfType as Class
     def stringType as Class
 
+    # multiple backends
+    get backEnd as BackEnd
+    def objectTypeProxy as AbstractTypeProxy 
+    def typeTypeProxy as AbstractTypeProxy 
+    def installNativeMethods(box as Box, nativeType as NativeType)
 
     ## Other
 
     def addIntermediateFile(path as String)
-    def loadReference(reference as String) as bool
+    def loadReference(reference as String, addExtn as bool) as bool

Source/CommandLine.cobra

@@ -739 +739 @@
         try
             comp.initBackEnd
             reference = .options['document-library'] to String  # to-do: pick out type name. to-do: support multiple references
-            if not reference.endsWith('.dll') and not reference.endsWith('.exe'), reference += '.dll'  # todo-backend
+            reference = comp.backEnd.fixLibExtension(reference)
             .options['reference'] = [reference]
             phaseClasses = [
                 BindRunTimeLibraryPhase,

Source/Phases/BindUsePhase.cobra

@@ -87 +87 @@
             # curNS = nil # force reference attempt
         if curNS is nil and not didAutoLoad
             if _fileName <> ''
-                if .compiler.loadReference(_fileName + '.dll')
+                #if .compiler.loadReference(_fileName + '.dll')
+                if .compiler.loadReference(_fileName, true)
                     _bindUse(true)
                     if .boundNameSpace is nil
                         .throwError('Cannot find namespace "[_fullName]" in library "[_fileName]".')
@@ -100 +101 @@
             else
                 if _fullName.endsWith('.dll')
                     .throwError('Do not end a namespace name in a "use" directive with ".dll".')
-                if .compiler.loadReference(_fullName + '.dll')
+                #if .compiler.loadReference(_fullName + '.dll')
+                if .compiler.loadReference(_fullName, true)
                     _bindUse(true)
                     if .boundNameSpace is nil
                         .throwError('Cannot find namespace "[_fullName]" in loaded library "[_fullName]".')

Source/Phases/ParsePhase.cobra

@@ -25 +25 @@
         extraSource = .options.getDefault('extra-source', '').trim to String
         if extraSource <> ''
             # CC: parser = CobraParser(verbosity=.verbosity, typeProvider=this, warningRecorder=this, errorRecorder=this, globalNS=compiler.globalNS, parseCommandLineArgs=ref .parseCommandLineArgsCallBack)
-            parser = CobraParser(verbosity=.verbosity, typeProvider=compiler, warningRecorder=compiler, errorRecorder=compiler, globalNS=compiler.globalNS)
+            parser = CobraParser()
+            parser.verbosity=.verbosity
+            parser.typeProvider = compiler # compiler.typeProvider
+            parser.warningRecorder = compiler
+            parser.errorRecorder = compiler
+            parser.globalNS=compiler.globalNS
             parser.parseCommandLineArgs = ref .parseCommandLineArgsCallBack
+            parser.backEnd = compiler.backEnd
             errorsCount = compiler.errors.count
             try
                 module = parser.parseSource('_ch_cobra-extra-source.cobra', extraSource)  # ch = compiler helper
@@ -35 +41 @@
                 throw
             if compiler.errors.count > errorsCount
                 _printExtraSource(extraSource)
-            for r in parser.references, compiler.loadReference(r.fixLibExtension)
+            for r in parser.references, compiler.loadReference(.compiler.backEnd.fixLibExtension(r), false)
             modules.add(module)
 
         didError = false
         for filename in .compiler.pathsToCompile
-            if filename.endsWith('.cs')
-                if .verbosity, print 'Noting  [filename]'  # extra space to line up with 'Parsing [filename]'
-                modules.add(SharpModule(filename, .verbosity))
+            nativeModule = .compiler.backEnd.genNativeModule(filename, .verbosity)
+            if nativeModule
+                modules.add(nativeModule) # SharpModule or JavaModule or ...
             else
                 parser = CobraParser()
                 parser.verbosity = .verbosity
@@ -52 +58 @@
                 parser.parseCommandLineArgs = ref .parseCommandLineArgsCallBack
                 parser.globalNS = compiler.globalNS
                 # @@ TODO: assert _globalNS is parser.nameSpaceStack[0]
+                parser.backEnd = compiler.backEnd
                 try
                     module = parser.parseFileNamed(filename)
                 catch SourceException
                     didError = true
                 success
-                    for r in parser.references, compiler.loadReference(r.fixLibExtension)
+                    for r in parser.references, compiler.loadReference(.compiler.backEnd.fixLibExtension(r), false)
                     # There could still be parse errors that were recorded, but not thrown.
                     # But that's okay because _errors.count is checked further below.
                     modules.add(module)

Source/HelpGenerator.cobra

@@ -469 +469 @@
         i = 0
         for prop in props
             if prop.canRead
-                name = Utils.cobraNameForSharpMemberName(prop.name)
+                name = Utils.cobraNameForNativeMemberName(prop.name)
                 try
                     value = prop.getValue(obj, nil)
                 catch exc as Exception

Source/Utils.cobra

@@ -33 +33 @@
                     success
                         value = _toTechString(value)
                     name = pi.name
-                    name = Utils.cobraNameForSharpMemberName(name)
+                    name = Utils.cobraNameForNativeMemberName(name)
                     print '    [name] = [value]'
             if obj inherits System.Collections.ICollection
                 i = 0
@@ -53 +53 @@
 
 extend String
 
+    # These should go in String Extensions
+    def beforeL(sep as String) as String
+        test
+            s = 'abc|de'
+            assert s.beforeL('|') == 'abc'
+            assert s.beforeL('=') == 'abc|de'
+            assert '|abcde'.beforeL('|') == ''
+            assert 'abcde|'.beforeL('|') == 'abcde'
+        body
+            idx = .indexOf(sep)
+            if idx < 0
+                return this
+            return this[0:idx]
+
+    def afterL(sep as String) as String
+        test
+            s = 'abc|de'
+            assert s.afterL('|') == 'de'
+            assert s.afterL('=') == ''
+            assert '|abcde'.afterL('|') == 'abcde'
+            assert 'abcde|'.afterL('|') == ''
+        body
+            idx = .indexOf(sep)
+            if idx < 0
+                return ''
+            return this[idx+sep.length:]
+                                
     ## Language specific
-
     def canBeUndottedMemberName as bool
         """
         Returns true if this string is the kind of name that can reference a box member without
@@ -172 +198 @@
                 return defaultValue
 
 
-        ## C#
+        ## BackEnd C#
         
-        def cobraNameForSharpMemberName(name as String) as String
+        def cobraNameForNativeMemberName(name as String) as String
             require
                 name.length
             ensure
@@ -197 +223 @@
                 ]
                 for case in cases
                     parts = case.split
-                    assert Utils.cobraNameForSharpMemberName(parts[0]) == parts[1]
+                    assert Utils.cobraNameForNativeMemberName(parts[0]) == parts[1]
             body
                 if name.length == 1
                     return name.toLower
@@ -321 +347 @@
             # return Assembly.loadWithPartialName(name)
             # with dynamic binding:
             assemblyType = Assembly to dynamic
-            return assemblyType.loadWithPartialName(name)
+            try 
+                ass = assemblyType.loadWithPartialName(name)
+            catch System.Reflection.TargetInvocationException # or any Exception 
+                ass = nil
+            return ass
 
 
 class ShouldNotCallException inherits Exception

Source/BackEndClr/ClrType.cobra

@@ +1 @@
+"""
+BackEnd Type wrappers for dotNet/CLR
+"""
+
+
 class ClrNativeType inherits NativeType
-
+    """
+    Acts as a holder for a Native Type, typically from scanning a DLL.
+    """
+        
     var _type as System.Type
     
     cue init(type as System.Type)
@@ -17 +25 @@
     def getHashCode as int is override
         return .clrType.getHashCode
 
-    get clrType as Type
+    get backEndType as Type # was clrType changed to backEndType
         return _type
-
+        
+    # Not part of NativeType - used by a cast to ClrNativeType then deref (:(
+    # should only be used/called from within ClrBackEnd code
+    get clrType as Type 
+        return _type
+        
     get name as String is override
         return _type.name
 
@@ -35 +48 @@
     def customAttributes as IList<of dynamic> is override
         return .clrType.getCustomAttributes(true) to IList<of dynamic>
 
+    get isSystemObjectClass as bool is override
+        return /#_type and #/ .fullName == 'System.Object'
+        
+    get isSystemTypeClass as bool is override
+        return /#_type and #/ .fullName == 'System.Type'
 
-class Class is partial
+class ClrTypeProxy inherits NativeTypeProxy
+    """
+    Acts as an ITypeProxy where the CLR type is known.
+    Typically used when scanning DLLs.
+    """
 
-    get isSystemObjectClass as bool is override
-        return _nativeType and _nativeType.fullName == 'System.Object'
+    shared
 
-    get isSystemTypeClass as bool is override
-        return _nativeType and _nativeType.fullName == 'System.Type'
+        var _cobraNameForSharpGenericNameCache = Dictionary<of String, String>()
+
+        def cobraNameForSharpBoxName(name as String) as String
+            """
+            Returns 'Foo' for 'Foo' and 'Foo<of,>' for 'Foo`2'
+            In other words, works for generic and non-generic classes, structs and interfaces.
+            Does *not* work for arrays, pointers, etc.
+            """
+            if '`' not in name
+                return name
+            if _cobraNameForSharpGenericNameCache.containsKey(name)
+                return _cobraNameForSharpGenericNameCache[name]
+            else
+                parts = name.split(c'`')
+                count = int.parse(parts[1])
+                cobraName = parts[0] + '<of'
+                for i in count-1, cobraName += ','
+                cobraName += '>'
+                _cobraNameForSharpGenericNameCache[name] = cobraName
+                return cobraName
+
+    var _clrType as Type
+
+    cue init(nativeType as NativeType)  # TODO: HACK
+        .init((nativeType to ClrNativeType).clrType)
+
+    cue init(clrType as Type)
+        base.init
+        _clrType = clrType
+
+    def addMinFields
+        base.addMinFields
+        .addField('clrType', _clrType)
+
+    get realType as IType is override
+        return _realTypeWithCache(_clrType)
+
+    def _realTypeWithCache(clrType as Type) as IType
+        t = (.compiler to Compiler).typeForClrType(clrType)
+        if t is nil
+            t = _realTypeWithoutCache(clrType, 0)
+            (.compiler to Compiler).addTypeForClrType(t to !, clrType)
+        return t to !
+    
+    def _realTypeWithoutCache(clrType as Type, 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.
+        clrPrimitiveToIType = .compiler.primitiveToITypeCache
+        if clrPrimitiveToIType is nil or clrPrimitiveToIType.count == 0
+            typeToIType = _makePrimitiveTypesDict
+            clrPrimitiveToIType = Dictionary<of dynamic, IType>()
+            for key in typeToIType.keys, clrPrimitiveToIType[key] = typeToIType[key]
+            (.compiler to Compiler).primitiveCache  = clrPrimitiveToIType to !
+        basicType as IType?
+        if clrPrimitiveToIType.tryGetValue(clrType, out basicType)
+            return basicType to !
+        
+        # handle wrapped types, like arrays and pointers, with recursive calls
+        if clrType.isArray
+            # assert clrType.name.endsWith(r'[]') # could be [,] so TODO: handle multidim arrays
+            return .typeProvider.arrayType(_realTypeWithCache(clrType.getElementType to !))
+        else if clrType.isNested and not clrType.isGenericParameter
+            declaringType = _realTypeWithCache(clrType.declaringType to !)
+            potential = declaringType.memberForName(clrType.name)
+            if potential is nil
+                # comes up on MS Windows .NET 2.0 for multiple types when using System.Windows.Forms
+                # error: Cannot locate nested CLR type "System.Windows.Forms.UnsafeNativeMethods+IOleControl" (simple name is "IOleControl").
+                if 'NativeMethods' in clrType.toString
+                    return _hack(clrType)
+                .throwError('Cannot locate nested CLR type "[clrType]" (simple name is "[clrType.name]").')
+            else if potential inherits IType
+                return potential
+            else
+                .throwError('Located CLR type spec "[clrType]" but got a [potential.englishName] instead of a type.')
+        else if clrType.isPointer
+            assert clrType.name.endsWith('*')
+            # TODO: handle pointer types
+            return _realTypeWithCache(clrType.getElementType to !)
+        else if clrType.isByRef
+            assert clrType.name.endsWith('&')
+            # TODO: handle ref types
+            return _realTypeWithCache(clrType.getElementType to !)
+
+        # generic parameters
+        if clrType.isGenericParameter
+            return GenericParam(ClrNativeType(clrType))
+
+        typeName = _computeTypeName(clrType)
+        missing = false
+        curNS = _computeNameSpace(clrType, level, out missing)
+        if missing
+            # since the CLR 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 CLR type "[clrType.fullName]" or its assembly "[clrType.assembly]". Please report to the Cobra discussion forums (http://cobra-language.com/).')
+
+            (.compiler to dynamic).clrReadAssembly(clrType.assembly)
+            return _realTypeWithoutCache(clrType, 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 clrType.isGenericType and not clrType.isGenericTypeDefinition
+                    # So we have something like ICollection<of KeyValuePair<of TKey,TValue>> which is all CLR 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.
+                    member = _typeForArgsOfGeneric(clrType, member)
+            return member
+        else
+            msg = 'Cannot locate CLR type "[clrType]".'
+            if clrType.namespace and clrType.namespace.startsWith('System.')
+                # TODO: On .NET 2.0 only \Tests\110-basics-two\550-collection-equality.cobra
+                # fails with: Cannot locate CLR type "System.Collections.KeyValuePairs[]".
+                # Figure out why.
+                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 _makePrimitiveTypesDict as IDictionary<of System.Type, IType>
+        clrPrimitiveToIType = Dictionary<of System.Type, IType>()
+    #def _makePrimitiveTypesDict as IDictionary<of dynamic, IType>
+    #   clrPrimitiveToIType = Dictionary<of dynamic, IType>()
+        for bt in .compiler.basicTypes
+            if bt.systemAliasProxy
+                key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType # TODO: hops cleanup no ClrNativeType
+                clrPrimitiveToIType[key] = bt
+        assert clrPrimitiveToIType.count == 0 or clrPrimitiveToIType.count > 9
+        return clrPrimitiveToIType
+
+    def _computeTypeName(clrType as Type) as String
+        typeName = clrType.name
+        if '`' in typeName
+            # generic like IComparable`1
+            assert r'[' not in typeName
+            typeName = .cobraNameForSharpBoxName(typeName)
+        else if typeName[typeName.length-1].isLetterOrDigit
+            pass
+        else
+            .throwError('Cannot locate CLR type "[clrType]".')
+        return typeName
+
+    def _computeNameSpace(clrType as Type, level as int, missing as out bool) as NameSpace
+        missing = false
+        if clrType.namespace is nil, return .compiler.globalNS
+        nameParts = clrType.namespace.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 CLR type "[clrType.fullName]", but it is a [possible.englishName].')
+                i += 1
+        return curNS    
+
+    def _typeForArgsOfGeneric(clrType as Type, member as IType) as IType
+        args = List<of IType>()
+        for genArg in clrType.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 _hack(clrType as Type) as IType
+        if clrType.isInterface
+            return ClrTypeProxy(sharp'typeof(System.ICloneable)').realType
+        else
+            return ClrTypeProxy(Object).realType
+
+            
+        
+
+            
+        

Source/BackEndClr/SharpGenerator.cobra

@@ -1499 +1499 @@
         sw.write(';\n')
 
 
+class BoxField is partial
+
+    get _sharpBackEndName as String
+        name = .name
+        if not name.startsWith('_')
+            name = name.capitalized
+        return name
+
 class BoxConst is partial
 
     def writeSharpDef(sw as CurlyWriter) is override
@@ -1507 +1515 @@
         .writeSharpIsNames(sw)
         sw.write('const ')
         sw.write(_type.sharpRef)
-        sw.write(' [_backEndName] = ')
+        sw.write(' [_sharpBackEndName] = ')
         _initExpr.writeSharpDef(sw)
         sw.write(';\n')
 
@@ -1516 +1524 @@
     is partial
 
     get sharpAssignmentNames as List<of String>
-        return [_backEndName]
+        return [_sharpBackEndName]
         # return List<of String>(_useBackEndNameStack)
 
     get sharpName as String is override
         if _ifInheritsStack.count
             if _type.isReference
-                return '(([_ifInheritsStack.peek.sharpRef])[_backEndName])'
+                return '(([_ifInheritsStack.peek.sharpRef])[_sharpBackEndName])'
             else
                 # 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 '[_sharpBackEndName].Value'  # Nullable<of T>.Value
         else
-            return _backEndName
+            backEndName = .name
+            if not backEndName.startsWith('_')
+                backEndName = backEndName.capitalized
+            return backEndName
+            #return _backEndName
         # return _useBackEndNameStack.peek to !
 
     def writeSharpDef(sw as CurlyWriter) is override
@@ -1535 +1547 @@
         .writeSharpAttribs(sw)
         .writeSharpIsNames(sw)
         sw.write(_type.sharpRef)
-        sw.write(' [_backEndName]')
+        sw.write(' [_sharpBackEndName]')
         if _initExpr
             sw.write(' = ')
             _initExpr.writeSharpDef(sw)
@@ -2417 +2429 @@
         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).isClrSystemExceptionClass
             wrongExceptionVarName = '_lh_expect_[_varNumber]'
             assert gotRightExceptionVarName <> wrongExceptionVarName
             sw.writeAndIndent('catch (System.Exception [wrongExceptionVarName]) {\n')
@@ -4368 +4380 @@
 class CompareExpr
     is partial
 
+    var _cobraToSharp = {
+        'EQ': '==',
+        'NE': '!=',
+        'GT': '>',
+        'LT': '<',
+        'GE': '>=',
+        'LE': '<=',
+        'IS': '==',
+        'ISNOT': '!=',
+    }
+    
     def _writeSharpDef(sw as CurlyWriter) is override
         left = _left
         right = _right

Source/BackEndClr/ScanClrType.cobra

@@ -1 +1 @@
 class Compiler is partial
 
+    var _didLoadAssemblies = Set<of String>()
+
     var _didReadAssemblies = Set<of String>()
     
-    def readAssembly(ass as Assembly)
-        .readAssembly(ass, false)
+    var _clrTypeToType = Dictionary<of System.Type, IType>()
+    
+    var _clrTypeCache = Dictionary<of String, System.Type>()
+    
+    
+    # .Net specific Reference loading
+    def dotNetLoadReference(reference as String) as bool
+        try 
+            return  __dotNetLoadReference(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)
 
-    def readAssembly(ass as Assembly, skipCobra as bool)
+    def __dotNetLoadReference(reference as String) as bool
+        # uses reference parameter
+        # compiler .referenceVerbosity, _willReadDependencies
+        # fills .loadedReferences
+        
+        require
+            reference.endsWith('.dll') or reference.endsWith('.exe')
+            reference not in ['.dll', '.exe']
+        ensure
+            result implies .loadedReferences[.loadedReferences.count-1] == reference
+            not result implies .loadedReferences.count == old .loadedReferences.count
+        body
+            rv = .referenceVerbosity
+            assert not (reference.startsWith('-r') and '-r' in reference[2:])
+            if false
+                # Does not work on Novell Mono. See notes above.
+                referredAss = Assembly.reflectionOnlyLoadFrom(reference)
+                # TODO: handle all the exceptions from Assembly.loadFrom
+            else
+                if File.exists(reference)
+                    # try current directory
+                    if rv, print '"[reference]" found as file. Will Assembly.loadFrom().'
+                    referredAss = Assembly.loadFrom(reference)
+                    if rv, print 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
+                else
+                    # TODO: the problem with -lib: in both Cobra and C# is that it has no effect on runtime,
+                    # you must still register the DLLs in the GAC or copy them into the same dir as the .exe
+                    # because the -lib: paths are not passed into executable.
+                    # So should Cobra copy the .dll's into the target directory (if their paths are not in MONO_PATH)?
+                    if rv, print 'File does not exist.'
+                    searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
+                    # TODO: ?: searchPaths.add(Path.getDirectoryName(Assembly.getExecutingAssembly.location))  # try Cobra's directory - also should be added to .options.'library-directory' not to a local var
+                    found = false
+                    for searchPath in searchPaths
+                        if rv, print 'Checking lib path: "[searchPath]"'
+                        combinedPath = Path.combine(searchPath, reference)
+                        if File.exists(combinedPath)
+                            if rv, print '"[reference]" found as file. Will Assembly.loadFrom().'
+                            referredAss = Assembly.loadFrom(combinedPath)
+                            if rv, print 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
+                            found = true
+                            break
+                    if rv
+                        if searchPaths.count
+                            if not found, print 'Did not find "[reference]" in lib paths'
+                        else
+                            print 'No lib paths to search.'
+                    if not found
+                        # try system wide (GAC)
+                        if reference.endsWith('.dll'), reference = reference[:-4]
+                        if rv, print 'Will load with partial name "[reference]"'
+                        referredAss = Utils.loadWithPartialName(reference)
+                        if rv, print 'Load with partial name returned: [CobraCore.toTechString(referredAss)]'
+                        if referredAss is nil, return false
+                        # 2009-08-03 CE: Removed this code:
+                        # reference = referredAss.location
+                        # To address this:
+                        # http://cobra-language.com/forums/viewtopic.php?f=4&t=501
+                        # See also: ../Tests/720-libraries/100-microsoft/110-winforms-native-compiler.cobra
+                        #           Note the -native-compiler option in that test which triggers this.
+                        # Also, it doesn't see right to have to use the full path of a GAC-based assembly anyway.
+                        # But still have to end in .dll or .exe:
+                        reference += if(referredAss.location.endsWith('.exe'), '.exe', '.dll')
+                # TODO: handle all the exceptions from Assembly.loadFrom
+            if referredAss
+                if _willReadDependencies # wired false in Compiler.cobra
+                    for dependency in referredAss.getReferencedAssemblies
+                        if rv
+                            print '>> Loading dependency: [dependency]'
+                            .indentPrint
+                            try
+                                _dotNetLoadAssembly(dependency)
+                            finally
+                                .outdentPrint
+                                print '<< Loading dependency: [dependency]'
+                        else
+                            _dotNetLoadAssembly(dependency)
+                if rv, print 'Will read assembly: [referredAss]'
+                try
+                    __dotNetReadAssembly(referredAss, reference <> 'Cobra.Lang.dll')
+                catch readExc as Exception
+                    if rv, print 'Caught exception during read assembly: [readExc]'
+                    throw
+                if rv, print 'Did read assembly: [referredAss]'
+                # reassert the preconditions. there have been bugs in the past
+                assert reference.endsWith('.dll') or reference.endsWith('.exe')
+                assert reference not in ['.dll', '.exe']
+                .loadedReferences.add(reference)
+                if rv, print 'Returning true for __loadReference("[reference]").'
+                return true
+            else
+                if rv, print 'Returning false for __loadReference("[reference]").'
+                return false
+
+    def _dotNetLoadAssembly(assName as AssemblyName)
+        if .referenceVerbosity
+            print '>> loadAssembly [assName]'
+            .indentPrint
+            try
+                _loadAssembly(assName)
+            finally
+                .outdentPrint
+                print '<< loadAssembly [assName]'
+        else
+            _loadAssembly(assName)
+
+    def _loadAssembly(assName as AssemblyName)
+        rv = .referenceVerbosity - 1
+        if rv < 0, rv = 0
+        if assName.toString in _didLoadAssemblies
+            if rv, print 'Already loaded.'
+            return
+        _didLoadAssemblies.add(assName.toString)
+        try
+            if rv, print 'Will Assembly.load([assName])'
+            ass = Assembly.load(assName)     # Will not pick up the assembly from the same directory.
+            if rv, print 'Did Assembly.load with result: [ass]'
+        catch fnfe as FileNotFoundException  # In fact, will get a FileNotFoundException!
+            if rv, print 'Did Assembly.load with exception: [fnfe]. Will try .loadReference'
+            .loadReference(assName.name to !, true) # .compiler.loadReference(assName.name to !, true)
+            # TODO: compare the the name loaded to the name given with AssemblyName.referenceMatchesDefinition
+            return
+        catch exc as Exception
+            msg = 'Could not open assembly "[assName]" due to: [exc.getType.name]: [exc.message]'
+            if rv, print msg
+            throw SourceException(msg)
+        if _willReadDependencies # wired false in Compiler.cobra
+            for dependency in ass.getReferencedAssemblies
+                if rv
+                    print '>> Loading dependency: [dependency]'
+                    .indentPrint
+                    try
+                        _dotNetLoadAssembly(dependency)
+                    finally
+                        .outdentPrint
+                        print '<< Loading dependency: [dependency]'
+        try
+            .clrReadAssembly(ass to !) # compiler.readAssembly(ass)
+        catch readExc as Exception
+            if rv, print 'Caught exception during read assembly: [readExc]'
+            throw
+
+    # Called by ClrTypeProxy 
+    # dotNet specific  - readLibrary
+    def clrReadAssembly(ass as Assembly)
+        """ Reads the contents of an dotNet assembly (.DLL) so that they are accessible to the program."""
+        assert _backEnd.typeOf == ClrBackEnd # tmp guard
+        __dotNetReadAssembly(ass, false) # ScanClrType
+            
+            
+    #def dotNetReadAssembly(ass as Assembly)
+    #   """ Reads the contents of an dotNet assembly (.DLL). EntryPoint"""
+    #   __dotNetReadAssembly(ass, false)
+
+    def __dotNetReadAssembly(ass as Assembly, skipCobra as bool)
         """
         Reads the contents of an assembly (.DLL) so that they are accessible to the program.
         In other words, this method reads libraries.
@@ -17 +184 @@
             print 'Reading assembly:  [ass]'  # extra space lines up with 'Loading reference:'
             print '              at:  [ass.location]'
         namespaceQualNameToNameSpaceObject = Dictionary<of String, NameSpace>()
-        module = AssemblyModule(ass, .globalNS)
+        module = AssemblyModule(ass.location, .globalNS)
+        #module = AssemblyModule(ass, .globalNS)
         saveModule, _curModule = _curModule, module
         try
             _modules.add(module)
@@ -54 +222 @@
                 else
                     if type.isClass
                         if type.name.startsWith('Extend_') and type.name.count(c'_') >= 2
-                            curNameSpace.addDecl(Extension(clrType))
+                            curNameSpace.addDecl(Extension(clrType, .backEnd))
                         else
-                            curNameSpace.addDecl(Class(clrType))
+                            curNameSpace.addDecl(Class(clrType, .backEnd))
                     else if type.isInterface
-                        curNameSpace.addDecl(Interface(clrType))
+                        curNameSpace.addDecl(Interface(clrType, .backEnd))
                     else if type.isEnum
                         curNameSpace.addDecl(EnumDecl(curNameSpace, clrType, List<of String>(), ''))  # TODO: isNames; docString?
                     else if type.isValueType
-                        curNameSpace.addDecl(Struct(clrType))
+                        curNameSpace.addDecl(Struct(clrType, .backEnd))
                     else if type.isAnsiClass
                         # The Enum class is an example that returns false for .isClass but true for .isAnsiClass
-                        curNameSpace.addDecl(Class(clrType))
+                        curNameSpace.addDecl(Class(clrType, .backEnd))
                     else
                         throw FallThroughException(type)
         finally
             _curModule = saveModule
 
-    def fixNilableMemberSigs
+    def dotNetfixNilableMemberSigs
         # TODO: this really needs to go in a separate file that the compiler reads each time
 
         # TODO: look to see if what the Spec# team put together can be leveraged instead of recreating all this work!
@@ -124 +292 @@
             print 'WARNING: Cannot fix [className] which is not a class/struct/interface. (type=[type])'  # TODO: make a real warning
 
 
-    var _clrTypeToType = Dictionary<of System.Type, IType>()
     
     def typeForClrType(clrType as System.Type) as IType?
         """
         Returns the Cobra type for a CLR type if the CLR type was previously scanned.
-        In other words, this is access to the cache.
+        In other words, this is access to the clr Type cache.
         This not only eliminates unwanted duplication, but it is essential to the compiler when it
         checks for certain things like "does this type implement IDictionary<of TKey, TValue>?"
         """
@@ -138 +305 @@
     def addTypeForClrType(type as IType, clrType as System.Type)
         require .typeForClrType(clrType) in [nil, type]
         _clrTypeToType[clrType] = type
+        
+    def clrTypeByName(qualifiedName as String) as System.Type
+        """
+        Obtain the Clr type given by the fully qualified name.
+        """
+        # eventually this method will be key in targeting different versions of the CLR
+        # suppose you are on .NET 3.0 and want to target .NET 2.0
+        t as System.Type?
+        _clrTypeCache.tryGetValue(qualifiedName, out t)
+        if t is nil
+            t = sharp'System.Type.GetType(qualifiedName)' # to System.Type
+            _clrTypeCache[qualifiedName] = t to passthrough  # "to passthrough" instead of "to !" to avoid non-nil check
+        return t to passthrough
+    
 
+        
+    def installClrNativeMethods(box as Box, nativeType as NativeType) 
+        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]'
+                
+    def _installClrNativeMethodsFrom(namespaceName as String, nativeType as NativeType, 
+                    thisNativeType as NativeType, box as Box, meths as List<of Method>)
+        argClrType = (nativeType to ClrNativeType).backEndType
+        thisClrType = (thisNativeType to ClrNativeType).backEndType
+        # print
+        # print '** [.name], clrType'
+        isSameNativeType = argClrType == thisClrType
+        for methInfo in argClrType.getMethods(BindingFlags(DeclaredOnly, Static, Instance, Public))
+            if methInfo.isSpecialName, continue
+            # print
+            # print '--', methInfo, methInfo.isStatic
+            name = Utils.cobraNameForNativeMemberName(methInfo.name)
+            modifiers = List<of String>()
+            if methInfo.isStatic, modifiers.add('shared')
+            newParams = List<of Param>()
+            first = true
+            cancel = false
+            for nativeParam in methInfo.getParameters
+                if first
+                    first = false
+                    if methInfo.isStatic
+                        if methInfo.getParameters[0].parameterType == thisClrType
+                            # When the first arg of the shared method is the same type,
+                            # then make an instance method that can be used directly on values of the type.
+                            # print methInfo.getParameters
+                            # print methInfo.getParameters[0].parameterType
+                            modifiers.remove('shared')
+                            continue
+                        else if not isSameNativeType
+                            # don't want, for example, Math.sign showing up in types char, bool, etc. as a shared method
+                            cancel = true
+                            continue
+                param = Param(Token.empty.copy('ID', nativeParam.name), ClrTypeProxy(nativeParam.parameterType))
+                if nativeParam.parameterType.isByRef and not nativeParam.isOut
+                    param.direction = Direction.InOut
+                else if nativeParam.isOut
+                    param.direction = Direction.Out
+                newParams.add(param)
+            if cancel, continue
+            meth = Method(Token.empty, Token.empty, box, name, newParams, ClrTypeProxy(methInfo.returnType), nil, modifiers, AttributeList(), '')
+            if methInfo.isStatic
+                meth.sharedMethodBacking = '[namespaceName].[argClrType.name].[methInfo.name]'
+                if 'shared' in modifiers, meth.sharedMethodBackingIsAlias = true
+
+            overload = nil to MemberOverload?
+            other = box.declForName(name)
+            if other
+                if other inherits MemberOverload
+                    overload = other
+                else if other inherits AbstractMethod or other inherits ProperDexer
+                    overload = MemberOverload(other to BoxMember)
+                    box.registerOverload(overload to !)
+                else
+                    throw FallThroughException([box, meth, other])
+            else
+                assert box.declForName(name) is nil
+            if overload
+                overload.addMember(meth)
+            else
+                box.addDecl(meth)
+                
+            meths.add(meth)
+        
+        
+
 class Box is partial
 
-    get clrType as Type
+    get _clrType as Type
         """
         Returns the CLR System.Type boxed by the .nativeType.
         Throws exception rather than return nil.
         """
         return (.nativeType to ClrNativeType).clrType
 
-    def _scanNativeType
+    var _defaultMemberName as String?
         """
+        An Indexer in CLR is known by being a property with arguments whose name matches the .memberName of a box-level DefaultMemberAttribute.
+        """
+        
+    def isClrSystemExceptionClass as bool
+        return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'System'
+                
+    def _prepSystemObjectClassClr
+        # Pretend .NET is a bit more OO, consistent and elegant.
+        # C#'s typeof(X) is X.getType in Cobra.
+        existing = .declForName('getType') 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 = 'typeof'
+        overload.addMember(meth)
+        
+    def _scanNativeTypeClr
+        """
         Subclasses should invoke base and then invoke the various _scanFoo methods that are appropriate for them.
         """
         ensure not .needScanNativeType
         _needScanNativeType = false
         # print '<> _scanNativeType for [.name] in [_parentNameSpace.fullName], class is [.getType.name]'
 
-    def _scanIsNames
+
+    def _scanGenericArgsClr
+        if _clrType.isGenericType
+            for genArg in _clrType.getGenericArguments
+                t = (.compiler to Compiler).typeForClrType(genArg)
+                if t is nil
+                    t = GenericParam(ClrNativeType(genArg), parentDefinition=this)
+                    (.compiler to Compiler).addTypeForClrType(t to !, genArg)
+                _genericParams.add(t)
+
+    def _scanClrIsNames
         # TODO
         _isNames.add('extern')  # to make the box like the ones that were in SystemInterfaces.cobra
 
         # scan DefaultMemberAttribute for later use
-        for attr in .clrType.getCustomAttributes(true)
+        for attr in _clrType.getCustomAttributes(true)
             if attr inherits DefaultMemberAttribute
                 _defaultMemberName = attr.memberName  # this attribute names the indexer for the class
                 break
 
-    def _scanGenericArgs
-        if .clrType.isGenericType
-            for genArg in .clrType.getGenericArguments
-                t = (.compiler to Compiler).typeForClrType(genArg)
-                if t is nil
-                    t = GenericParam(ClrNativeType(genArg), parentDefinition=this)
-                    (.compiler to Compiler).addTypeForClrType(t to !, genArg)
-                _genericParams.add(t)
-
-    def _scanImplements
-        for interf in .clrType.getInterfaces
-            if not _badRelatedType(interf)
+    def _scanClrImplements
+        for interf in _clrType.getInterfaces
+            if not _badClrRelatedType(interf)
                 _baseInterfaceProxies.add(ClrTypeProxy(interf))
 
-    def _scanNestedTypes
+    def _scanClrNestedTypes
         # TODO: enable and fix resulting bugs
         # for type in .clrType.getNestedTypes(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
-        for type in .clrType.getNestedTypes
-            _scanNestedType(type)
-        for type in .clrType.getNestedTypes(BindingFlags(Static, DeclaredOnly, NonPublic))
+        for type in _clrType.getNestedTypes
+            _scanClrNestedType(type)
+        for type in _clrType.getNestedTypes(BindingFlags(Static, DeclaredOnly, NonPublic))
             if type.isEnum and not type.isPublic and not type.isNestedAssembly
                 # "not type.isNestedAssembly" guards against a strange WPF enum on Windows called
                 # Control+ControlBoolFlags whose Enum.getValues() returns enums instead of ints
-                _scanNestedType(type)
+                _scanClrNestedType(type)
 
-    def _scanNestedType(type as System.Type)
+    def _scanClrNestedType(type as System.Type)
         clrType = ClrNativeType(type)
         if type.isClass
-            .addDecl(Class(clrType))
+            .addDecl(Class(clrType, .compiler.backEnd))
         else if type.isInterface
-            .addDecl(Interface(clrType))
+            .addDecl(Interface(clrType, .compiler.backEnd))
         else if type.isEnum
             .addDecl(EnumDecl(this, clrType, List<of String>(), ''))  # TODO: isNames; docString?
         else if type.isValueType
-            .addDecl(Struct(clrType))
+            .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))
+            .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 _scanFields
-        for fieldInfo in .clrType.getFields(BindingFlags(Instance, Static, DeclaredOnly, Public))
-            if fieldInfo.declaringType is not .clrType, continue
+    def _scanClrFields
+        for fieldInfo in _clrType.getFields(BindingFlags(Instance, Static, DeclaredOnly, Public))
+            if fieldInfo.declaringType is not _clrType, continue
             if fieldInfo.isAssembly, continue
             if fieldInfo.isPrivate, continue
-            name = Utils.cobraNameForSharpMemberName(fieldInfo.name)
-            type = _memberTypeResultProxy(fieldInfo, fieldInfo.fieldType)
+            name = Utils.cobraNameForNativeMemberName(fieldInfo.name)
+            type = _clrMemberTypeResultProxy(fieldInfo, fieldInfo.fieldType)
             attrs = AttributeList()
             isNames = [if(fieldInfo.isPublic, 'public', 'protected')]  # private was guarded against above
             if fieldInfo.isStatic, isNames.add('shared')
@@ -234 +529 @@
                 varr.binaryName = fieldInfo.name
                 .addDecl(varr)
 
-    def _scanInitializers
-        for conInfo in .clrType.getConstructors(BindingFlags(Instance, DeclaredOnly, Public, NonPublic))
+    def _scanClrInitializers
+        for conInfo in _clrType.getConstructors(BindingFlags(Instance, DeclaredOnly, Public, NonPublic))
             if conInfo.isPrivate, continue
-            if conInfo.declaringType is not .clrType, continue
+            if conInfo.declaringType is not _clrType, continue
             skip = false
             for paramInfo in conInfo.getParameters
-                if _badRelatedType(paramInfo.parameterType)
+                if _badClrRelatedType(paramInfo.parameterType)
                     skip = true
                     break
             if skip, continue
-            params = _scanParams(conInfo.getParameters)
+            params = _scanClrParams(conInfo.getParameters)
             isNames = _isNamesForMethodInfo(conInfo)
             attribs = _attribsForMethodInfo(conInfo)
             docString = ''  # TODO: get doc string for class?
@@ -264 +559 @@
             else
                 .addDecl(initer)
 
-    def _scanProperties
-        for propInfo in .clrType.getProperties(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
+    def _scanClrProperties
+        for propInfo in _clrType.getProperties(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
             getMethod = propInfo.getGetMethod(true) # true means include nonpublic
             setMethod = propInfo.getSetMethod(true)
             visible = false
@@ -278 +573 @@
                     theMethod = setMethod to !
                     visible = true
             if not visible, continue
-            if theMethod.declaringType is not .clrType, continue
+            if theMethod.declaringType is not _clrType, continue
             if propInfo.name == _defaultMemberName and propInfo.getIndexParameters and propInfo.getIndexParameters.length
-                _scanIndexer(propInfo)
+                _scanClrIndexer(propInfo)
                 continue
-            if _badRelatedType(propInfo.propertyType)
+            if _badClrRelatedType(propInfo.propertyType)
                 continue
             attribs = AttributeList()  # TODO:
             docString = ''  # TODO: get doc string
             # TODO: eventually the isNames need to be an the property part level (get or set) rather than the property level, like in C# and the CLR runtime
             isNames = _isNamesForMethodInfo(theMethod)
-            prop = Property(TokenFix.empty, TokenFix.empty, this, Utils.cobraNameForSharpMemberName(propInfo.name), _memberTypeResultProxy(propInfo, propInfo.propertyType), isNames, attribs, docString)
+            prop = Property(TokenFix.empty, TokenFix.empty, this, Utils.cobraNameForNativeMemberName(propInfo.name), _clrMemberTypeResultProxy(propInfo, propInfo.propertyType), isNames, attribs, docString)
             prop.binaryName = propInfo.name
             if propInfo.canRead
                 prop.makeGetPart(TokenFix.empty)
@@ -296 +591 @@
                 prop.makeSetPart(TokenFix.empty)
             .addDecl(prop)
 
-    def _scanIndexer(propInfo as PropertyInfo)
+    def _scanClrIndexer(propInfo as PropertyInfo)
         for paramInfo in propInfo.getIndexParameters
-            if _badRelatedType(paramInfo.parameterType)
+            if _badClrRelatedType(paramInfo.parameterType)
                 return
-        params = _scanParams(propInfo.getIndexParameters)
+        params = _scanClrParams(propInfo.getIndexParameters)
         attribs = AttributeList()  # TODO:
         docString = ''  # TODO: get doc string for class?
         if propInfo.canRead
@@ -309 +604 @@
             isNames = _isNamesForMethodInfo(propInfo.getSetMethod(true) to !)
         else
             throw FallThroughException(propInfo)
-        indexer = Indexer(TokenFix.empty, TokenFix.empty, this, r'[]', params, _memberTypeResultProxy(propInfo, propInfo.propertyType), isNames, attribs, docString)
+        indexer = Indexer(TokenFix.empty, TokenFix.empty, this, r'[]', params, _clrMemberTypeResultProxy(propInfo, propInfo.propertyType), isNames, attribs, docString)
         overload as MemberOverload? = nil
         other = .declForName(r'[]')
         if other
@@ -325 +620 @@
         else
             .addDecl(indexer)
 
-    def _scanMethods
-        for methInfo in .clrType.getMethods(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
+    def _scanClrMethods
+        for methInfo in _clrType.getMethods(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
             if methInfo.isSpecialName, continue
             if methInfo.isAssembly, continue
             if methInfo.isPrivate, continue
-            if methInfo.declaringType is not .clrType, continue
+            if methInfo.declaringType is not _clrType, continue
             skip = false
-            if _badRelatedType(methInfo.returnType)
+            if _badClrRelatedType(methInfo.returnType)
                 skip = true
             else
                 for paramInfo in methInfo.getParameters
-                    if _badRelatedType(paramInfo.parameterType)
+                    if _badClrRelatedType(paramInfo.parameterType)
                         skip = true
                         break
             if skip, continue
@@ -348 +643 @@
                 # TODO: these are mostly (maybe all) explicit implementations of interfaces
                 # print 'xxx dotted name: [methInfo]'
                 continue
-            name = Utils.cobraNameForSharpMemberName(methInfo.name)
+            name = Utils.cobraNameForNativeMemberName(methInfo.name)
             genericParams = List<of IType>()
             for genArg in methInfo.getGenericArguments
                 genericParams.add(GenericParam(ClrNativeType(genArg)))
-            params = _scanParams(methInfo.getParameters)
+            params = _scanClrParams(methInfo.getParameters)
             isNames = _isNamesForMethodInfo(methInfo)
             attribs = _attribsForMethodInfo(methInfo)
             docString = ''  # TODO: get doc string for class?
             implementsTypeNode as ITypeProxy?  # TODO: explicit interface implementation?
-            method = Method(TokenFix.empty, TokenFix.empty, this, name, genericParams, params, _memberTypeResultProxy(methInfo, methInfo.returnType), implementsTypeNode, isNames, attribs, docString)
+            method = Method(TokenFix.empty, TokenFix.empty, this, name, genericParams, params, _clrMemberTypeResultProxy(methInfo, methInfo.returnType), implementsTypeNode, isNames, attribs, docString)
             method.binaryName = methInfo.name
             overload as MemberOverload? = nil
             other = .declForName(name)
@@ -374 +669 @@
             else
                 .addDecl(method)
 
-    def _scanParams(paramInfos as ParameterInfo[]?) as List<of Param>
+    def _scanClrParams(paramInfos as ParameterInfo[]?) as List<of Param>
         """
         Returns a list of Cobra parameters given a list of CLR Reflection ParameterInfos.
         """
@@ -394 +689 @@
                 isRef = paramInfo.parameterType.isByRef and not paramInfo.isOut
                 # Unpack "ByRef" types. Comes up with WinForm's .processCmdKey which has a ByRef struct argument (Message&)
                 parameterType = if(isRef, paramInfo.parameterType.getElementType, paramInfo.parameterType)
-                type = _memberTypeProxy(parameterType, isNotNull)
+                type = _clrMemberTypeProxy(parameterType, isNotNull)
                 if isVari, type = VariTypeProxy(type)
                 # In XNA 3.1 some types such as GraphicsDevice and Texture have a Dispose method
                 # with one argument with an empty name (''). Cobra doesn't dig that.
@@ -413 +708 @@
                 params.add(param)
         return params
 
-    def _scanEvents
-        for eventInfo in .clrType.getEvents(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
+    def _scanClrEvents
+        for eventInfo in _clrType.getEvents(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
             if eventInfo.getAddMethod is nil, continue
             if eventInfo.getAddMethod.isAssembly, continue
             if eventInfo.getAddMethod.isPrivate, continue
             if eventInfo.isSpecialName, continue
-            if eventInfo.declaringType is not .clrType, continue
+            if eventInfo.declaringType is not _clrType, continue
             if '.' in eventInfo.name
                 # TODO: these are mostly (maybe all) explicit implementations of interfaces
                 # print 'xxx dotted name: [methInfo]'
                 continue
-            name = Utils.cobraNameForSharpMemberName(eventInfo.name)
+            name = Utils.cobraNameForNativeMemberName(eventInfo.name)
             if eventInfo.getAddMethod  # Gtk.Object has such a beast (InternalDestroyed)
                 isNames = _isNamesForMethodInfo(eventInfo.getAddMethod to !)
             else
@@ -454 +749 @@
     def _attribsForMethodInfo(mi as MethodBase) as AttributeList
         return AttributeList()  # TODO:
 
-    def _badRelatedType(t as Type?) as bool
+    def _badClrRelatedType(t as Type?) 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.
@@ -468 +763 @@
 
         # 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 _badRelatedType(t.getElementType)
+            return _badClrRelatedType(t.getElementType)
         if t.isNotPublic or t.isNestedAssembly  # .isNestedAssembly should imply .isNotPublic but at least in System.Windows.Forms, on Novell Mono 1.2.6, Control+LayoutType reports .isNestedAssembly but not .isNotPublic
             return true
 
         return false
 
-    def _memberTypeProxy(clrType as Type?) as ITypeProxy
-        return _memberTypeProxy(clrType, false)
+    def _clrMemberTypeProxy(clrType as Type?) as ITypeProxy
+        return _clrMemberTypeProxy(clrType, false)
 
-    def _memberTypeProxy(clrType as Type?, notNullAttr as bool) as ITypeProxy
+    def _clrMemberTypeProxy(clrType as Type?, notNullAttr as bool) as ITypeProxy
         """
-        Returns a type proxy for a member type such as a parameter type or method return type.
+        Returns a type proxy for a member type such as a parameter type
         In CLR, reference types are nilable by default, but you can pass `true` for `notNullAttr` to indicate there was a NotNullAttribute in the DLL.
         """
         if clrType is nil
@@ -493 +788 @@
                 tp = NilableTypeProxy(tp)
             return tp
 
-    def _memberTypeResultProxy(member as MemberInfo, clrType as Type?) as ITypeProxy
+    def _clrMemberTypeResultProxy(member as MemberInfo, clrType as Type?) as ITypeProxy
         """
-        Returns a type proxy for a member type such as a parameter type or method return type.
+        Returns a type proxy for a member result type such as a method return type, property or field.
         In CLR, reference types are nilable by default.
         """
         if clrType is nil
@@ -523 +818 @@
 class Class
     is partial
 
-    def _scanNativeType
-        base._scanNativeType
-        _scanIsNames
-        _scanImplements
-        _scanNestedTypes
-        _scanFields
-        _scanInitializers
-        _scanProperties
-        _scanMethods
-        _scanEvents
-        # TODO: _scanEnums
+    def _scanNativeTypeClr
+        base._scanNativeTypeClr
+        _scanClrIsNames
+        _scanClrImplements
+        _scanClrNestedTypes
+        _scanClrFields
+        _scanClrInitializers
+        _scanClrProperties
+        _scanClrMethods
+        _scanClrEvents
+        # TODO: _scanClrEnums
         # TODO: scan all other nested types
 
 
 class Interface
     is partial
 
-    def _scanNativeType
-        base._scanNativeType
-        _scanIsNames
-        _scanImplements
-        _scanNestedTypes
-        _scanFields
-        _scanProperties
-        _scanMethods
-        _scanEvents
+    def _scanNativeTypeClr
+        base._scanNativeTypeClr
+        _scanClrIsNames
+        _scanClrImplements
+        _scanClrNestedTypes
+        _scanClrFields
+        _scanClrProperties
+        _scanClrMethods
+        _scanClrEvents
 
 
 class Struct
     is partial
 
-    def _scanNativeType
-        base._scanNativeType
-        _scanIsNames
-        _scanImplements
-        _scanNestedTypes
-        _scanFields
-        _scanInitializers
-        _scanProperties
-        _scanMethods
-        _scanEvents
+    def _scanNativeTypeClr
+        base._scanNativeTypeClr
+        _scanClrIsNames
+        _scanClrImplements
+        _scanClrNestedTypes
+        _scanClrFields
+        _scanClrInitializers
+        _scanClrProperties
+        _scanClrMethods
+        _scanClrEvents
 
 
 class Extension
     is partial
 
-    def _scanNativeType
+    def _scanNativeTypeClr
         # this only for Cobra specific extensions. Example: class Extend_String_1939
-        base._scanNativeType
-        _scanIsNames
-        #_scanImplements
-        #_scanNestedTypes
-        #_scanFields
-        #_scanInitializers
-        #_scanProperties
-        _scanMethods
+        base._scanNativeTypeClr
+        _scanClrIsNames
+        #_scanClrImplements
+        #_scanClrNestedTypes
+        #_scanClrFields
+        #_scanClrInitializers
+        #_scanClrProperties
+        _scanClrMethods
         #_scanEvents
 
-    def _scanParams(paramInfos as ParameterInfo[]?) as List<of Param>
+    def _scanClrParams(paramInfos as ParameterInfo[]?) as List<of Param> is override
         # the first argument is implicit in an Extension
-        results = base._scanParams(paramInfos)
+        results = base._scanClrParams(paramInfos)
         return results[1:]
+        
+    def clrExtnNativeType(nativeType as NativeType) as NativeType
+        # the real extended type is the type of the first argument of any method
+        for methInfo in _clrType.getMethods 
+            nativeType = ClrNativeType(methInfo.getParameters[0].parameterType)
+            break
+        return nativeType
+
+        
+
+class EnumDecl
+    is partial
+
+    def _setUnderlyingTypeClr
+        _storageTypeNode =  ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).backEndType))
+    
+    def _scanNativeTypeClr
+        # TODO: read attribs
+        _needScanNativeType = false
+        clrType = (_nativeType to ClrNativeType).clrType 
+        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
+        #print clrType
+        for name in Enum.getNames(clrType)
+            #print name
+            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/BackEndClr/ClrBackEnd.cobra

@@ +1 @@
+use System.Diagnostics
 use System.Reflection
 
 
@@ -3 +4 @@
 class ClrBackEnd inherits BackEnd
 
+    var _objectTypeProxy as AbstractTypeProxy =  ClrTypeProxy(Object)
+    var _typeTypeProxy   as AbstractTypeProxy =  ClrTypeProxy(Type)
+
     cue init(compiler as Compiler)
         base.init(compiler)
+        _name = 'c#-clr'
+        _rtlName = 'Cobra.Lang.dll'
+    
+        _tagToTypeName = { 
+            'Object'    :       'System.Object',
+            'Type'      :       'System.Type',
+            'String'    :       'System.String',
+            'Exception' :       'System.Exception',
+            'Delegate'  :       'System.Delegate',
+            'Attribute' :       'System.Attribute',
+            'ICloneable':       'System.ICloneable',
+            'IEnumerable':      'System.Collections.IEnumerable',
+            'IEnumerator':      'System.Collections.IEnumerator',
+            'IEnumerable<of>' : 'System.Collections.Generic.IEnumerable<of>',
+            'IEnumerator<of>' : 'System.Collections.Generic.IEnumerator<of>',
+            'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator',
+            'ICollection':      'System.Collections.ICollection',
+            'ICollection<of>':  'System.Collections.Generic.ICollection<of>',
+            'IList' :           'System.Collections.IList',
+            'IList<of>' :       'System.Collections.Generic.IList<of>',
+            'List<of>':         'System.Collections.Generic.List<of>',
+            'IDictionary':      'System.Collections.IDictionary',
+            'IDictionary<of,>': 'System.Collections.Generic.IDictionary<of,>',
+            'Dictionary<of,>' : 'System.Collections.Generic.Dictionary<of,>',
+            'Set<of>':          'Cobra.Lang.Set<of>',
 
+            'bool'  :  'System.Boolean',
+            'char'  :  'System.Char',
+            'decimal': 'System.Decimal',
+            'single': 'System.Single',      
+            'double': 'System.Double',      
+            'sbyte' : 'System.SByte',       
+            'int16' : 'System.Int16',       
+            'int32' : 'System.Int32',       
+            'int64' : 'System.Int64',       
+            'byte'  : 'System.Byte',        
+            'uint16': 'System.UInt16',      
+            'uint32': 'System.UInt32',      
+            'uint64': 'System.UInt64',      
+            }
+        
     def makePhases(phases as IList<of Phase>) is override
         phases.add(GenerateSharpCodePhase(.compiler))
@@ -13 +57 @@
     def computeOutName as String is override
         return .compiler.computeOutNameSharp
         
+    def genNativeModule(filename as String, verbosity as int) as Module? is override
+        m as Module? = nil
+        if filename.endsWith('.cs')
+            if verbosity, print 'Noting  [filename] as SharpModule'  # extra space to line up with 'Parsing [filename]'
+            m = SharpModule(filename, verbosity)
+        return m
+    
+    def setupRunProcess(baseExe as String, fullExe as String) as Process is override
+        p = Process()
+        branch .compiler.platform
+            on PlatformEnum.Microsoft
+                p.startInfo.fileName = baseExe
+            on PlatformEnum.Novell
+                p.startInfo.fileName = 'mono'
+                args = ''
+                # mono also needs --debug when running
+                if .compiler.options.getDefault('debug', '') not in ['', '-']
+                    args += '--debug '
+                args += '"[fullExe]"'
+                p.startInfo.arguments = args + ' '
+            else
+                throw FallThroughException(.compiler.platform)
+        return p        
+        
+    def setDefaultUseDirectives(ns as NameSpace) is override
+        useToken = Token('(implicit)', 1, 1, 1, 'USE', 'use', nil)      # TODO: make an "implicit" token
+        ns.addUseDirective(UseDirective(useToken, ['System']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'Collections', 'Generic']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'IO']))
+        ns.addUseDirective(UseDirective(useToken, ['System', 'Text']))
+        ns.addUseDirective(UseDirective(useToken, ['Cobra', 'Lang']))
+    
+    def fixLibExtension(libRef as String) as String is override
+        """
+        Augment given lib reference string with backend extension if not already have one
+        """
+        or require libRef.length
+        and ensure result.endsWith('.dll') or result.endsWith('.exe')
+        if not libRef.endsWith('.dll') and not libRef.endsWith('.exe')
+            libRef += '.dll'
+        return libRef
+        
+    def loadLibReference(reference as String) as bool is override
+        return .compiler.dotNetLoadReference(reference)   # in ScanClrType
+    
+    def readSystemTypes is override
+        # TODO: Move the called support methods below out of Compiler
+        
+        # TODO: support targeting a specific CLR version, but not below 2.0
+        #.compiler.readAssembly(Assembly.load('mscorlib.dll') to !)
+        .compiler.clrReadAssembly(Assembly.load('mscorlib.dll') to !)
 
+        # TODO: .readAssembly(Assembly.loadFrom('System.dll') to !)
+        #       gives: Unhandled Exception: System.IO.FileNotFoundException: Could not load file or assembly 'System.dll' or one of its dependencies. The system cannot find the file specified.
+
+        t = System.Diagnostics.Process.getType
+        #.compiler.readAssembly(t.assembly) # System.dll
+        .compiler.clrReadAssembly(t.assembly) # System.dll
+        
+    def fixNilableMemberSigs is override
+        .compiler.dotNetfixNilableMemberSigs # in ScanClrType
+        
+    # Types
+    get objectTypeProxy from var  is override
+        """Type proxy for BE root of Object hierarchy."""
+    get typeTypeProxy from var  is override
+        """Type proxy for BE notion of a class describing a Type."""
+        
+    def cobraNameForNativeBoxName(nativeBoxName as String) as String is override
+        return ClrTypeProxy.cobraNameForSharpBoxName(nativeBoxName)
+        
+    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is override
+        return ClrTypeProxy(type)
+    
+    def nativeType(type as dynamic) as NativeType  is override
+        return ClrNativeType(type)
+    
+    def nativeTypeByName(qualifiedNameOrTag as String) as NativeType is override
+        qualifiedName = .resolveTypeTag(qualifiedNameOrTag)
+        return ClrNativeType(.compiler.clrTypeByName(qualifiedName))
+        /#
+        These are the type tags used directly by the compiler code.
+            
+            bool        'System.Boolean'
+            char        'System.Char'
+            decimal     'System.Decimal'    
+            single      'System.Single'     
+            double      'System.Double'     
+            sbyte       'System.SByte'      
+            int16       'System.Int16'      
+            int32       'System.Int32'      
+            int64       'System.Int64'      
+            byte        'System.Byte'       
+            uint16      'System.UInt16'     
+            uint32      'System.UInt32'     
+            uint64      'System.UInt64'     
+        #/
+    
+    def installNativeMethods(box as Box, nativeType as NativeType) is override
+        .compiler.installClrNativeMethods(box, nativeType) # in ScanClrType
+        
+    def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override
+        iclone = .compiler.libraryType('ICloneable')
+        interfaces.insert(0, iclone to ITypeProxy)
+    
+    
+        
 class GenerateSharpCodePhase inherits Phase
 
     cue init(c as Compiler)

Source/CobraParser.cobra

@@ -62 +62 @@
         """
 
     test
+        c = Compiler()
         p = CobraParser()
         p.globalNS = NameSpace(Token.empty, '(global)')
         p.typeProvider = BasicTypeProvider()
+        p.backEnd = BasicBackEnd(c)
         module = p.parseSource('test1', 'class Test\n\tpass\n')
         decls = (module to dynamic).topNameSpace.declsInOrder
         decl = decls[decls.count-1]
@@ -76 +78 @@
         p = CobraParser()
         p.globalNS = NameSpace(Token.empty, '(global)')
         p.typeProvider = BasicTypeProvider()
+        p.backEnd = BasicBackEnd(c)
         p.parseSource('test2', 'class Test\n\tdef main is shared\n\t\treturn\n')
         
-        c = Compiler()
-        p = CobraParser(typeProvider=c, warningRecorder=c, errorRecorder=c, globalNS=c.globalNS)
+        c = TestCompiler() # to default backend to something on init
+        p = CobraParser(typeProvider=c, warningRecorder=c, errorRecorder=c, globalNS=c.globalNS, backEnd=c.backEnd)
         p.parseSource('test3', '')
         
-        c = Compiler()
-        p = CobraParser(typeProvider=c, warningRecorder=c, errorRecorder=c, globalNS=c.globalNS)
+        c = TestCompiler()
+        p = CobraParser(typeProvider=c, warningRecorder=c, errorRecorder=c, globalNS=c.globalNS, backEnd=c.backEnd)
         p.parseSource('test4', '    ')
 
     shared
@@ -125 +128 @@
     var _expectAnonymousMethodExprStack as Stack<of AnonymousMethodExpr>
 
     var _typeProvider as ITypeProvider?
+    var _backEnd as BackEnd?
+    # compiler is available from _backEnd.compiler
 
     var _parseCommandLineArgs as ParseCommandLineArgsSig?
     
@@ -142 +147 @@
         _curLoopBlockDepth = 0
 
     pro typeProvider from var
+    pro backEnd from var
 
     pro parseCommandLineArgs from var
         """
@@ -178 +184 @@
             return _nameSpaceStack.peek
 
     def parseFileNamed(fileName as String) as CobraModule
-        require .typeProvider
+        require .typeProvider and .backEnd
         if .verbosity >= 2, print 'Parsing [fileName]'
         _fileName = fileName
         source = File.readAllText(_fileName to !)
         return .parseSource(fileName, source)
 
     def parseSource(source as String) as CobraModule
-        require .typeProvider
+        require .typeProvider and .backEnd
         return .parseSource('(no file name)', source)
 
     def parseSource(fileName as String, source as String) as CobraModule
@@ -246 +252 @@
             .recordError(te.token, te.message)
             return false
 
-        # TODO: fold all occcurrences of this lookup to a helper
-        compiler = .typeProvider to? Compiler
-        if compiler
-            compiler.noWarningLines.addRange(tokenizer.noWarningLines)
-            compiler.linesCompiled += tokenizer.linesCompiled
-            compiler.tokensCompiled += tokens.count
+        compiler = .backEnd.compiler
+        compiler.noWarningLines.addRange(tokenizer.noWarningLines)
+        compiler.linesCompiled += tokenizer.linesCompiled
+        compiler.tokensCompiled += tokens.count
 
         if tokenizer.errors.count
             for error in tokenizer.errors
@@ -356 +360 @@
         try
             topNS = _module.topNameSpace
             if not _fileName.endsWith('SystemInterfaces.cobra')
-                # TODO: make an "implicit" token
-                useToken = Token(_fileName, 1, 1, 1, 'USE', 'use', nil)
-                # default use directives
-                topNS.addUseDirective(UseDirective(useToken, ['System']))
-                topNS.addUseDirective(UseDirective(useToken, ['System', 'Collections', 'Generic']))
-                topNS.addUseDirective(UseDirective(useToken, ['System', 'IO']))
-                topNS.addUseDirective(UseDirective(useToken, ['System', 'Text']))
-                topNS.addUseDirective(UseDirective(useToken, ['Cobra', 'Lang']))
+                .backEnd.setDefaultUseDirectives(topNS)
             while .peek, .parseTopLevel
         finally
             _nameSpaceStack.pop
@@ -455 +452 @@
                 if not typeName.text.isOneOf('decimal.float.float32.float64.')
                     .throwError('Compiler directive "number": unrecognized type "[typeName.text]". Must be one of "decimal", "float", "float32" or "float64".')
                 .expect('EOL')
-                comp = .typeProvider to? Compiler
-                if comp, comp.numberTypeName = typeName.text
+                .backEnd.compiler.numberTypeName = typeName.text
             on 'ref'
                 pathToken = .grab
                 if not pathToken.which.isOneOf('ID.STRING_SINGLE.STRING_DOUBLE.')

Source/Types.cobra

@@ -1 +1 @@
 use System.Reflection
 
-
 class NativeType is abstract
     """
     The abstract base class for a boxed native type of the platform being compiled to.
@@ -42 +41 @@
         TODO: Add contract to enforce above statement
         """
 
+    get isSystemObjectClass as bool is abstract
+        """
+        Return true if this is the Native Type Object for the root Object of the class hierarchy.
+            e.g. like System.Object in .Net, java.lang.Object in java
+        """
+
+    get isSystemTypeClass as bool is abstract
+        """
+        Return true if this is the Native Type Object for a System Type.
+            e.g. like System.Type in .Net, java.lang.class in java
+        """
+                
     def customAttributes as IList<of dynamic> is abstract
         """
         Return a list of custom attributes attached to this type.
@@ -52 +63 @@
 
     def getHashCode as int is override
         throw Exception('Subclasses must override .getHashCode')
+            
+class NullNativeType inherits NativeType
+    """
+    Valid but empty nativeType for Tests
+    """
+    var _full = ''
+    var _name = ''
+    
+    cue init(qualName as String)
+        base.init
+        _full = qualName
+        l = qualName.split('.')
+        _name = l[l.length-1]   # l.last or l[-1:][0]
+        
+    get name as String is override
+        return _name
+    
+    get fullName as String is override
+        return _full
 
+    get isValueType as bool is override
+        return false
+        
+    get baseType as NativeType? is override
+        return this # wrong either way - cant get ObjectType and isnt Object root so cant return nil
+    
+    def customAttributes as IList<of dynamic> is override
+        return List<of dynamic>() 
 
+    def equals(other as Object?) as bool is override
+        return false
+
+    def getHashCode as int is override
+        return 999666
+    
+    get isSystemObjectClass as bool is override 
+        return false    
+        
+    get isSystemTypeClass as bool is override
+        return false    
+
 interface ITypeProvider
     """
-    A type provider can provide essential types and serve as a place
-    they are "uniqued" in order to avoid type duplication.
+    A type provider can provide essential types and serve as a place to centralise the provision of these
+    types. They are "uniqued" in order to avoid type duplication.
 
     The Cobra types themselves rely on having a type provider available to implement some of their methods.
 
-    The main type provider is Compiler.
+    The main type provider is in the Compiler.
     There is also a BasicTypeProvider that is useful in setting up tests.
     """
 
@@ -114 +164 @@
 
     def defaultType as IType
 
-
+        
+#   TODO: rename to TypeProvider, change to a "mix-in" and have the Compiler class inherit it
 class BasicTypeProvider
     implements ITypeProvider
     """
-    TODO: rename to TypeProvider, change to a "mix-in" and have the Compiler class inherit it
+    This is the base and also can be used as a test TypeProvider
     """
 
     var _anyFloatType       as AnyFloatType?
@@ -264 +315 @@
         _variTypes[type] = vt = VariType(type)
         return vt
 
-    def libraryType(qualifiedName as String) as IType
-        return BasicLibraryType(.nativeType(qualifiedName))
-
-    def nativeType(qualifiedName as String) as NativeType
-        return ClrNativeType(sharp'System.Type.GetType(qualifiedName)' to System.Type)
-
     def defaultType as IType
         if _defaultType is nil
             _defaultType = .nilableType(.dynamicType)
         return _defaultType to !
 
+    def libraryType(qualifiedName as String) as IType
+        return BasicLibraryType(.nativeType(qualifiedName))
 
+    def nativeType(qualifiedName as String) as NativeType
+        return NullNativeType(qualifiedName) 
+        #return ClrNativeType(sharp'System.Type.GetType(qualifiedName)' to System.Type)
+        
+
 class BasicLibraryType
     is partial
     implements IType
@@ -288 +340 @@
     shared
         
         def systemObjectType as BasicLibraryType
-            return BasicLibraryType(ClrNativeType(sharp'typeof(System.Object)'))
+            #nativeType = .compiler.ObjectNativeType
+            nativeType = ClrNativeType(sharp'typeof(System.Object)')
+            return BasicLibraryType(nativeType)
 
     var _nativeType as NativeType
 
@@ -513 +567 @@
     def unNilReturnType
         pass
 
+        
 
 interface IType
     is partial
@@ -843 +898 @@
 
     var _systemAliasProxy as ITypeProxy?
         """
-        Subclasses set this to a LibraryTypeProxy instead of ClrTypeProxy because, for example, the
+        Subclasses set this to a LibraryTypeProxy instead of a backendTypeProxy because, for example, the
         ClrTypeProxy for the clr type System.Boolean would return a Cobra BoolType instance! Then
         the primitive type would have a self reference when what it really wanted was the Struct
         instance for System.Boolean.
@@ -876 +931 @@
             _systemAliasType = _systemAliasProxy.realType
             _systemAliasType.bindInh
         if .compiler  # will be nil during unit tests
-            _box = Class(Token.empty, Token.empty, '[.getType.name]_[.serialNum]', List<of IType>(), List<of String>(), AttributeList(), ClrTypeProxy(Object), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
+            baseNode = .compiler.objectTypeProxy 
+            _box = Class(Token.empty, Token.empty, '[.getType.name]_[.serialNum]', List<of IType>(), List<of String>(), AttributeList(), baseNode, List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
             if _systemAliasType inherits Box
                 for bip in _systemAliasType.baseInterfaceProxies
                     _box.baseInterfaceProxies.add(bip)
@@ -884 +940 @@
 
     def _bindInt
         base._bindInt
-
         if _systemAliasType, _systemAliasType.bindInt
-
         if .compiler and _nativeType
-            meths = List<of Method>()
-            _installNativeMethodsFrom('System', _nativeType to !, meths)
-            _installNativeMethodsFrom('System', ClrNativeType(System.Math.getType), 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
-            _installNativeMethodsFrom('CobraLangInternal', ClrNativeType(Cobra.Lang.DecimalTools.getType), meths)
-
-            # _printMethods(meths)
-
+            .compiler.installNativeMethods(_box to !, _nativeType to !) # BackEnd
         _box.bindInt
 
-    def _printMethods(meths as IList<of Method>)
-        # print out the methods
-        # useful for documentation
-        print
-        print 'type', .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]'
-
-    def _installNativeMethodsFrom(namespaceName as String, nativeType as NativeType, meths as List<of Method>)
-        argClrType = (nativeType to ClrNativeType).clrType
-        thisClrType = (_nativeType to ClrNativeType).clrType
-        box = _box
-        # print
-        # print '** [.name], clrType'
-        isSameNativeType = argClrType == thisClrType
-        for methInfo in argClrType.getMethods(BindingFlags(DeclaredOnly, Static, Instance, Public))
-            if methInfo.isSpecialName, continue
-            # print
-            # print '--', methInfo, methInfo.isStatic
-            name = Utils.cobraNameForSharpMemberName(methInfo.name)
-            modifiers = List<of String>()
-            if methInfo.isStatic, modifiers.add('shared')
-            newParams = List<of Param>()
-            first = true
-            cancel = false
-            for nativeParam in methInfo.getParameters
-                if first
-                    first = false
-                    if methInfo.isStatic
-                        if methInfo.getParameters[0].parameterType == thisClrType
-                            # When the first arg of the shared method is the same type,
-                            # then make an instance method that can be used directly on values of the type.
-                            # print methInfo.getParameters
-                            # print methInfo.getParameters[0].parameterType
-                            modifiers.remove('shared')
-                            continue
-                        else if not isSameNativeType
-                            # don't want, for example, Math.sign showing up in types char, bool, etc. as a shared method
-                            cancel = true
-                            continue
-                param = Param(Token.empty.copy('ID', nativeParam.name), ClrTypeProxy(nativeParam.parameterType))
-                if nativeParam.parameterType.isByRef and not nativeParam.isOut
-                    param.direction = Direction.InOut
-                else if nativeParam.isOut
-                    param.direction = Direction.Out
-                newParams.add(param)
-            if cancel, continue
-            meth = Method(Token.empty, Token.empty, box, name, newParams, ClrTypeProxy(methInfo.returnType), nil, modifiers, AttributeList(), '')
-            if methInfo.isStatic
-                meth.sharedMethodBacking = '[namespaceName].[argClrType.name].[methInfo.name]'
-                if 'shared' in modifiers, meth.sharedMethodBackingIsAlias = true
-
-            overload = nil to MemberOverload?
-            other = box.declForName(name)
-            if other
-                if other inherits MemberOverload
-                    overload = other
-                else if other inherits AbstractMethod or other inherits ProperDexer
-                    overload = MemberOverload(other to BoxMember)
-                    box.registerOverload(overload to !)
-                else
-                    throw FallThroughException([box, meth, other])
-            else
-                assert box.declForName(name) is nil
-            if overload
-                overload.addMember(meth)
-            else
-                box.addDecl(meth)
-                
-            meths.add(meth)
-
-    def compareMethodNames(a as Method, b as Method) as int
-        return a.name.compareTo(b.name)
-
     def memberForName(name as String) as IMember?
         member = base.memberForName(name)
         if member is nil, member = _box.memberForName(name)
@@ -1010 +972 @@
 
     cue init
         base.init
-        _nativeType = .typeProvider.nativeType('System.Boolean')
-        _systemAliasProxy = LibraryTypeProxy('System.Boolean')
+        _nativeType = .typeProvider.nativeType('bool')
+        _systemAliasProxy = LibraryTypeProxy('bool')
 
     get name as String is override
         return 'bool'
@@ -1021 +983 @@
 
     cue init
         base.init
-        _nativeType = .typeProvider.nativeType('System.Char')
-        _systemAliasProxy = LibraryTypeProxy('System.Char')
+        _nativeType = .typeProvider.nativeType('char')
+        _systemAliasProxy = LibraryTypeProxy('char')
 
     get name as String is override
         return 'char'
@@ -1038 +1000 @@
 
     cue init
         base.init
-        _nativeType = .typeProvider.nativeType('System.Decimal')
-        _systemAliasProxy = LibraryTypeProxy('System.Decimal')
+        _nativeType = .typeProvider.nativeType('decimal')
+        _systemAliasProxy = LibraryTypeProxy('decimal')
 
     get name as String is override
         return 'decimal'
@@ -1133 +1095 @@
             base.init(superType)
             _size = size
             branch size
-                on 32, _nativeType = .typeProvider.nativeType('System.Single')
-                on 64, _nativeType = .typeProvider.nativeType('System.Double')
+                on 32, _nativeType = .typeProvider.nativeType('single')
+                on 64, _nativeType = .typeProvider.nativeType('double')
                 else, throw FallThroughException(size)
             _systemAliasProxy = LibraryTypeProxy(_nativeType.fullName)
 
@@ -1240 +1202 @@
             _size = size
             if signed
                 branch size
-                    on  8, _nativeType = .typeProvider.nativeType('System.SByte')
-                    on 16, _nativeType = .typeProvider.nativeType('System.Int16')
-                    on 32, _nativeType = .typeProvider.nativeType('System.Int32')
-                    on 64, _nativeType = .typeProvider.nativeType('System.Int64')
+                    on  8, _nativeType = .typeProvider.nativeType('sbyte')
+                    on 16, _nativeType = .typeProvider.nativeType('int16')
+                    on 32, _nativeType = .typeProvider.nativeType('int32')
+                    on 64, _nativeType = .typeProvider.nativeType('int64')
                     else, throw FallThroughException(size)
             else
                 branch size
-                    on  8, _nativeType = .typeProvider.nativeType('System.Byte')
-                    on 16, _nativeType = .typeProvider.nativeType('System.UInt16')
-                    on 32, _nativeType = .typeProvider.nativeType('System.UInt32')
-                    on 64, _nativeType = .typeProvider.nativeType('System.UInt64')
+                    on  8, _nativeType = .typeProvider.nativeType('byte')
+                    on 16, _nativeType = .typeProvider.nativeType('uint16')
+                    on 32, _nativeType = .typeProvider.nativeType('uint32')
+                    on 64, _nativeType = .typeProvider.nativeType('uint64')
                     else, throw FallThroughException(size)
             _systemAliasProxy = LibraryTypeProxy(_nativeType.fullName)
 
@@ -1761 +1723 @@
     def _bindInh
         base._bindInh
         if .compiler  # will be nil during unit tests
-            iclone = .compiler.libraryType('System.ICloneable')
-            icoll = (.compiler.libraryType('System.Collections.Generic.ICollection<of>') to Box).constructedTypeFor([.theWrappedType])
+            #iclone = .compiler.libraryType('ICloneable')
+
+            #icoll = (.compiler.libraryType('System.Collections.Generic.ICollection<of>') to Box).constructedTypeFor([.theWrappedType])
+            #icoll = (.compiler.libraryType('ICollection<of>') to Box).constructedTypeFor([.theWrappedType])
+            icoll = .compiler.collectionOfType.constructedTypeFor([.theWrappedType])
             ienum = .compiler.enumerableOfType.constructedTypeFor([.theWrappedType])
             _ilistOf = .compiler.ilistOfType.constructedTypeFor([.theWrappedType]) to Interface
-            interfaces = [iclone to ITypeProxy, icoll, ienum]  # TODO:, _ilistOf]  -- problems with cobra -ert:yes hello and extension method String.split
+            interfaces = [icoll to ITypeProxy, ienum]  # TODO:, _ilistOf]  -- problems with cobra -ert:yes hello and extension method String.split
+            .compiler.backEnd.addArrayInterfaces(interfaces)
             _box = Class(Token.empty, Token.empty, '[.getType.name]_[.serialNum]', List<of IType>(), List<of String>(), AttributeList(), nil, interfaces, List<of ITypeProxy>(), nil)
             # TODO: make members based on System.Array
             indexer = Indexer(Token.empty, Token.empty, _box, r'[]', [Param(Token('', 1, 1, 1, 'ID', 'index', nil), .compiler.intType)], _wrappedType, List<of String>(), AttributeList(), '')

Source/files-to-compile.text

@@ -59 +59 @@
 BackEndClr/SharpGenerator
 BackEndClr/SharpCompilationMessage
 
+#BackEndClr/CobraJvmProxy
 BackEndJvm/JvmBackEnd
+BackEndJvm/JvmType
+BackEndJvm/JvmJarSig
+BackEndJvm/ScanJvmType
 BackEndJvm/JavaGenerator
 BackEndJvm/JavaCompilationMessage
 

Source/Vars.cobra

@@ -39 +39 @@
     var _ifInheritsStack = Stack<of IType>()
     var _isAssignedTo as bool
     var _backEndName as String
-    var _useBackEndNameStack = Stack<of String>()  # for if-inherits
+    var _useBackEndNameStack = Stack<of String>()  # TODO: for if-inherits
 
     cue init(token as IToken, type as IType)
         require token.text.length