cleanup to Value - fix for StringEscapesTest

frog/await/transformation.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Desugarizes all await calls in a single function. This visitor assumes that
  * the tree is already normalized with [AwaitNormalizer]. For this reason it
  * only needs to recurse on statements and not on expressions. Like in
  * [AwaitChecker], nested functions have to be processed separately.
  */
@@ skipping 54 matching lines @@
   }
 
   visitFunctionDefinition(FunctionDefinition node) {
     if (!haveAwait.contains(node)) return node;
     // TODO(sigmund): consider making this part of the normalizer
     // make implicit return explicit:
     if (node.body is BlockStatement) {
       BlockStatement block = node.body;
       if (block.body.last() is! ReturnStatement) {
         continuation.addFirst(
-            _callCompleter(new NullExpression(node.span), node.span));
+            _callCompleter(_makeNull(node.span), node.span));
       }
     }
 
     Statement newBody = node.body.visit(this);
     // TODO(sigmund): extract type arg and put it in completer
     // We update the body in-place to make it easier to update nested functions
     // without having to rewrite the containing function's AST.
     node.body = new BlockStatement([
         _declareCompleter(null, node.span),
         _wrapInTryCatch(newBody, node == _mainMethod.definition),
@@ skipping 368 matching lines @@
         [new NewExpression(false, typeRef, null, [], span)],
         span);
     return def;
   }
 
   /**
    * Wrap [s] in a try-catch block that propagates errors through the future
    * that is returned from the asynchronous function. If the function that we
    * are generating is `main`, we add a noop listener on the resulting future.
    * Without it, we would have to make it illegal to use `await` in main. This
-   * is because futures swallow exceptions if their values are never used. 
+   * is because futures swallow exceptions if their values are never used.
    */
   Statement _wrapInTryCatch(Statement s, bool isMain) {
     final ex = new Identifier("ex", s.span);
     Statement catchStatement =
         _callCompleterException(new VarExpression(ex, ex.span), s.span);
     if (isMain) {
       final future = new DotExpression(
           new VarExpression(new Identifier(_COMPLETER_NAME, s.span), s.span),
           new Identifier("future", s.span), s.span);
       final noopHandler = new LambdaExpression(
@@ skipping 79 matching lines @@
 
   /** Make a statement invoking a function in scope. */
   Statement _callNoArg(String mName, SourceSpan span) {
     return new ExpressionStatement(new CallExpression(
         new VarExpression(new Identifier(mName, span), span), [], span), span);
   }
 
   /** Make the statement: [: target.method(value); :]. */
   Statement _callTarget1Arg(
       String target, String method, Expression value, SourceSpan span) {
-    if (value == null) value = new NullExpression(span);
+    if (value == null) value = _makeNull(span);
     return new ExpressionStatement(new CallExpression(
         new DotExpression(
             new VarExpression(new Identifier(target, span), span),
             new Identifier(method, span), span),
         [new ArgumentNode(null, value, value.span)], span), span);
   }
 
   /** Make the statement: [: f(value); :]. */
   Statement _call1Arg(String f, Expression value, SourceSpan span) {
-    if (value == null) value = new NullExpression(span);
+    if (value == null) value = _makeNull(span);
     return new ExpressionStatement(new CallExpression(
         new VarExpression(new Identifier(f, span), span),
         [new ArgumentNode(null, value, value.span)], span), span);
   }
 
   /** Make the statement: [: f(a, b); :]. */
   Statement _call2Args(String f, Expression a, Expression b,
       SourceSpan span) {
-    if (a == null) a = new NullExpression(span);
-    if (b == null) b = new NullExpression(span);
+    if (a == null) a = _makeNull(span);
+    if (b == null) b = _makeNull(span);
     return new ExpressionStatement(new CallExpression(
         new VarExpression(new Identifier(f, span), span),
         [new ArgumentNode(null, a, a.span),
          new ArgumentNode(null, b, b.span)], span), span);
   }
 
   /** Make a return statement for a boolean value. */
-  Statement _returnBoolean(SourceSpan span, value) {
-    return new ReturnStatement(new LiteralExpression(value,
-        new TypeReference(span, world.nonNullBool), "$value", span), span);
+  Statement _returnBoolean(SourceSpan span, bool value) {
+    return new ReturnStatement(
+      new LiteralExpression(Value.fromBool(value, span), span), span);
+  }
+
+  Expression _makeNull(SourceSpan span) {
+    return new LiteralExpression(Value.fromNull(span), span);
   }
 }
 
 // TODO(sigmund): create the following tests:
 // - await within the body of getter or setter properties
 // - await in each valid AST construct
 // - exceptions - make some of these fail and propagate errors.
 // - methods with and without returns (are returns added implicitly)
 // - await within assignmetns, but not declarations (see what happens with
 //      x = await t;
@@ skipping 10 matching lines @@
 //   if (a) if (b) await t; 2;
 //  becomes:
 //   if (a) { if (b) { await t; } } 2;
 //  which becomes becomes:
 //    _2() { 2; } if (a) { if (b) { t.then((_) { _2(); } } } _2();
 //  (seems that 'a' doesn't need { })
 // - 'if/while' with only one statement in the continuation (check the
 // optimization that copies code rather than adding a continuation closure).
 // - await not inside a block (could break error propagation if normalization is
 // done incorrectly).