Ticket #161: ticket161.patch

Source/Expr.cobra

@@ -3068 +3068 @@
         else
             .compiler.warning(this, 'The given expression is already non-nilable so "to !" is redundant. You can remove it.') # TODO: needs test case
             _type = _expr.type
+
+
+class ChainedCompareExpr
+    is partial
+    inherits Expr
+        
+    var _items as List<of Expr>
+    var _operations as List<of String>
+    
+    cue init(opToken as IToken, items as List<of Expr>, operations as List<of String>)
+        require
+            # should not happen, there is an error in the compiler if this occurs
+            items.count == operations.count + 1
+            items.count > 2
+        body
+            base.init(opToken)
+            _items = List<of Expr>()
+            _operations = List<of String>()
+            _items = items
+            _operations = operations
+    
+    def _bindImp is override
+        base._bindImp
+        itemIndex = 1
+        for operation in _operations
+            _items[itemIndex - 1].bindImp
+            _items[itemIndex].bindImp
+            _willCompare(_items[itemIndex - 1], operation, _items[itemIndex])
+            itemIndex += 1
+        _type = .compiler.boolType
+        
+    def _willCompare(left as Expr, op as String, right as Expr) as bool
+        if left.type is nil or right.type is nil
+            assert .hasError
+            return false
+        leftType = left.type to !
+        rightType = right.type to !
+        innerMsg as String?
+        # cannot invoke .isAssignableTo directly on the types because if one is nilable and the other is not, you can get false, even though that doesn't apply for "is". So use isEquatableTo and isComparableTo
+        if op in ['EQ', 'NE', 'IS', 'ISNOT']
+            if not leftType.isEquatableTo(rightType)
+                innerMsg = if(op.startsWith('IS'), 'can never be identical', 'cannot be equated')
+            else if op in ['IS', 'ISNOT']
+                # Essentially "is" and "is not" are for reference types. Give a warning when used for value types.
+                if not leftType.isDynamicOrPassThrough and not rightType.isDynamicOrPassThrough
+                    opName = if(op=='IS', 'is', 'is not')
+                    altName = if(op=='IS', '==', '<>')
+                    if leftType inherits NilableType and rightType inherits NilType
+                        pass
+                    else if not leftType.isReference and not rightType.isReference
+                        .compiler.warning(this, 'Both the left and right sides of "[opName]" are value types ("[leftType.name]" and "[rightType.name]"), but "[opName]" applies to reference types. Use "[altName]" instead.')
+                    # interestingly, I don't think the following ever happen in practice...
+                    else if not leftType.isReference and not rightType.isNilableAndDescendantOf(leftType)
+                        .compiler.warning(this, 'The left side of "[opName]" is a value type ("[leftType.name]") while the right side is an incompatible reference type ("[rightType.name]").')
+                    else if not rightType.isReference and not leftType.isNilableAndDescendantOf(rightType)
+                        .compiler.warning(this, 'The right side of "[opName]" is a value type ("[rightType.name]") while the left side is an incompatible reference type ("[leftType.name]").')                     
+        else
+            if not leftType.isComparableTo(rightType)
+                innerMsg = 'cannot be compared'
+        if innerMsg
+            typeNames = if(left.type.name==right.type.name, 'type ("[left.type.name]")', 'types ("[left.type.name]" and "[right.type.name]")')
+            msg = 'The left and right sides of the "[.token.text]" expression [innerMsg] because of their [typeNames].'
+            if op == 'IS' and right.type.isDescendantOf(.compiler.typeType) # C#
+                msg += ' Maybe you should try "inherits" instead of "is".'
+            .throwError(msg)
+            return false
+        return true
+    
+    def toCobraSource as String is override
+        sb = StringBuilder(_items[0].toCobraSource)
+        sep = ' '       
+        for index in _operations.count
+            sb.append(sep)
+            branch _operations[index]
+                on 'EQ'
+                    sb.append('==')
+                on 'NE'
+                    sb.append('<>')
+                on 'GT'
+                    sb.append('>')
+                on 'LT'
+                    sb.append('<')
+                on 'GE'
+                    sb.append('>=')
+                on 'LE'
+                    sb.append('<=')
+                on 'IS'
+                    sb.append('is')
+                on 'ISNOT'
+                    sb.append('is not')
+            sb.append(sep)
+            sb.append(_items[index + 1].toCobraSource)
+        return sb.toString

Source/BackEndClr/SharpGenerator.cobra

@@ -4439 +4439 @@
             throw FallThroughException(op)
 
 
