Changeset 1853

Timestamp:

12/30/08 09:14:09 (3 years ago)

Author:

Chuck.Esterbrook

Message:

Added extensions on generic types like List<of T> and IDictionary<of K, V>.
ticket:1

Location:

cobra/trunk

Files:

• Developer/IntermediateReleaseNotes.text (modified) (1 diff)
• Source/BackEndClr/SharpGenerator.cobra (modified) (5 diffs)
• Source/Boxes.cobra (modified) (13 diffs)
• Tests/420-extensions/400-extend-generics (added)
• Tests/420-extensions/400-extend-generics/100-extend-list-of.cobra (added)
• Tests/420-extensions/400-extend-generics/110-extend-ilist-of.cobra (added)
• Tests/420-extensions/400-extend-generics/120-extend-list-of-same-generic-arg-name.cobra (added)
• Tests/420-extensions/400-extend-generics/200-extend-dictionary-of.cobra (added)
• Tests/420-extensions/400-extend-generics/210-extend-idictionary-of.cobra (added)
• Tests/420-extensions/400-extend-generics/300-extend-nonlib-generic.cobra (added)
• Tests/420-extensions/400-extend-generics/310-extend-nonlib-generic-with-inheritance.cobra (added)
• Tests/420-extensions/400-extend-generics/400-extend-nonlib-generic-error.cobra (added)

cobra/trunk/Developer/IntermediateReleaseNotes.text

@@ -77 +77 @@
     r = Rectangle(p1=Point(x=0, y=1), p2=Point(x=2, y=3))
     c = Customer('Acme, Inc.', region=Regions.South)
+
+* Added extensions on generic types like List<of T> and IDictionary<of K, V>.  ticket:1
 
 * Added partial classes, a la C# and VB. This enables class (and struct and interface) declarations to be split across files. This can be useful for organizing generated code or even manually written code based on purpose. ticket:10

cobra/trunk/Source/BackEndClr/SharpGenerator.cobra

@@ -973 +973 @@
         return sharp
 
+    def extendedMethodGenericParams(genericParams as IList<of IType>) as IList<of IType>
+        """
+        This is a hook for Extension and Method which have to deal with extensions on generic classes.
+        """
+        ensure
+            old genericParams == genericParams
+            result.count >= genericParams.count
+        body
+            return genericParams
+
     def writeSharpDef(sw as SharpWriter)
         base.writeSharpDef(sw)
@@ -1275 +1285 @@
     is partial
 
+    get _computeSharpRef as String is override
+        sharp = .sharpName
+        if .parentNameSpace and not .parentNameSpace.isRoot
+            sharp = .parentNameSpace.sharpQualifier + sharp
+        else if .parentBox
+            sharp = .parentBox.sharpRef + '.' + sharp
+        return sharp
+
     get sharpInit as String is override
         return _extendedBox.sharpInit
@@ -1285 +1303 @@
 
     var _backEndName as String?
-    
+
     get sharpName as String is override
         if not _backEndName
@@ -1293 +1311 @@
     get sharpThis as String is override
         return '_lh_this'
+
+    def extendedMethodGenericParams(genericParams as IList<of IType>) as IList<of IType> is override
+        if .isGeneric
+            # the generated static C# method will need the generic params of the extension on it
+            # since C# itself doesn't have "extension types", only extension methods
+            r = List<of IType>(.genericParams)
+            r.addRange(genericParams)
+            return r
+        else
+            return base.extendedMethodGenericParams(genericParams)
 
     def writeSharpDefName(sw as SharpWriter) is override
@@ -1780 +1808 @@
 
     get sharpGenericParams as String is override
-        if _genericParams.count
+        params = .parentBox.extendedMethodGenericParams(_genericParams)
+        if params.count
             sb = StringBuilder()
             sb.append('<')
             sep = ''
-            for param in _genericParams
+            for param in params
                 sb.append(sep)
                 sb.append(param.sharpName)

cobra/trunk/Source/Boxes.cobra

@@ -46 +46 @@
         _attribs = attribs
         _genericParams = paramList
-        for i = 0 .. _genericParams.count
+        for i in _genericParams.count
             p = _genericParams[i]
-            if p inherits GenericParam
-                p.index = i
+            if p inherits GenericParam, p.index = i
         _extensions = List<of Extension>()
         _baseInterfaceProxies = baseInterfaceNodes
@@ -128 +127 @@
 
     get extensions from var
