upgrade to latest analyzer

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.
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/dart/ast/token.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
-import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
 import '../js/js_ast.dart' as JS;
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../compiler.dart'
     show AbstractCompiler, corelibOrder, getCorelibModuleName;
@@ skipping 70 matching lines @@
 
   final TypeProvider _types;
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
+  /// The current function body being compiled.
+  FunctionBody _currentFunction;
+
   /// The default value of the module object. See [visitLibraryDirective].
   String _jsModuleValue;
 
   bool _isDartRuntime;
 
   JSCodegenVisitor(AbstractCompiler compiler, this.rules, this.currentLibrary,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options.codegenOptions,
         _types = compiler.context.typeProvider {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
     _isDartRuntime = currentLibrary.source.uri.toString() == 'dart:_runtime';
   }
 
   TypeProvider get types => _types;
 
   JS.Program emitLibrary(LibraryUnit library) {
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, rules).reify();
 
-    // Build the public namespace for this library. This allows us to do
-    // constant time lookups (contrast with `Element.getChild(name)`).
-    if (currentLibrary.publicNamespace == null) {
-      (currentLibrary as LibraryElementImpl).publicNamespace =
-          new PublicNamespaceBuilder().build(currentLibrary);
-    }
-
     library.library.directives.forEach(_visit);
 
     var units = library.partsThenLibrary;
 
     // Rather than directly visit declarations, we instead use [_loader] to
     // visit them. It has the ability to sort elements on demand, so
     // dependencies between top level items are handled with a minimal
     // reordering of the user's input code. The loader will call back into
     // this visitor via [_emitModuleItem] when it's ready to visit the item
     // for real.
@@ skipping 952 matching lines @@
       // Mark the parameter as no-rename.
       body = js.statement('''{
         // Get the class name for this instance.
         let name = this.constructor.name;
         // Call the default constructor.
         let result = void 0;
         if (name in this) result = this[name](...arguments);
         return result === void 0 ? this : result;
       }''') as JS.Block;
     } else {
+      var savedFunction = _currentFunction;
+      _currentFunction = node.body;
       body = _emitConstructorBody(node, fields);
+      _currentFunction = savedFunction;
     }
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
     return annotate(
         new JS.Method(name, new JS.Fun(params, body, returnType: returnType)),
         node,
         node.element);
   }
@@ skipping 459 matching lines @@
   /// Contrast with [_emitFunction].
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     assert(node.parent is! FunctionDeclaration &&
         node.parent is! MethodDeclaration);
     return _emitFunctionTagged(_emitArrowFunction(node), getStaticType(node),
         topLevel: _executesAtTopLevel(node));
   }
 
   JS.ArrowFun _emitArrowFunction(FunctionExpression node) {
-    List<JS.Parameter> params;
+    JS.Fun f = _emitFunctionBody(node.element, node.parameters, node.body);
+    var body = f.body;
 
-    var body = node.body;
-    var type = node.element.type;
-
-    JS.Node jsBody;
-    if (body.isGenerator || body.isAsynchronous) {
-      params = visitFormalParameterList(node.parameters, destructure: false);
-      jsBody = _emitGeneratorFunctionBody(node.element, node.parameters, body);
-    } else {
-      params = visitFormalParameterList(node.parameters);
-
-      // Chrome Canary does not accept default values with destructuring in
-      // arrow functions yet (e.g. `({a} = {}) => 1`) but happily accepts them
-      // with regular functions (e.g. `function({a} = {}) { return 1 }`).
-      // Note that Firefox accepts both syntaxes just fine.
-      // TODO(ochafik): Simplify this code when Chrome Canary catches up.
-      bool destructureNamed = params.any((p) =>
-          p is JS.DestructuredVariable &&
-          p.structure is JS.ObjectBindingPattern);
-
-      if (body is ExpressionFunctionBody && !destructureNamed) {
-        // An arrow function can use the expression directly.
-        jsBody = _visit(body.expression);
-      } else {
-        jsBody = _visit(body);
+    // Simplify `=> { return e; }` to `=> e`
+    if (body is JS.Block) {
+      JS.Block block = body;
+      if (block.statements.length == 1) {
+        JS.Statement s = block.statements[0];
+        if (s is JS.Return) body = s.value;
       }
     }
 
-    var fn = new JS.ArrowFun(params, jsBody,
-        typeParams: _emitTypeFormals(type.typeFormals),
-        returnType: emitTypeRef(type.returnType));
-    return annotate(fn, node);
+    // Convert `function(...) { ... }` to `(...) => ...`
+    // This is for readability, but it also ensures correct `this` binding.
+    return annotate(
+        new JS.ArrowFun(f.params, body,
+            typeParams: f.typeParams, returnType: f.returnType),
+        node);
   }
 
   /// Emits a non-arrow FunctionExpression node.
   ///
   /// This should be used for all places in Dart's AST where FunctionExpression
   /// appears but the function is not actually in an Expression context, such
   /// as methods, properties, and top-level functions.
   ///
   /// Contrast with [visitFunctionExpression].
   JS.Fun _emitFunction(FunctionExpression node) {
@@ skipping 431 matching lines @@
     // 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 savedFunction = _currentFunction;
+    _currentFunction = node;
     var initArgs = _emitArgumentInitializers(node.parent);
     var ret = new JS.Return(_visit(node.expression));
+    _currentFunction = savedFunction;
     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 savedFunction = _currentFunction;
+    _currentFunction = node;
     var initArgs = _emitArgumentInitializers(node.parent);
     var stmts = _visitList(node.block.statements) as List<JS.Statement>;
     if (initArgs != null) stmts.insert(0, initArgs);
+    _currentFunction = savedFunction;
     return new JS.Block(stmts);
   }
 
   @override
   JS.Block visitBlock(Block node) =>
       new JS.Block(_visitList(node.statements) as List<JS.Statement>,
           isScope: true);
 
   @override
   visitMethodInvocation(MethodInvocation node) {
@@ skipping 714 matching lines @@
   ///
   /// 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;
+    if (isStateless(_currentFunction, expr, context)) return expr;
 
     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
@@ skipping 565 matching lines @@
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
           _visitList(node.elements) as List<JS.Expression>);
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
-      if (elementType != types.dynamicType) {
+      // TODO(jmesserly): analyzer will usually infer `List<Object>` because
+      // that is the least upper bound of the element types. So we rarely
+      // generate a plain `List<dynamic>` anymore.
+      if (!elementType.isDynamic) {
         // dart.list helper internally depends on _interceptors.JSArray.
         _loader.declareBeforeUse(_jsArray);
         list = js.call('dart.list(#, #)', [list, _emitTypeName(elementType)]);
       }
       return list;
     }
     if (node.constKeyword != null) return _emitConst(emitList);
     return emitList();
   }
 
@@ skipping 430 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);
 }