Ticket #339: nil-safe-deref-updated.patch

Source/Expr.cobra

@@ -1353 +1353 @@
     def setDefinition(value as INamedNode?)
         # cannot override definition with a set, because base does not do a set
         _definition = value
+        # override use detection for compiler generated variables - not being set under normal checks
+        if .isImplicit, _definition.isUsed = true
+            
 
     get canBeStatement as bool is override
         return _definition inherits Method
@@ -1778 +1781 @@
     def _bindImp is override
         base._bindImp
         assert .superNode inherits DotExpr
-        assert .binarySuperNode.op == 'DOT'
+        assert .binarySuperNode.op == 'DOT' or .binarySuperNode.op == 'QUESTION_DOT'
         assert .binarySuperNode.right is this
         left = .binarySuperNode.left
         if _definition is nil or _type is nil

Source/BinaryOpExpr.cobra

@@ -50 +50 @@
                     return AssignExpr(opToken, op, left, right)
                 on 'DOT'
                     return DotExpr(opToken, op, left, right)
+                on 'QUESTION_DOT'
+                # Convert nilSafe deref sequence to a sequence of cascaded non-nil coalesce assignments which have 
+                # the same effect but are a little tricky to code up correctly by hand.
+                    # AST generated uses implicit (and inferred) temporary nilSafeHelper variables prefixed 
+                    #  'tnsh' to capture each possibly-nil expression to deref.
+                    # There are two cases:
+                    # 1) simple binary 2 expr:  leftExpr?.rightExpr (like a?.b ) 
+                    #       becomes (tnsh0 = leftExpr) ! (tnsh1 = tnsh0.rightExpr)
+                    # 2) multiple cascaded  ( like from a?.b?.c...):
+                    #   at the ?. operator the first part is already partially converted from 1) above
+                    #       (so the bit before the '?.' is already an inverse-coalesce-expr):
+                    #   i.e (tnsh0 = a) ! (tnsh1 = b) ?. c ... 
+                    #   or more generally:   
+                    #       leftInverseCoalesceExpr ?. rightExpr  
+                    #   which becomes:  
+                    #       leftInverseCoalesceExpr ! (tnsh2 = tnsh1.rightExpr)
+                    #
+                    #   e.g a?.b?.c becomes (tnsh0 = a) ! (tnsh1 = b) ! (tnsh2 = tnsh1.c)
+                    #       a?.b?.c?.d becomes (tnsh0 = a) ! (tnsh1 = b) ! (tnsh2 = tnsh1.c) ! (tnsh3 = tnsh2.d)
+                    #
+                    bangToken = opToken.copy('BANG', '!')
+                    serNo = IdentifierExpr(opToken).serialNum                   
+                    tmpNameToken = opToken.copy('ID', 'tnsh_[serNo]' )  # tnsh = tmp nilsafe helper
+                    leftId = IdentifierExpr(tmpNameToken)               # new id to capture value of this expr tnsh0
+                    leftId.isImplicit = true        # variable is compiler generated
+                    assToken = opToken.copy('ASSIGN', '=')
+                    if left inherits InverseCoalesceExpr                  # previous InverseCoalesceExpr
+                        prevId = (left.right to AssignExpr).left          # tnsh1
+                        dotex = DotExpr(opToken, 'DOT', prevId, right)    # tnsh1.right
+                        rhs = AssignExpr(assToken, 'ASSIGN', leftId, dotex)   # tnsh2 = tnsh1.right
+                        ice = InverseCoalesceExpr(bangToken, 'BANG', left, rhs) # (<prev-ice>) ! (tnsh2 = tnsh1.right)
+                    else
+                        lhs = AssignExpr(assToken, 'ASSIGN', leftId, left)  #tnsh0 = left
+                        serNo = IdentifierExpr(opToken).serialNum           # for a different serNo
+                        rightId = IdentifierExpr(opToken.copy('ID', 'tnsh_[serNo]'))
+                        rightId.isImplicit = true
+                        rhs = AssignExpr(assToken, 'ASSIGN', rightId, DotExpr(opToken, 'DOT', leftId, right))  # tnsh1 = tnsh0.right
+                        ice = InverseCoalesceExpr(bangToken, 'BANG', lhs, rhs)  # tnsh0 = left ! tnsh1 = tnsh0.right
+                    return ice
                 on 'INHERITS' or 'IMPLEMENTS'
                     return InheritsExpr(opToken, op, left, right)
                 on 'IN' or 'NOTIN'
@@ -633 +672 @@
 
     cue init(opToken as IToken, op as String, left as Expr, right as Expr)
         require
-            op == 'DOT'
+            op == 'DOT' or op == 'QUESTION_DOT'
             right inherits IDotRightExpr 
         body
             base.init(opToken, op, left, right)
@@ -1043 +1082 @@
     cue init(opToken as IToken, op as String, left as Expr, right as Expr)
         base.init(opToken, op, left, right)
 
+    def addMinFields
+        base.addMinFields
+        .addField('left.toCobraSource', .left.toCobraSource)
+        .addField('right.toCobraSource', .right.toCobraSource)
+
     def _bindImp
         base._bindImp
         left, right = .left, .right

