optimize null safe ops by using DDC's let abstraction

pkg/dev_compiler/lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 4677 matching lines @@
 
   @override
   visitPropertyAccess(PropertyAccess node) {
     if (node.operator.lexeme == '?.') {
       return _emitNullSafe(node);
     }
     return _emitAccess(_getTarget(node), node.propertyName, node.staticType);
   }
 
   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.
-    //
-    // 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 (!isNullable(nodeTarget)) {
-          node = _stripNullAwareOp(node, nodeTarget);
-          break;
-        }
-
-        var param = _createTemporary('_', nodeTarget.staticType,
-            nullable: false, dynamicInvoke: isDynamicInvoke(nodeTarget));
-        var baseNode = _stripNullAwareOp(node, param);
-        tail.add(
-            new JS.ArrowFun(<JS.Parameter>[_visit(param)], _visit(baseNode)));
-        node = nodeTarget;
-      } else {
-        break;
-      }
-    }
-    if (tail.isEmpty) return _visit(node);
-    return _callHelper(
-        'nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
+    // Desugar `obj?.name` as ((x) => x == null ? null : x.name)(obj)
+    var target = _getTarget(node);
+    var vars = <JS.MetaLetVariable, JS.Expression>{};
+    var t = _bindValue(vars, 't', target, context: target);
+    return new JS.MetaLet(vars, [
+      js.call('# == null ? null : #',
+          [_visit(t), _visit(_stripNullAwareOp(node, t))])
+    ]);
   }
 
   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) {
@@ skipping 1120 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }