Ticket #258: typeAlias-chk-implements.patch

Source/Types.cobra

@@ -873 +873 @@
         if _superType is nil
             _superType = .compiler.objectType
         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)
+            # Tmp hack below, this would be better done by reading interfaces off nativeType and copying 
+            #  them onto this aliasType
+            icomp = .compiler.libraryType('System.IComparable')
+            iconv = .compiler.libraryType('System.IConvertible')
+            # TODO ifmt = .compiler.libraryType('System.IFormattable') # ints/single/float/Decimal only
+            # TODO IComparable<type>, IEquatable<type>
+            interfaces = [icomp to ITypeProxy, iconv]  
+            _box = Class(Token.empty, Token.empty, '[.getType.name]_[.serialNum]', List<of IType>(), List<of String>(), AttributeList(), ClrTypeProxy(Object), interfaces, List<of ITypeProxy>(), nil)
             _box.bindInh
     
     def _bindInt
@@ -892 +899 @@
             # 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)
-
+            #TODO _installNativeInterfacesFrom('System', _nativeType to !)
             _box.bindInt
             if false
                 # print out the methods
@@ -985 +992 @@
     def isAssignableTo(type as IType) as bool
         r = base.isAssignableTo(type)
         if not r, r = _systemAliasType == type
+        if not r and _box, r =  _box.isAssignableTo(type)
         return r
 
     def isComparableTo(t as IType) as bool

Tests/130-interfaces/800-primitive-typeAlias-implements.cobra

@@ +1 @@
+# int primitive aliasType not cogniscent of interfaces of Int*
+# Also missing on other aliasTypes but this only exercises
+# IComparable, IConvertible
+# full set of interfaces on aliases to check is
+#  int{8,16,32,64} IComparable, IConvertible, IFormattable   IComparable<int>, IEquatable<int>, 
+#   single         IComparable, IConvertible, IFormattable   IComparable<float>, IEquatable<float>, 
+#   double         IComparable, IConvertible, IFormattable   IComparable<double>, IEquatable<double> 
+#   decimal        IComparable, IConvertible, IFormattable   IComparable<decimal>, IEquatable<decimal> 
+
+#   bool  IComparable, IConvertible,                 IComparable<bool>, IEquatable<bool>, 
+#   char  IComparable, IConvertible,                 IComparable<bool>, IEquatable<bool>, 
+
+class IntNotIComp
+    def main
+        
+        # int (int32)
+        i as int = 47
+        i1 as int = 46
+        .checkIComparable(i, i1)
+        .checkIConvertible(i, i1)
+        #b = .checkICompGt(i, i1) # was compile error here
+        #assert b
+        #print b
+    
+        # bool
+        b = true
+        b1 = false
+        .checkIComparable(b, b1)
+        .checkIConvertible(b, b1)
+    
+        # char
+        c = c'0'
+        c1 = c'1'
+        .checkIComparable(c, c1)
+        .checkIConvertible(c, c1)
+        
+        # float/single
+        s  = 10f
+        s1 = 11f
+        .checkIComparable(s, s1)
+        .checkIConvertible(s, s1)
+        
+        # float64/double
+        d  as float64 = 10f64
+        d1 as float64 = 11f64
+        .checkIComparable(d, d1)
+        .checkIConvertible(d, d1)
+    
+        # Decimal
+        dc  as decimal = 99.1
+        dc1 as decimal = 99.9
+        .checkIComparable(dc, dc1)
+        .checkIConvertible(dc, dc1)
+    
+        
+    def checkICompGt(i as IComparable, i1 as IComparable) as bool
+        if i.compareTo(i1) >0, return true
+        return false
+        
+    def checkIComparable(i as IComparable, i1 as IComparable)
+        pass
+        
+    def checkIConvertible(i as IConvertible, i1 as IConvertible)
+        pass
+    
+    #NYI    
+    def checkIFormattable(f as IFormattable, f1 as IFormattable)
+        pass
+        
+class GenChk<of T>
+    shared
+        def checkIComparableG(i as IComparable<of T>, i1 as IComparable<of T>)
+            pass
+        
+        def checkIEquatableG(e as IEquatable<of T>, e1 as IEquatable<of T>)
+            pass
+    # use as GenChk<of int>.checkIComparableG(i, i1)
+    # use as GenChk<of bool>.checkIComparableG(b, b1)
+    #...