Source/Node.cobra

@@ -1155 +1155 @@
 
     def addMinFields
         .addField('name', .name)
+        .addField('isUsed', .isUsed)
         base.addMinFields
 
     get typeForIdentifier as IType is abstract

Source/CobraParser.cobra

@@ -2731 +2731 @@
             'LBRACKET':         80,
             'LPAREN':           80,
             'ARRAY_OPEN':       80,
+            'QUESTION_DOT':     80,
 
             'STARSTAR':         70,  # right associative
 
@@ -2910 +2911 @@
                         # support to expression. Ex: x to int  Ex: x to? Shape
                         right = .typeExpr to Expr
                         getTypeExprForRightHandSide = false
-                    else if op == 'DOT' and .peek.isKeyword
+                    else if (op == 'DOT' or op == 'QUESTION_DOT') and .peek.isKeyword
                         # support foo.bar where bar is a keyword. Ex: foo.this
                         right = MemberExpr(.grab) to Expr
-                    else if op == 'DOT' and _isHelpDirective(.peek)
+                    else if (op == 'DOT' or op == 'QUESTION_DOT') and _isHelpDirective(.peek)
                         # support foo.@help
                         left.isHelpRequested = true
                         op = ''  # cancel the creation of a new binary op expr
                         .grab
                     else
                         right = _continuedExpression(prec, opToken)
-                    if op == 'DOT' and not right inherits IDotRightExpr
+                    if (op == 'DOT' or op == 'QUESTION_DOT') and not right inherits IDotRightExpr
                         if left inherits StringLit or right inherits StringLit
                             sugg = ' Use plus "+", not dot ".", for string concatenation.'
                         else
@@ -3319 +3320 @@
         """
         nameToken = .idOrKeyword
         name = nameToken.text
-        if .opStack.count and .opStack.peek=='DOT'
+        if .opStack.count and (.opStack.peek=='DOT' or .opStack.peek=='QUESTION_DOT')
             return MemberExpr(nameToken)
         if .peek.which=='AS'
             return AsExpr(.grab, nameToken, .typeId)

Source/CobraTokenizer.cobra

@@ -239 +239 @@
             r'DOUBLE_LT_EQUALS      s   <<=',
             r'DOUBLE_GT_EQUALS      s   >>=',
 
+            r'QUESTION_DOT      s   ?.',
             r'QUESTION_EQUALS   s   ?=',
             r'BANG_EQUALS       s   !=',
         ]

Tests/320-misc-two/410-nil-safe/020-nil-safe.cobra

@@ +1 @@
+class NilSafe
+    var co as Company?
+    var co1 as Company?
+    var ccnil as Object?
+    
+    def main is shared
+        ns = NilSafe()
+        co = Company()
+        co.name ='H Die and Tool'
+        ns.co = co
+    
+        assert ns.co.name == co.name
+        name = ns.co ! ns.co.name ? 'x'
+        assert name == co.name 
+
+        name = ns.co1?.name ? 'no-Name?'
+        # name = (t=ns.co1) : t.name )
+        assert name == 'no-Name?'
+    
+        #name = (t=ns.co) ! t.name ? 'x'
+        #assert name == co.name 
+        
+        # inverse coalesce in similar form to what the ?. operator generates
+        ns1 as NilSafe?
+        name =  ((t0=ns1) ! (t1=t0.co1)) ! t1.name ? 'no.Name?'
+        assert name == 'no.Name?'
+        
+        # nilsafe deref ops
+        name =  ns1?.co1?.name ? 'no.Name?'
+        assert name == 'no.Name?'
+        
+    def x
+        pass
+    
+    invariant .ccnil == nil
+    
+class Company
+    var name as String?
+    
+    

Tests/320-misc-two/410-nil-safe/040-nil-safe-non-idempotent.cobra

@@ +1 @@
+# non idempotent: calls changing return values on each call
+class NilSafe
+    var co as Company?
+    var co1 as Company?
+    
+    def main is shared
+        ns = NilSafe()
+        co = Company()
+        co.name ='Hops Die and Tool'
+        ns.co = co
+    
+    
+        #print ns.co.chkCo ? 'chkFail'
+        #print ns.co.chkCo ? 'chkFail'
+        
+        # simplifid safe-deref using inverse coalesce ops
+        ns2 = ns to ?
+        r = ns2 ! ns2.co ! ns2.co.chkCo ? 'chkFail'
+        assert r == 'OK'
+        r = ns2 ! ns2.co ! ns2.co.chkCo ? 'chkFail'
+        assert r == 'chkFail'
+    
+        ns2 =NilSafe()
+        n = ns2.coCalc.name 
+        assert n == 'Synth1'
+        n = ns2.coCalc.name 
+        assert n == 'Synth2'
+        # ns2?.coCalc?.name
+        #n1 = ns2 ! ns2.coCalc ! ns2.coCalc.name  # simplified
+        n1 = (t=ns2) ! (t1=t.coCalc) ! t1.name    # similar to that generated by ?. op
+        assert n1 == 'Synth3'
+        ## ns2.coCalc?.name
+        n1 = ns2 ! (u=ns2.coCalc) ! u.name
+        assert n1 == 'Synth4'
+    
+        #
+        # same as above but using nilsafe deref op
+        #
+        n1 = ns2?.coCalc?.name
+        assert n1 == 'Synth5'
+        #print n1 
+        n1 = ns2.coCalc?.name
+        assert n1 == 'Synth6'
+        #print n1
+        
+    def coCalc as Company?
+        return .co1 ? Company(dname='Synth[Company.cnt]')
+
+class Company
+    shared
+        var cnt = 0
+    var name as String? =''
+    var n =0
+
+    set dname from name
+
+    cue init
+        base .init
+        Company.cnt += 1
+        
+    def chkCo as String?
+        n = .n
+        .n += 1
+        if n ==0, return 'OK'
+        return nil
+    
+    def chkN as int
+        n, .n = .n, .n+1
+        return n

Tests/320-misc-two/410-nil-safe/030-many-nil-safe.cobra

@@ +1 @@
+# cascaded nilsafe deref operators to a ridiculous depth, access and mutate
+class NilSafe
+    var co as Company?
+    var co1 as Company?
+    
+    def main is shared
+        ns = NilSafe()
+        co = Company()
+        co.name ='Die and Tool'
+        co.subsid = Company()
+        co.subsid.name = 'Just Tool'
+        ns.co = co
+        
+        assert ns.co.name == co.name
+        name = ns.co1?.name ? 'X?'
+        assert name == 'X?'
+        
+        n2=  ns.co1 ! ns.co1.name ? 'X!'
+        assert n2 == 'X!'
+    
+        ns1 as NilSafe?
+        name =  ns1?.co1?.name ? 'X?'
+        assert name == 'X?'
+        name = ns.co?.name ? 'X'
+        assert name == co.name
+        
+        ssname = ns.co?.subsid?.name ? 'X'
+        assert ssname == 'Just Tool'
+        ns.co?.subsid.subsid =Company()
+        ns.co.subsid.subsid.name= 'Justy'
+        ns1 = ns
+        name = ns1?.co?.subsid?.subsid?.name ? 'X'
+        assert name == 'Justy'
+        
+        ns1.co.subsid.subsid.name = nil
+        name = ns1?.co?.subsid?.subsid?.name ? 'X'
+        assert name == 'X'
+        ns1.co.subsid.subsid = nil
+        name = ns1?.co?.subsid?.subsid?.name ? 'X'
+        assert name == 'X'
+    
+        coX = ns.co?.subsid?.subsid ? co
+        assert coX.name == 'Die and Tool'
+    
+        coX1 = ns1?.co?.subsid?.subsid ? co
+        assert (coX1 to Company).name == 'Die and Tool'
+        
+class Company
+    var name as String?
+    var subsid as Company?
+    

Tests/320-misc-two/410-nil-safe/010-simple-nil-safe.cobra

@@ +1 @@
+class NilSafe
+    var co as Company?
+    var co1 as Company?
+    var ccnil as Object?
+    
+    def main is shared
+        ns = NilSafe()
+        co = Company()
+        co.name ='H Die and Tool'
+        ns.co = co
+    
+        assert ns.co.name == co.name
+        
+        # In each test pair below 
+        # first is a  nilsafe deref using hand created cascaded non nil coalesce expressions
+        #   indicating nilsafe deref is possible without using the specific operator
+        # second is the same check using nilsafe deref operator (less duplication and all round nicer)
+            
+        name = ns.co ! ns.co.name ? 'x'
+        assert name == co.name 
+
+        name = ns.co1?.name ? 'no-Name?'
+        assert name == 'no-Name?'
+        
+        n2=  ns.co1 ! ns.co1.name ? 'noName!'
+        assert n2 == 'noName!'
+    
+        ns1 as NilSafe?
+        name =  ns1?.co1?.name ? 'no.Name?'
+        assert name == 'no.Name?'
+        
+        n2 = ns1 ! ns1.co1 ! ns.co1.name ? 'no.Name!'
+        assert n2 == 'no.Name!'
+    
+        ns1 = NilSafe()
+        name =  ns1?.co1?.name ? 'no.Name-co?'
+        assert name == 'no.Name-co?'
+    
+        n2 = ns1 ! ns1.co1 ! ns1.co1.name ? 'no.Name-co!'
+        assert n2 == 'no.Name-co!'
+    
+        ns1.co1 = Company()
+        name =  ns1?.co1?.name ? 'no.Name-co-name?'
+        assert name == 'no.Name-co-name?'
+    
+        n2 = ns1 ! ns1.co1 ! ns1.co1.name ? 'no.Name-co-name!'
+        assert n2 == 'no.Name-co-name!'
+    
+        ns1.co1.name = 'xx'
+        name =  ns1?.co1?.name ? 'no.Name-co-name?'
+        assert name == 'xx'
+    
+    def x
+        pass
+    
+    invariant .ccnil == nil
+    
+class Company
+    var name as String?
+    
+