Ticket #76: typecast-to-nil-warnings.patch

Source/BinaryOpExpr.cobra

@@ -924 +924 @@
 
     cue init(opToken as IToken, op as String, left as Expr, right as Expr)
         base.init(opToken, op, left, right)
-        # TODO: use IPotentialTypeExpr like ToExpr does
 
     def _bindImp
         base._bindImp
         if not _type inherits NilableType
             _type = NilableType(_type).bindAll to NilableType  # CC: axe cast when 'as this' is supported
-        # TODO: warn about redundancy
+        # warn about redundancy
+        rightTypeExpr = _right to IPotentialTypeExpr
+        rightType = rightTypeExpr.potentialType
+        if rightType
+            if _left.type inherits NilableType and not rightType inherits NilableType
+                if _left.type.nonNil == rightType
+                    .compiler.warning(this, 'The given expression is already a "[rightTypeExpr.toCobraSource]", but nilable. You can use "to !" to remove the nilability or remove the redundant cast.')
+            else if not _left.type inherits NilableType and rightType inherits NilableType
+                pass # TODO: chk rhs type is castable to lhs regardless of nilibility
+            else if _left.type == rightType
+                .compiler.warning(this, 'The given expression is already a "[rightTypeExpr.toCobraSource]" so the typecast is redundant. You can remove it.')
+        else
+            .throwError('Cannot locate a type for the type cast "to [rightTypeExpr.toCobraSource]".')
 
 
 class CoalesceExpr

Tests/800-warnings/201-typecast-nil-warnings.cobra

@@ +1 @@
+class Foo
+
+    def main is shared
+        
+        a = TypeA()
+        b = a to? TypeA  # .warning. The given expression is already a "TypeA" so the typecast is redundant. You can remove it
+        c = a to ?
+        d = c to? TypeA  # .warning. The given expression is already a "TypeA", but nilable. You can use "to !" to remove the nilability or remove the redundant cast.
+        
+        ok = a to? TypeA?
+        e = c to? TypeA? # .warning. The given expression is already a "TypeA?" so the typecast is redundant. You can remove it.
+        CobraCore.noOp(a, b, c, d, ok, e)
+    
+        
+        s as String? = 'aoeu'
+        t = s to? String  # .warning. The given expression is already a "String", but nilable.
+
+        ba = B() to? A    # no warning here because casting to a more general type is a legit way to affect type inference
+        .compute(ba)      # just to use the variable to avoid a warning
+
+        u = 'aoeu' to? String?
+        t = u to? String  # .warning. The given expression is already a "String", but nilable. You can use "to !" to remove the nilability or remove the redundant cast.
+        assert t
+        
+        u2 = u to? String?  # .warning. The given expression is already a "String?" so the typecast is redundant. You can remove it.
+        assert u2  # just to use the variable to avoid a warning
+
+        
+    def compute(a as A?) is shared
+        pass
+
+class A
+    pass
+
+
+class B
+    inherits A  
+    pass
+    
+class TypeA
+    pass
+    

Developer/IntermediateReleaseNotes.text

@@ -392 +392 @@
 * Fixed: Cobra gives an inscrutable error message for numeric for-loops that have incompatible numeric types. ticket:165
 
 * Fixed: Improper codegen for static constructors. ticket:169
+
+* Fixed: to? should give warning if operation is redundant. ticket:76
+