Roll analyzer to 0.27.2-alpha.1

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 487 matching lines @@
   }
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
   JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
 
     JS.Statement genericDef = null;
-    if (_boundTypeParametersOf(type).isNotEmpty) {
+    if (_typeFormalsOf(type).isNotEmpty) {
       genericDef = _emitGenericClassDef(type, body);
     }
     // The base class and all mixins must be declared before this class.
     if (!_loader.isLoaded(type.element)) {
       // TODO(jmesserly): the lazy class def is a simple solution for now.
       // We may want to consider other options in the future.
 
       if (genericDef != null) {
         return js.statement(
             '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }',
@@ skipping 11 matching lines @@
       var dynType = fillDynamicTypeArgs(type, types);
       var genericInst = _emitTypeName(dynType, lowerGeneric: true);
       return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
     }
     return body;
   }
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
-    var typeParams = _boundTypeParametersOf(type).map((p) => p.name);
+    var typeParams = _typeFormalsOf(type).map((p) => p.name);
     if (isPublic(name)) _exports.add(genericName);
     return js.statement('const # = dart.generic(function(#) { #; return #; });',
         [genericName, typeParams, body, name]);
   }
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
@@ skipping 998 matching lines @@
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
-    if (accessor is FunctionMember) element = accessor.baseElement;
 
     _loader.declareBeforeUse(element);
 
     // type literal
     if (element is ClassElement ||
         element is DynamicElementImpl ||
         element is FunctionTypeAliasElement) {
       return _emitTypeName(
           fillDynamicTypeArgs((element as dynamic).type, types));
     }
@@ skipping 1685 matching lines @@
   }
 
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
     return new JS.Expression.binary(
         _visitList(nodes) as List<JS.Expression>, operator);
   }
 
   /// Return the bound type parameters for a ParameterizedType
-  List<TypeParameterElement> _boundTypeParametersOf(ParameterizedType type) {
-    return (type is FunctionType)
-        ? type.boundTypeParameters
-        : type.typeParameters;
+  List<TypeParameterElement> _typeFormalsOf(ParameterizedType type) {
+    return type is FunctionType ? type.typeFormals : type.typeParameters;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
   JS.Expression _elementMemberName(ExecutableElement e,
       {bool allowExtensions: true}) {
     String name;
     if (e is PropertyAccessorElement) {
@@ skipping 273 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);
 }