Ticket #52: dts-as-expr.patch

Source/Expr.cobra

@@ -794 +794 @@
         assert _what.type
         return _what.type.innerType
 
+class StringizeExpr # hops
+    is partial
+    inherits Expr
+    """
+    Turn an expression into something else, String, other expr (?)on code gen.
+    """
+    var _template as StringLit
+        # metachars [expr.str] = stringized expr,  [expr] = expression, [expr.tts] = toTechString(expr) 
+        # default is  '[expr.str]=[expr.tts]'
+    var _expr as Expr
 
+    def init(token as IToken, tmpl as StringLit, exp as Expr )
+        base.init(token)
+        _template = tmpl 
+        _expr = exp
+    
+    def addSubFields
+        base.addSubFields
+        .addField('template', _template)
+        .addField('expr', _expr)
+    
+    def _bindInt is override
+        if not _type
+            _type = .compiler.stringType
+        base._bindInt
+
+    def _bindImp is override
+        if not _type
+            _type = .compiler.stringType
+        base._bindImp
+        _expr.bindImp
+            
 class IdentifierExpr
     is partial
     inherits NameExpr

Source/SharpGenerator.cobra

@@ -3083 +3083 @@
             sw.dedent
             sw.write('})')
 
+class StringizeExpr #hops
+    is partial
 
+    def writeSharpDef(sw as SharpWriter)
+        base.writeSharpDef(sw)
+        sep = ', '
+        sw.write('CobraCore.Tracer.StrExpando(')
+        _template.writeSharpDef(sw, false)
+        sw.write('[sep][Utils.sharpStringLiteralFor(_expr.toCobraSource)][sep]') # stringized expr
+        _expr.writeSharpDef(sw, false) #expr
+        sw.write(')')
+
 class IdentifierExpr
     is partial
 

Source/CobraLang.cobra

@@ -93 +93 @@
                 if .willAutoFlush
                     _dest.flush
 
+        def strExpando(template as String, exprStr as String, expr as Object) as String
+            exprTTS = CobraImp._techStringMaker.makeString(expr)
+            outStr = template.replace(r'[expr.str]', exprStr)
+            outStr = outStr.replace(r'[expr]', expr.toString)
+            outStr = outStr.replace(r'[expr.tts]', exprTTS)
+            return outStr
+
+
     class Visitor
         is abstract
         """

Source/CobraParser.cobra

@@ -2732 +2732 @@
             on 'OPEN_CALL'
                 assert not callName.endsWith('(')
                 args = .commaSepExprs(['RPAREN'], true, true)
+                if callName == 'dTs'            # hops
+                    return .stringize(token, args)
                 if .opStack.count and .opStack.peek == 'DOT'
                     return CallExpr(token, callName, args, true)
                 else
@@ -2756 +2758 @@
             else
                 throw FallThroughException(token)               
 
+    def stringize(token as IToken, args as List<of Expr>) as Expr # hops
+        if args.count == 1
+            expr = args[0]
+            strTok = token.copy('STRING_SINGLE', r'[expr.str]=[expr.tts]')
+            strTok.value = strTok.text
+            tmpl = StringLit(strTok)
+        else if args.count == 2
+            tmpl = args[0] to StringLit
+            expr = args[1]
+        else
+            .throwError('dts pseudo method needs either 1 or 2 args')
+        return StringizeExpr(token, tmpl, expr)
+                    
     def argument as Expr
         """
         In support of .callExpr and others, for when it's legal to write `out x` and such.

Tests/200-misc/999-dts.cobra

@@ +1 @@
+# examples of dts pseudo function 
+#  
+# dts(strTemplate as String, expr) as String
+# OR
+# dts(expr) as String
+#   which is equivalent to dts(r'[expr.str]=[expr.tts]', expr) 
+#
+#   arg strTemplate is string containing text and placeholders for 
+#   various representations of the given expression
+# Supported placeholders are 
+# [expr] for the evaluated expression (as a string)
+# [expr.str] for the expression 'stringized' - the text of the expr as a string
+# [expr.tts] for the expression passed through CobraCore.toTechString
+#
+#   arg expr is any arbitrary cobra expression
+#
+class DTS
+    def main is shared
+        a=99
+        b=a+100-47
+        r = dTs(b)
+        #print r
+        assert r == 'b=152'
+        
+        r = dTs("valueIs[b]")
+        #print r
+        assert r == r'"valueIs[b]"='+"'valueIs152'"
+
+        r = dTs(a-44+3)
+        #print r
+        assert r == '((a - 44) + 3)=58'
+
+        x= {'a':100}
+        r = dTs(x)
+        #print r
+        assert r == "x=Dictionary<of String, int>{'a': 100}"
+        
+        # explicitly specify display template
+        r = dTs(r'expr is [expr.str] value=[expr]', b-a)
+        #print r
+        assert r=='expr is (b - a) value=53'