Ticket #178: inner-classes.patch

Source/BackEndClr/SharpGenerator.cobra

@@ -1032 +1032 @@
             return
         if .isGenericDef  # sorry, but static methods always require a type arg even if you don't need it. workaround. make another class with a 'test' section that tests the generic class TODO: make Cobra do this, but then watch for use of the generic param!
             return
-        assert .parentNameSpace
+        #assert .parentNameSpace # suppress for nested classes 
         sw.write('\t\t[.sharpRef].RunTestsIfNeeded();\n')
         _didWriteSharpTestInvocation = true
 
@@ -1043 +1043 @@
 class Class
     is partial
 
+    get sharpRef as String is override
+        # for getting fully dotted name for nested classes
+        sb = StringBuilder()
+        if .enclosure
+            sb.append(.enclosure.sharpRef + '.')
+        sb.append(base.sharpRef)
+        return sb.toString
+
     get sharpInit as String is override
         return 'null'
 
@@ -1128 +1136 @@
 class Struct
     is partial
 
+    get sharpRef as String is override
+        # for getting fully dotted name for nested classes
+        sb = StringBuilder()
+        if .enclosure
+            sb.append(.enclosure.sharpRef + '.')
+        sb.append(base.sharpRef)
+        return sb.toString
+
     get sharpInit as String is override
         return ''  # blank to indicate there is no valid init
 
@@ -3561 +3577 @@
     is partial
 
     def writeSharpDef(sw as CurlyWriter, parens as bool) is override
-        sharpRef = _containedType.sharpRef
+        sharpRef =  _containedType.sharpRef
         # handle the case of "X.X" where namespace and class are both called "X".
         # C# chokes on it because the first "X" is considered to be the type
         if .curBox.name + '.' in sharpRef
             sharpRef = 'global::' + sharpRef
         if _requiresTypeOf()
             sw.write('typeof(')
-            sw.write(_containedType.sharpRef)
+            sw.write(sharpRef)
             sw.write(')')
         else
-            sw.write(_containedType.sharpRef)
+            sw.write(sharpRef)
 
     def _requiresTypeOf as bool
         # Cobra never requires that you wrap a type reference in typeof(Foo).

Source/Boxes.cobra

