implement null aware ops, fixes #249

lib/src/codegen/js_codegen.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_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1177 matching lines @@
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
-    return new JS.Method(
-        _elementMemberName(node.element), _emitFunctionBody(params, node.body),
+    JS.Fun fn = _emitFunctionBody(params, node.body);
+    if (node.operatorKeyword != null &&
+        node.name.name == '[]=' &&
+        params.isNotEmpty) {
+      // []= methods need to return the value. We could also address this at
+      // call sites, but it's cleaner to instead transform the operator method.
+      var returnValue = new JS.Return(params.last);
+      var body = fn.body;
+      if (JS.Return.foundIn(fn)) {
+        // If a return is inside body, transform `(params) { body }` to
+        // `(params) { (() => { body })(); return value; }`.
+        // TODO(jmesserly): we could instead generate the return differently,
+        // and avoid the immediately invoked function.
+        body = new JS.Call(new JS.ArrowFun([], fn.body), []).toStatement();
+      }
+      // Rewrite the function to include the return.
+      fn = new JS.Fun(fn.params, new JS.Block([body, returnValue]))
+        ..sourceInformation = fn.sourceInformation;
+    }
+
+    return new JS.Method(_elementMemberName(node.element), fn,
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
@@ skipping 403 matching lines @@
     }
 
     return idTable.putIfAbsent(e, () => new JS.MaybeQualifiedId(libName, name));
   }
 
   @override
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
-    return _emitOpAssign(
-        left, right, node.operator.lexeme[0], node.staticElement,
-        context: node);
+    var op = node.operator.lexeme;
+    assert(op.endsWith('='));
+    op = op.substring(0, op.length - 1); // remove trailing '='
+    return _emitOpAssign(left, right, op, node.staticElement, context: node);
   }
 
   JS.MetaLet _emitOpAssign(
       Expression left, Expression right, String op, MethodElement element,
       {Expression context}) {
+    if (op == '??') {
+      // Desugar `l ??= r` as ((x) => x == null ? l = r : x)(l)
+      // Note that if `x` contains subexpressions, we need to ensure those
+      // are also evaluated only once. This is similar to desguaring for
+      // postfix expressions like `i++`.
+
+      // Handle the left hand side, to ensure each of its subexpressions are
+      // evaluated only once.
+      var vars = <String, JS.Expression>{};
+      var x = _bindLeftHandSide(vars, left, context: left);
+      // Capture the result of evaluating the left hand side in a temp.
+      var t = _bindValue(vars, 't', x, context: x);
+      return new JS.MetaLet(vars, [
+        js.call('# == null ? # : #', [_visit(t), _emitSet(x, right), _visit(t)])
+      ]);
+    }
+
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
     var vars = <String, JS.Expression>{};
     var lhs = _bindLeftHandSide(vars, left, context: context);
     var inc = AstBuilder.binaryExpression(lhs, op, right);
     inc.staticElement = element;
     inc.staticType = getStaticType(left);
     return new JS.MetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression lhs, Expression rhs) {
     if (lhs is IndexExpression) {
       var target = _getTarget(lhs);
       if (_useNativeJsIndexer(target.staticType)) {
         return js.call(
             '#[#] = #', [_visit(target), _visit(lhs.index), _visit(rhs)]);
       }
       return _emitSend(target, '[]=', [lhs.index, rhs]);
     }
 
     Expression target = null;
     SimpleIdentifier id;
     if (lhs is PropertyAccess) {
+      if (lhs.operator.lexeme == '?.') {
+        return _emitNullSafeSet(lhs, rhs);
+      }
+
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
     }
 
     if (target != null && DynamicInvoke.get(target)) {
       return js.call('dart.$DPUT(#, #, #)', [
         _visit(target),
         _emitMemberName(id.name, type: getStaticType(target)),
         _visit(rhs)
       ]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
+  JS.Expression _emitNullSafeSet(PropertyAccess node, Expression right) {
+    // Emit `obj?.prop = expr` as:
+    //
+    //     (_ => _ == null ? null : _.prop = expr)(obj).
+    //
+    // We could use a helper, e.g.:  `nullSafeSet(e1, _ => _.v = e2)`
+    //
+    // However with MetaLet, we get clean code in statement or void context,
+    // or when one of the expressions is stateless, which seems common.
+    var vars = <String, JS.Expression>{};
+    var left = _bindValue(vars, 'l', node.target);
+    var body = js.call('# == null ? null : #',
+        [_visit(left), _emitSet(_stripNullAwareOp(node, left), right)]);
+    return new JS.MetaLet(vars, [body]);
+  }
+
   @override
   JS.Block visitExpressionFunctionBody(ExpressionFunctionBody node) {
     var initArgs = _emitArgumentInitializers(node.parent);
     var ret = new JS.Return(_visit(node.expression));
     return new JS.Block(initArgs != null ? [initArgs, ret] : [ret]);
   }
 
   @override
   JS.Block visitEmptyFunctionBody(EmptyFunctionBody node) => new JS.Block([]);
 
   @override
   JS.Block visitBlockFunctionBody(BlockFunctionBody node) {
     var initArgs = _emitArgumentInitializers(node.parent);
     var block = visitBlock(node.block);
     if (initArgs != null) return new JS.Block([initArgs, block]);
     return block;
   }
 
   @override
   JS.Block visitBlock(Block node) =>
       new JS.Block(_visitList(node.statements) as List<JS.Statement>);
 
   @override
   visitMethodInvocation(MethodInvocation node) {
-    var target = node.isCascaded ? _cascadeTarget : node.target;
+    if (node.operator != null && node.operator.lexeme == '?.') {
+      return _emitNullSafe(node);
+    }
 
+    var target = _getTarget(node);
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     String code;
     if (target == null || isLibraryPrefix(target)) {
       if (DynamicInvoke.get(node.methodName)) {
         code = 'dart.$DCALL(#, #)';
       } else {
         code = '#(#)';
       }
@@ skipping 363 matching lines @@
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   bool _isNonNullableExpression(Expression expr) {
     // If the type is non-nullable, no further checking needed.
     if (rules.isNonNullableType(getStaticType(expr))) return true;
 
     // TODO(vsm): Revisit whether we really need this when we get
     // better non-nullability in the type system.
+    // TODO(jmesserly): we do recursive calls in a few places. This could
+    // leads to O(depth) cost for calling this function. We could store the
+    // resulting value if that becomes an issue, so we maintain the invariant
+    // that each node is visited once.
 
     if (expr is Literal && expr is! NullLiteral) return true;
     if (expr is IsExpression) return true;
     if (expr is ThisExpression) return true;
     if (expr is SuperExpression) return true;
     if (expr is ParenthesizedExpression) {
       return _isNonNullableExpression(expr.expression);
     }
     if (expr is SimpleIdentifier) {
       // Type literals are not null.
       Element e = expr.staticElement;
       if (e is ClassElement || e is FunctionTypeAliasElement) return true;
     }
     DartType type = null;
     if (expr is BinaryExpression) {
       switch (expr.operator.type) {
         case TokenType.EQ_EQ:
         case TokenType.BANG_EQ:
         case TokenType.AMPERSAND_AMPERSAND:
         case TokenType.BAR_BAR:
           return true;
+        case TokenType.QUESTION_QUESTION:
+          return _isNonNullableExpression(expr.rightOperand);
       }
       type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
       if (expr.operator.type == TokenType.BANG) return true;
       type = getStaticType(expr.operand);
     } else if (expr is PostfixExpression) {
       type = getStaticType(expr.operand);
     }
     if (type != null && _isJSBuiltinType(type)) {
       return true;
@@ skipping 47 matching lines @@
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else if (left is SuperExpression) {
         return _emitSend(left, op.lexeme, [right]);
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
     }
 
+    if (op.type.lexeme == '??') {
+      // TODO(jmesserly): leave RHS for debugging?
+      // This should be a hint or warning for dead code.
+      if (_isNonNullableExpression(left)) return _visit(left);
+
+      var vars = <String, JS.Expression>{};
+      // Desugar `l ?? r` as `l != null ? l : r`
+      var l = _visit(_bindValue(vars, 'l', left, context: left));
+      return new JS.MetaLet(vars, [
+        js.call('# != null ? # : #', [l, l, _visit(right)])
+      ]);
+    }
+
     if (binaryOperationIsPrimitive(leftType, rightType) ||
         rules.isStringType(leftType) && op.type == TokenType.PLUS) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         var div = AstBuilder.binaryExpression(left, '/', right)
           ..staticType = node.staticType;
@@ skipping 76 matching lines @@
           _bindValue(scope, 'i', index.index, context: context),
           index.rightBracket);
     } else if (expr is PropertyAccess) {
       PropertyAccess prop = expr;
       result = new PropertyAccess(
           _bindValue(scope, 'o', _getTarget(prop), context: context),
           prop.operator,
           prop.propertyName);
     } else if (expr is PrefixedIdentifier) {
       PrefixedIdentifier ident = expr;
+      if (isLibraryPrefix(ident.prefix)) {
+        return expr;
+      }
       result = new PrefixedIdentifier(
           _bindValue(scope, 'o', ident.prefix, context: context)
           as SimpleIdentifier,
           ident.period,
           ident.identifier);
     } else {
       return expr as SimpleIdentifier;
     }
     result.staticType = expr.staticType;
     DynamicInvoke.set(result, DynamicInvoke.get(expr));
     return result;
   }
 
   /// Creates a temporary to contain the value of [expr]. The temporary can be
   /// 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.
   ///
   /// [scope] will be mutated to contain the new temporary's initialization.
   Expression _bindValue(
       Map<String, JS.Expression> scope, String name, Expression expr,
       {Expression context}) {
     // No need to do anything for stateless expressions.
     if (isStateless(expr, context)) return expr;
 
-    var t = _createTemporary('#$name', expr.staticType);
+    var t = _createTemporary('#$name', getStaticType(expr));
     scope[name] = _visit(expr);
     return t;
   }
 
   /// Desugars postfix increment.
   ///
   /// In the general case [expr] can be one of [IndexExpression],
   /// [PrefixExpression] or [PropertyAccess] and we need to
   /// ensure sub-expressions are evaluated once.
   ///
@@ skipping 45 matching lines @@
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('$op#', _visit(expr));
       } else if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
-        var mathop = op.lexeme[0];
         var vars = <String, JS.Expression>{};
         var x = _bindLeftHandSide(vars, expr, context: expr);
-        var body = js.call('# = # $mathop 1', [_visit(x), notNull(x)]);
-        return new JS.MetaLet(vars, [body]);
+
+        var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
+        var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
+          ..staticElement = node.staticElement
+          ..staticType = getStaticType(expr);
+
+        return new JS.MetaLet(vars, [_emitSet(x, increment)]);
       } else {
         return js.call('$op#', notNull(expr));
       }
     }
 
     if (op.lexeme == '++' || op.lexeme == '--') {
       // Increment or decrement requires expansion.
       // Desugar `++x` as `x = x + 1`, ensuring that if `x` has subexpressions
       // (for example, x is IndexExpression) we evaluate those once.
       var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
@@ skipping 39 matching lines @@
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (isLibraryPrefix(node.prefix)) {
       return _visit(node.identifier);
     } else {
       return _emitGet(node.prefix, node.identifier);
     }
   }
 
   @override
-  visitPropertyAccess(PropertyAccess node) =>
-      _emitGet(_getTarget(node), node.propertyName);
+  visitPropertyAccess(PropertyAccess node) {
+    if (node.operator.lexeme == '?.') {
+      return _emitNullSafe(node);
+    }
+    return _emitGet(_getTarget(node), node.propertyName);
+  }
+
+  JS.Expression _emitNullSafe(Expression node) {
+    // Desugar ?. sequence by passing a sequence of callbacks that applies
+    // each operation in sequence:
+    //
+    //     obj?.foo()?.bar
+    // -->
+    //     nullSafe(obj, _ => _.foo(), _ => _.bar);
+    //
+    // This pattern has the benefit of preserving order, as well as minimizing
+    // code expansion: each `?.` becomes `, _ => _`, plus one helper call.

[vsm, 2015/08/25 21:47:26]

Very nice!

+    //
+    // TODO(jmesserly): we could desugar with MetaLet instead, which may
+    // lead to higher performing code, but at the cost of readability.
+    var tail = <JS.Expression>[];
+    for (;;) {
+      var op = _getOperator(node);
+      if (op != null && op.lexeme == '?.') {
+        var nodeTarget = _getTarget(node);
+        if (_isNonNullableExpression(nodeTarget)) {
+          node = _stripNullAwareOp(node, nodeTarget);
+          break;
+        }
+
+        var param = _createTemporary('_', nodeTarget.staticType);
+        var baseNode = _stripNullAwareOp(node, param);
+        tail.add(new JS.ArrowFun([_visit(param)], _visit(baseNode)));
+        node = nodeTarget;
+      } else {
+        break;
+      }
+    }
+    if (tail.isEmpty) return _visit(node);
+    return js.call('dart.nullSafe(#, #)', [_visit(node), tail.reversed]);
+  }
+
+  static Token _getOperator(Expression node) {
+    if (node is PropertyAccess) return node.operator;
+    if (node is MethodInvocation) return node.operator;
+    return null;
+  }
+
+  // TODO(jmesserly): this is dropping source location.
+  Expression _stripNullAwareOp(Expression node, Expression newTarget) {
+    if (node is PropertyAccess) {
+      return AstBuilder.propertyAccess(newTarget, node.propertyName);
+    } else {
+      var invoke = node as MethodInvocation;
+      return AstBuilder.methodInvoke(
+          newTarget, invoke.methodName, invoke.argumentList.arguments);
+    }
+  }
 
   bool _requiresStaticDispatch(Expression target, String memberName) {
     var type = getStaticType(target);
     if (!rules.objectMembers.containsKey(memberName)) {
       return false;
     }
     if (!type.isObject &&
         !_isJSBuiltinType(type) &&
         _isNonNullableExpression(target)) {
       return false;
@@ skipping 66 matching lines @@
       return new JS.PropertyAccess(_visit(target), _visit(node.index));
     }
     return _emitSend(target, '[]', [node.index]);
   }
 
   // TODO(jmesserly): ideally we'd check the method and see if it is marked
   // `external`, but that doesn't work because it isn't in the element model.
   bool _useNativeJsIndexer(DartType type) =>
       findAnnotation(type.element, _isJsNameAnnotation) != null;
 
-  /// Gets the target of a [PropertyAccess] or [IndexExpression].
-  /// Those two nodes are special because they're both allowed on left side of
-  /// an assignment expression and cascades.
+  /// Gets the target of a [PropertyAccess], [IndexExpression], or
+  /// [MethodInvocation]. These three nodes can appear in a [CascadeExpression].
   Expression _getTarget(node) {
-    assert(node is IndexExpression || node is PropertyAccess);
+    assert(node is IndexExpression ||
+        node is PropertyAccess ||
+        node is MethodInvocation);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
   @override
   visitConditionalExpression(ConditionalExpression node) {
     return js.call('# ? # : #', [
       notNull(node.condition),
       _visit(node.thenExpression),
       _visit(node.elseExpression)
     ]);
@@ skipping 548 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }