implement null aware ops, fixes #249

lib/src/codegen/js_metalet.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_metalet;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart';
 import 'package:dev_compiler/src/js/precedence.dart';
 
@@ skipping 23 matching lines @@
   /// used multiple times in the resulting expression. For example:
   /// `expr ** 2` could be compiled as `expr * expr`. The temporary scope will
   /// ensure `expr` is only evaluated once: `(x => x * x)(expr)`.
   ///
   /// If the expression does not end up using `x` more than once, or if those
   /// expressions can be treated as [stateless] (e.g. they are non-mutated
   /// variables), then the resulting code will be simplified automatically.
   final Map<String, Expression> variables;
 
   /// A list of expressions in the body.
-  /// Conceptually this is like a comma expression: the last value is returned.
+  /// The last value should represent the returned value.
   final List<Expression> body;
 
   /// True if the final expression in [body] can be skipped in [toStatement].
   final bool statelessResult;
 
   /// We run [toExpression] implicitly when the JS AST is visited, to get the
   /// transformation to happen before the tree is printed.
   /// This happens multiple times, so ensure the expression form is cached.
   Expression _expression;
 
@@ skipping 58 matching lines @@
   }
 
   Block toYieldStatement({bool star: false}) {
     var statements = body
         .map((e) =>
             e == body.last ? e.toYieldStatement(star: star) : e.toStatement())
         .toList();
     return _finishStatement(statements);
   }
 
-  accept(NodeVisitor visitor) => toExpression().accept(visitor);
+  accept(NodeVisitor visitor) {
+    // TODO(jmesserly): we special case vistors from js_ast.Template, because it
+    // doesn't know about MetaLet. Should we integrate directly?
+    if (visitor is InstantiatorGeneratorVisitor) {
+      return _templateVisitMetaLet(visitor);
+    } else if (visitor is InterpolatedNodeAnalysis) {
+      return visitor.visitNode(this);
+    } else {
+      return toExpression().accept(visitor);
+    }
+  }
 
   void visitChildren(NodeVisitor visitor) {
-    toExpression().visitChildren(visitor);
+    // TODO(jmesserly): we special case vistors from js_ast.Template, because it
+    // doesn't know about MetaLet. Should we integrate directly?
+    if (visitor is InterpolatedNodeAnalysis ||
+        visitor is InstantiatorGeneratorVisitor) {
+      variables.values.forEach((v) => v.accept(visitor));
+      body.forEach((v) => v.accept(visitor));
+    } else {
+      toExpression().visitChildren(visitor);
+    }
   }
 
   /// This generates as either a comma expression or a call.
   int get precedenceLevel => variables.isEmpty ? EXPRESSION : CALL;
 
+  /// Patch to pretend [Template] supports visitMetaLet.
+  Instantiator _templateVisitMetaLet(InstantiatorGeneratorVisitor visitor) {
+    var valueInstantiators = variables.values.map(visitor.visit);
+    var bodyInstantiators = body.map(visitor.visit);
+
+    return (args) => new MetaLet(
+        new Map.fromIterables(
+            variables.keys, valueInstantiators.map((i) => i(args))),
+        bodyInstantiators.map((i) => i(args)).toList(),
+        statelessResult: statelessResult);
+  }
+
   Expression _toInvokedFunction(Statement block) {
     var finder = new _YieldFinder();
     block.accept(finder);
     if (!finder.hasYield) {
       return new Call(new ArrowFun([], block), []);
     }
     // If we have a yield, it's more tricky. We'll create a `function*`, which
     // we `yield*` to immediately invoke. We also may need to bind this:
     Expression fn = new Fun([], block, isGenerator: true);
     if (finder.hasThis) fn = js.call('#.bind(this)', fn);
@@ skipping 60 matching lines @@
   ///     ((_) => _.addAll(result), _.add(2), result = _)([])
   ///
   MetaLet _simplifyAssignment(Identifier left, {bool isDeclaration: false}) {
     // See if the result value is a let* temporary variable.
     if (body.last is! InterpolatedExpression) return null;
 
     InterpolatedExpression last = body.last;
     String name = last.nameOrPosition;
     if (!variables.containsKey(name)) return null;
 
-    // Variables declared can't be used inside their initializer.
+    // Variables declared can't be used inside their initializer, so make
+    // sure we don't transform an assignment into an initializer.
+    // If this already was a declaration, then we know it's legal, so we can
+    // skip the check.
     if (!isDeclaration) {
       var finder = new _IdentFinder(left.name);
       for (var expr in body) {
         if (finder.found) break;
         expr.accept(finder);
       }
       // If the identifier was used elsewhere, bail, because we're going to
       // change the order of when the assignment happens.
       if (finder.found) return null;
     }
@@ skipping 56 matching lines @@
   }
 
   @override visitYield(Yield node) {
     if (!_nestedFunction) hasYield = true;
   }
 
   @override visitNode(Node node) {
     if (!hasYield) super.visitNode(node);
   }
 }