+
+    get allExtensions as Extension*
+        """ Return all extensions including inheritance through all base classes and interfaces. """
+        require .didBindInh and .didBindInt
+        for ext in .extensions, yield ext
+        if _baseClass, for ext in _baseClass.allExtensions, yield ext
+        for bi in _baseInterfaces, for ext in bi.allExtensions, yield ext
 
     get hasExtensions as bool
@@ -819 +825 @@
             t._nativeType = nil  # The constructed type is really sourced from the generic def. Don't foster confusion with a reference to the original generic def's clr type (if there is one).
             t.cloneCollections
+
             # set the contructed type args immediately or its ancestors will get the original generic args during _bindInt:
             for i in typeArgs.count
                 t._genericParams[i] = typeArgs[i]
             assert t._constructedTypes is nil or t._constructedTypes.count == 0
+
             if .didBindInt
                 t._completeConstruction(typeArgs)
@@ -828 +836 @@
                 t._needsConstruction(typeArgs)
             assert t._constructedTypes is nil or t._constructedTypes.count == 0
+
             return t
 
@@ -871 +880 @@
             gpToType = TypeUtil.dictionaryOf(_genericDef.genericParams, typeArgs)
 
-            _baseClass = _baseClass.secondaryConstructedTypeFor(this, gpToType) to Class
+            if _baseClass, _baseClass = _baseClass.secondaryConstructedTypeFor(this, gpToType) to Class
 
             assert _baseInterfaceProxies.count == 0 or _baseInterfaceProxies.count == _baseInterfaces.count
-            for i = 0 .. _baseInterfaces.count
+            for i in _baseInterfaces.count
                 _baseInterfaces[i] = _baseInterfaces[i].secondaryConstructedTypeFor(this, gpToType) to Interface
 
@@ -912 +921 @@
                     _declsByName[decl.name] = decl
                     _declsByNameCI[decl.name.toLower] = decl
+            for i in _extensions.count
+                ext = _extensions[i] = _extensions[i].constructedTypeFor(typeArgs) to Extension
+                ext.completeMemberConstructionIfNeeded
             # TODO: can this next statement can be axed since there is a separate "bind inheritance" phase?
             _finishOverloads
@@ -945 +957 @@
         _baseInterfaces = List<of Interface>(_baseInterfaces)
         # _overloads = List<of MemberOverload>(_overloads)  # these will be recreated
+        _extensions = List<of Extension>(_extensions)
 
     def typeForGenericParam(gp as GenericParam) as IType # TODO: is this needed for NilableType?
@@ -1449 +1462 @@
     """
 
-    var _extendedBoxProxy as ITypeProxy
+    var _extendedBoxProxy as ITypeProxy?
     var _extendedBox as Box?
 
@@ -1487 +1500 @@
         if box.isDescendantOf(_extendedBox to !)
             return .declForName(name)
+        else if box.genericDef and (box.genericDef.isDescendantOf(_extendedBox to !) _
+                                        or (_extendedBox.genericDef and box.isDescendantOf(_extendedBox.genericDef.constructedTypeFor(box.genericParams))))
+            for ext in box.allExtensions
+                if ext.genericDef is this
+                    return ext.declForName(name)
+            throw FallThroughException()
         else
             return nil
@@ -1506 +1525 @@
 
         if _extendedBox is nil
+            if _extendedBoxProxy inherits GenericTypeIdentifier
+                # this will error on the generic params unless we set them up to be found
+                for tn in _extendedBoxProxy.typeNodes
+                    if tn inherits TypeIdentifier
+                        _genericParams.add(GenericParam(tn.name))
+                    else
+                        .throwError('Invalid generic param "[tn]".')
+
             realType = _extendedBoxProxy.realType
             if realType inherits Box
@@ -1511 +1538 @@
             else
                 .throwError('Cannot extend a [realType.name]. You can extend classes, structs and interfaces.')
+                
         _name = '[_extendedBox.name].extension.[.serialNum]'
 
@@ -1519 +1547 @@
         
         # connect up
-        _extendedBox.extensions.add(this)
+        if _extendedBox.genericDef
+            _genericParams = List<of IType>(_extendedBox.genericParams)
+            _extendedBox.genericDef.extensions.add(this)
+        else
+            _extendedBox.extensions.add(this)
     
     def _bindInt
@@ -1548 +1580 @@
                         else
                             throw FallThroughException([this, decl])
-                        decl.overloadGroup = nil  # Could be in a group from the extension itself. And .addMember below don't like that.
+                        decl.overloadGroup = nil  # Could be in a group from the extension itself. And .addMember below doesn't like that.
                         overload.addMember(decl)
                         if newOverload, newOverload.bindInt  # an overload that never .bindInt will get cranky later