@@ -1072 +1072 @@
     """
     
     var _addsProxies as List<of ITypeProxy>
+    var _enclosure as ClassOrStruct?
+
+    pro enclosure from var  # enclosure for nested class/struct
     
     cue init(token as IToken, idToken as IToken, name as String, paramList as List<of IType>, isNames as List<of String>, attribs as AttributeList, implementsNodes as List<of ITypeProxy>, addsProxies as List<of ITypeProxy>, docString as String?)
         base.init(token, idToken, name, paramList, isNames, attribs, implementsNodes, docString)
         _addsProxies = addsProxies
 
+    def addRefFields
+        base.addRefFields
+        .addField('enclosure', _enclosure)
+
     def _bindInh
         # mixins act as interfaces (and more)
         for proxy in _addsProxies

Source/CobraParser.cobra

@@ -665 +665 @@
         
         theClass = Class(wordToken, idToken, name, .makeList<of IType>(genericParams), typeSpecs.isNames, typeSpecs.attributes, inheritsProxy, typeSpecs.implementsProxies, typeSpecs.addsProxies, docString)
 
-        # TODO when supporting nested classes, look at the _boxStack and set a back pointer here
+        # For nested classes, set pointer to enclosure
+        if _boxStack.count
+            encl = .curBox 
+            if encl inherits ClassOrStruct
+                theClass.enclosure = encl
+
         _boxStack.push(theClass)
 #       .isNamesStack = Stack<of String>
         .bodiedBoxMemberDecls(theClass)
@@ -928 +933 @@
 
         theStruct = Struct(wordToken, idToken, name, .makeList<of IType>(genericParams), typeSpecs.isNames, typeSpecs.attributes, nil, typeSpecs.implementsProxies, typeSpecs.addsProxies, docString)
 
-        # TODO when supporting nested classes, look at the boxStack and set a back pointer here
+        # For nested classes, set pointer to enclosure
+        if _boxStack.count
+            encl = .curBox 
+            if encl inherits ClassOrStruct
+                theStruct.enclosure = encl
+
         _boxStack.push(theStruct)
 #       .isNamesStack = Stack(str)
         .bodiedBoxMemberDecls(theStruct)
@@ -1174 +1184 @@
                     on 'SIG', .addDecl(box, .declareMethodSig)
                     on 'SHARED', .bodiedBoxMemberDeclsShared(box)
                     on 'TEST', .testSection(box)
+                    on 'CLASS',  .addDecl(box, .classDecl)  # nested classes
+                    on 'STRUCT', .addDecl(box, .structDecl) # nested classes
                     else
                         branch .peek.text
                             on 'ensure', sugg = 'invariant'
@@ -1181 +1193 @@
                             else, sugg = ''
                         if sugg <> ''
                             sugg = ' Instead of "[.peek.text]", try "[sugg]".'
-                        .throwError('Got [.peek] when expecting def, enum, get, invariant, pro, set, shared, sig, test, or var.[sugg]')
+                        .throwError('Got [.peek] when expecting def, enum, get, invariant, pro, set, shared, sig, test, class or var.[sugg]')
             .dedent
 
     def addDecl(box as Box, member as IBoxMember?)

Tests/120-classes/330-nested.cobra

@@ +1 @@
+# simple nested class - access from inside
+class Enclosing
+    
+    class Nested
+        cue init
+            base.init
+
+        def geti as int
+            return 1
+            
+    def geti as int
+        return 99
+        
+    def main
+        a = Enclosing()
+        assert a.geti == 99
+        n=Enclosing.Nested()
+        assert n.geti == 1
+        

Tests/120-classes/332-nested-multi.cobra

@@ +1 @@
+# multiple levels of Nested class, infereed and explicit typing
+class Enclosing
+    
+    class Nested is public
+
+        def geti as int
+            return 1
+
+        class Nested2
+
+            def geti as int
+                return 2
+
+    class NestedOther
+
+        get geti
+            return 10
+            
+    def geti as int 
+        return 99
+    
+class Enc
+    def main
+        a = Enclosing()
+        assert a.geti == 99
+
+        en=Enclosing.Nested()
+        assert en.geti == 1
+    
+        enn=Enclosing.Nested.Nested2()
+        assert enn.geti == 2
+        
+        eno as Enclosing.NestedOther?
+        eno = Enclosing.NestedOther()
+        assert eno.geti == 10
+        

Tests/120-classes/334-nested-idiom.cobra

@@ +1 @@
+# Test of C# idiom for Java-like implicit enclosure ref for nested classes.
+# as per  http://blogs.msdn.com/oldnewthing/archive/2006/08/01/685248.aspx
+
+class Enclosing
+    var s as String = 'no-thing'
+    
+    class Nested 
+        var _parent 
+
+        cue init(parent) # Java does this implicitly
+            base.init
+            _parent = parent
+        
+        def getS as String
+            return _parent.s
+            
+    
+    def mkNested as Nested
+        return Enclosing.Nested(this)
+            
+    def main
+        e = Enclosing()
+        #n = Enclosing.Nested()  # no no-arg ctor
+        n = Enclosing.Nested(e) 
+        n1 = e.Nested(e)
+        assert n.getS == 'no-thing'
+        assert n1.getS == 'no-thing'
+        
+        n2 = e.mkNested
+        assert n2.getS == 'no-thing'
+        delta = 'activated'
+        e.s = delta
+        assert n.getS  == delta
+        assert n1.getS == delta
+        assert n2.getS == delta
+        assert n <> n1
+        assert n <> n2
+        assert n1 <> n2

Tests/140-structs/402-nested-multi.cobra

@@ +1 @@
+# nested struct in struct and classes accessed from a third class
+struct Enclosing
+    
+    struct Nested
+        def geti as int
+            return 1
+
+        struct Nested2
+            def geti as int
+                return 2
+
+    struct NestedOther
+        def geti as int
+            return 10
+            
+    def geti as int 
+        return 99
+    
+class EnclosingClass
+    
+    struct Nested is public
+
+        def geti as int
+            return 101
+
+        struct Nested2
+            def geti as int
+                return 102
+
+    struct NestedOther
+        def geti as int
+            return 110
+            
+    def geti as int 
+        return 199
+        
+class EntryPt
+    def main
+        s = Enclosing()
+        assert s.geti == 99
+
+        sen=Enclosing.Nested()
+        assert sen.geti == 1
+        
+        senn1 as Enclosing.Nested.Nested2 = Enclosing.Nested.Nested2()
+        assert senn1.geti == 2
+    
+        senn =Enclosing.Nested.Nested2()
+        assert senn.geti == 2
+        
+        seno = Enclosing.NestedOther()
+        assert seno.geti == 10
+    
+        c = EnclosingClass()
+        assert c.geti == 199
+
+        cen=EnclosingClass.Nested()
+        assert cen.geti == 101
+    
+        cenn=EnclosingClass.Nested.Nested2()
+        assert cenn.geti == 102
+        
+        ceno = EnclosingClass.NestedOther()
+        assert ceno.geti == 110
+        

Tests/140-structs/400-nested.cobra

@@ +1 @@
+# nested struct in class or struct
+
+struct EnclStruct
+    class Nested
+        def geti as int
+            return 1
+            
+    struct SNested
+        def geti as int
+            return 10
+
+    def geti as int
+        return 99
+
+
+class Enclosing
+    
+    struct NestedStruct
+        def geti as int
+            return 1
+
+    def geti as int
+        return 99
+        
+    def main
+    
+        # class with nested struct
+        e = Enclosing()
+        assert e.geti == 99
+        ens=Enclosing.NestedStruct()
+        assert ens.geti == 1
+        
+        # Struct with nested class
+        es = EnclStruct()
+        assert es.geti == 99
+        esn=EnclStruct.Nested()
+        assert esn.geti == 1
+        
+        ess=EnclStruct.SNested()
+        assert ess.geti == 10

Developer/IntermediateReleaseNotes.text

@@ -48 +48 @@
 
 * Sets with duplicate members such as `{1, 0, 1}` now generate a warning.
 
+* Provide support for inner/nested classes (structs and classes) within classes and structs
+
 ================================================================================
 Library
 ================================================================================