+class ChainedCompareExpr
+    is partial
+    
+    def writeSharpDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('(')
+        .writeSharpDef(sw)
+        if parens, sw.write(')')
+    
+    def writeSharpDef(sw as CurlyWriter) is override
+        sw.write('CobraLangInternal.CobraCore.ChainedComparison(')
+        _items[0].writeSharpDef(sw)
+        itemIndex = 1
+        for operation in _operations
+            sw.write(', "[operation]", ')
+            _items[itemIndex].writeSharpDef(sw)
+            itemIndex += 1
+        sw.write(')')
+
+
 class DotExpr
     is partial
 

Source/Cobra.Lang/CobraCore.cobra

@@ -499 +499 @@
                     for code in _htmlEncodes
                         s = s.replace(code[0], code[1])
                     return s
+            def singleCompare(left as dynamic, op as String, right as dynamic) as bool
+                returnValue = false
+                branch op
+                    on 'EQ'
+                        returnValue = (left == right)
+                    on 'NE'
+                        returnValue = (left <> right)
+                    on 'GT'
+                        returnValue = (left > right)
+                    on 'LT'
+                        returnValue = (left < right)
+                    on 'GE'
+                        returnValue = (left >= right)
+                    on 'LE'
+                        returnValue = (left <= right)
+                    on 'IS'
+                        returnValue = (left == right)
+                    on 'ISNOT'
+                        returnValue = (left <> right)
+                return returnValue
+            def chainedComparison(stuff as vari dynamic) as bool
+                returnValue = true
+                things = List<of dynamic>(stuff)
+                for index in 0 : things.count - 1 : 2
+                    returnValue = returnValue and .singleCompare(things[index], things[index + 1], things[index + 2])
+                    if not returnValue, return returnValue
+                return returnValue

Source/BinaryOpExpr.cobra

@@ -55 +55 @@
                 on 'IN' or 'NOTIN'
                     return InExpr(opToken, op, left, right)
                 on 'IS' or 'ISNOT' or 'EQ' or 'NE' or 'LT' or 'GT' or 'LE' or 'GE'
+                    if left inherits CompareExpr
+                        left.addComparison(op, right)
+                        return left
                     return CompareExpr(opToken, op, left, right)
                 on 'AND' or 'OR' or 'IMPLIES'
                     return BinaryBoolExpr(opToken, op, left, right)
@@ -528 +531 @@
         'IS': '==',
         'ISNOT': '!=',
     }
+    
+    var _items as List<of Expr>
+    var _operations as List<of String>
 
     cue init(opToken as IToken, op as String, left as Expr, right as Expr)
         base.init(opToken, op, left, right)
+        _items = List<of Expr>()
+        _items.add(left)
+        _items.add(right)
+        _operations = List<of String>()
+        _operations.add(op)
         if op == 'ISNOT' and .token.text == 'is'
             .token.text = 'is not'
 
+    def addComparison(op as String, right as Expr)
+        _operations.add(op)
+        _items.add(right)
+    
     def _bindImp
         base._bindImp
         _type = .compiler.boolType
+        if _items.count > 2
+            # this transformation is done so that the back ends handle chained comparisons differently than normal comparisons
+            cce = ChainedCompareExpr(.token, _items, _operations)
+            cce.bindImp
+            _transformTo(cce)
+            return
         if _left.type is nil or _right.type is nil
             assert .hasError
             return

Tests/320-misc-two/256-chained-comparison.cobra

@@ +1 @@
+class Test
+    
+    def main
+        assert 3 < 5 < 7
+        
+        assert not 3 < 10 < 7
+        
+        aLetter = 'b'
+        assert 'c' > aLetter <> 'q'
+        
+        assert "cobra" <= 'is' >= 'cool'
+        
+        a = 1 to dynamic?
+        b = 1 to dynamic
+        c = 1
+        d = 1 to ?
+        assert a == b == c == d >= 0 <= 76
+        
+        assert b.getType is c.getType is d.getType is not aLetter.getType
+        
+        fred = Stack<of int>()
+        fred.push(1)
+        fred.push(5)
+        fred.push(4)
+        fred.push(3)
+        assert fred.pop < fred.pop < fred.pop
+        
+ No newline at end of file

Tests/320-misc-two/258-chained-comparison-errors.cobra

@@ +1 @@
+class Test
+    
+    enum MyEnum
+        burrito
+        carne
+        chili
+        enchilada
+        flan
+        taco
+    
+    def main
+        result = 4 > MyEnum.carne == 'hi' # .error. cannot be compared
+        result = 'hi' > 4 <> MyEnum.carne # .error. cannot be compared
+        result = MyEnum.carne > 'hi' <> 4 # .error. cannot be compared
+        print result
+        
+ No newline at end of file