Update 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.
 
 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;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.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 'package:analyzer/src/task/strong/rules.dart';
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
 // TODO(jmesserly): import from its own package
 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;
@@ skipping 22 matching lines @@
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 const ListEquality _listEquality = const ListEquality();
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ClosureAnnotator {
   final AbstractCompiler compiler;
   final CodegenOptions options;
-  final TypeRules rules;
   final LibraryElement currentLibrary;
+  final StrongTypeSystemImpl rules;
 
   /// The global extension type table.
   final HashSet<ClassElement> _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   ///
@@ skipping 31 matching lines @@
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
   /// The default value of the module object. See [visitLibraryDirective].
   String _jsModuleValue;
 
   bool _isDartUtils;
 
-  Map<String, DartType> _objectMembers;
-
   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');
     _isDartUtils = currentLibrary.source.uri.toString() == 'dart:_utils';
-
-    _objectMembers = getObjectMemberMap(types);
   }
 
-  TypeProvider get types => rules.provider;
+  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);
@@ skipping 184 matching lines @@
   bool isPublic(String name) => !name.startsWith('_');
 
   @override
   visitAsExpression(AsExpression node) {
     var from = getStaticType(node.expression);
     var to = node.type.type;
 
     var fromExpr = _visit(node.expression);
 
     // Skip the cast if it's not needed.
-    if (rules.isSubTypeOf(from, to)) return fromExpr;
+    if (rules.isSubtypeOf(from, to)) return fromExpr;
 
     // All Dart number types map to a JS double.
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
       if (from != _types.intType && to == _types.intType) {
         return js.call('dart.asInt(#)', [fromExpr]);
       }
 
       // A no-op in JavaScript.
       return fromExpr;
@@ skipping 190 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 (type.typeParameters.isNotEmpty) {
+    if (_boundTypeParametersOf(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: # }); }',
             [genericDef, _exportsVar, _propertyName(name), genericName]);
       }
 
       return js.statement(
           'dart.defineLazyClass(#, { get #() { #; return #; } });',
           [_exportsVar, _propertyName(name), body, name]);
     }
 
     if (isPublic(name)) _addExport(name);
 
     if (genericDef != null) {
       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 = type.typeParameters.map((p) => p.name);
+    var typeParams = _boundTypeParametersOf(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 13 matching lines @@
     if (type.isObject) return null;
 
     // Assume we can load eagerly, until proven otherwise.
     _loader.startTopLevel(element);
 
     // Find the super type
     JS.Expression heritage;
     var supertype = type.superclass;
     if (_deferIfNeeded(supertype, element)) {
       // Fall back to raw type.
-      supertype = fillDynamicTypeArgs(supertype.element.type, rules.provider);
+      supertype = fillDynamicTypeArgs(supertype.element.type, _types);
       _hasDeferredSupertype.add(element);
     }
     heritage = _emitTypeName(supertype);
 
     if (type.mixins.isNotEmpty) {
       var mixins = type.mixins.map(_emitTypeName).toList();
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
 
@@ skipping 157 matching lines @@
       var tStatics = <JS.Property>[];
       var tMethods = <JS.Property>[];
       var sNames = <JS.Expression>[];
       for (MethodDeclaration node in methods) {
         if (!(node.isSetter || node.isGetter || node.isAbstract)) {
           var name = node.name.name;
           var element = node.element;
           var inheritedElement =
               classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
           if (inheritedElement != null &&
-              inheritedElement.type == element.type) continue;
+              inheritedElement.type == element.type) {
+            continue;
+          }
           var memberName = _elementMemberName(element);
           var parts = _emitFunctionTypeParts(element.type);
           var property =
               new JS.Property(memberName, new JS.ArrayInitializer(parts));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else {
             tMethods.add(property);
           }
@@ skipping 111 matching lines @@
   /// `C() : super() {}`.
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node, List<FieldDeclaration> fields) {
     assert(_hasUnnamedConstructor(node.element) == fields.isNotEmpty);
 
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
     if (fields.isEmpty && superCall == null) return null;
 
     dynamic body = _initializeFields(node, fields);
-    if (superCall != null) body = [
-      [body, superCall]
-    ];
+    if (superCall != null) {
+      body = [
+        [body, superCall]
+      ];
+    }
     var name = _constructorName(node.element.unnamedConstructor);
     return annotateDefaultConstructor(
         new JS.Method(name, js.call('function() { #; }', body) as JS.Fun),
         node.element);
   }
 
   JS.Method _emitConstructor(ConstructorDeclaration node, InterfaceType type,
       List<FieldDeclaration> fields, bool isObject) {
     if (_externalOrNative(node)) return null;
 
@@ skipping 291 matching lines @@
           ]));
         }
       } else if (param.kind == ParameterKind.POSITIONAL) {
         body.add(js.statement('if (# === void 0) # = #;',
             [jsParam, jsParam, _defaultParamValue(param)]));
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/161
       var paramType = param.element.type;
-      if (!constructor && _hasTypeParameter(paramType)) {
-        body.add(js.statement(
-            'dart.as(#, #);', [jsParam, _emitTypeName(paramType)]));
+      if (!constructor && _hasUnsoundTypeParameter(paramType)) {
+        body.add(js
+            .statement('dart.as(#, #);', [jsParam, _emitTypeName(paramType)]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
-  bool _hasTypeParameter(DartType t) => t is TypeParameterType ||
-      t is ParameterizedType && t.typeArguments.any(_hasTypeParameter);
+  bool _isUnsoundTypeParameter(DartType t) =>
+      t is TypeParameterType && t.element.enclosingElement is ClassElement;
+
+  bool _hasUnsoundTypeParameter(DartType t) =>
+      _isUnsoundTypeParameter(t) ||
+      t is ParameterizedType && t.typeArguments.any(_hasUnsoundTypeParameter);
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
@@ skipping 114 matching lines @@
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return annotate(
         new JS.Method(_propertyName(name), _visit(node.functionExpression),
             isGetter: node.isGetter, isSetter: node.isSetter),
         node.element);
   }
 
   bool _executesAtTopLevel(AstNode node) {
-    var ancestor = node.getAncestor((n) => n is FunctionBody ||
+    var ancestor = node.getAncestor((n) =>
+        n is FunctionBody ||
         (n is FieldDeclaration && n.staticKeyword == null) ||
         (n is ConstructorDeclaration && n.constKeyword == null));
     return ancestor == null;
   }
 
   bool _typeIsLoaded(DartType type) {
     if (type is FunctionType && (type.name == '' || type.name == null)) {
       return (_typeIsLoaded(type.returnType) &&
           type.optionalParameterTypes.every(_typeIsLoaded) &&
           type.namedParameterTypes.values.every(_typeIsLoaded) &&
@@ skipping 120 matching lines @@
     } else {
       _asyncStarController = null;
       jsParams = params;
     }
     JS.Expression gen = new JS.Fun(jsParams, _visit(body), isGenerator: true);
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
     _asyncStarController = savedController;
 
-    var T = _emitTypeName(rules.getExpectedReturnType(body));
+    var T = _emitTypeName(_getExpectedReturnType(body));
     return js.call('dart.#(#)', [
       kind,
       [gen, T]..addAll(params)
     ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
@@ skipping 25 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);
 
     var name = element.name;
 
     // type literal
     if (element is ClassElement ||
         element is DynamicElementImpl ||
         element is FunctionTypeAliasElement) {
       return _emitTypeName(
@@ skipping 136 matching lines @@
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
       var parts = _emitFunctionTypeParts(type as FunctionType);
       return js.call('dart.functionType(#)', [parts]);
     }
+    // For now, reify generic method parameters as dynamic
+    bool _isGenericTypeParameter(DartType type) =>
+        (type is TypeParameterType) &&
+        !(type.element.enclosingElement is ClassElement ||
+            type.element.enclosingElement is FunctionTypeAliasElement);
+
+    if (_isGenericTypeParameter(type)) {
+      return js.call('dart.dynamic');
+    }
 
     if (type is TypeParameterType) {
       return new JS.Identifier(name);
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       var isCurrentClass =
           args.isNotEmpty && _loader.isCurrentElement(type.element);
       Iterable jsArgs = null;
-      if (args.any((a) => a != types.dynamicType)) {
+      if (args
+          .any((a) => a != types.dynamicType && !_isGenericTypeParameter(a))) {
         jsArgs = args.map(_emitTypeName);
       } else if (lowerGeneric || isCurrentClass) {
         // When creating a `new S<dynamic>` we try and use the raw form
         // `new S()`, but this does not work if we're inside the same class,
         // because `S` refers to the current S<T> we are generating.
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _maybeQualifiedName(element, '$name\$');
         return js.call('#(#)', [genericName, jsArgs]);
@@ skipping 61 matching lines @@
     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 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);
       }
@@ skipping 65 matching lines @@
     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 = '#(#)';
       }
-      return js.call(
-          code, [_visit(node.methodName), _visit(node.argumentList)]);
+      return js
+          .call(code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     if (DynamicInvoke.get(target)) {
       code = 'dart.$DSEND(#, #, #)';
     } else if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically known target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       code = 'dart.$DCALL(#.#, #)';
     } else if (_requiresStaticDispatch(target, name)) {
-      assert(rules.objectMembers[name] is FunctionType);
       // Object methods require a helper for null checks.
       return js.call('dart.#(#, #)',
           [memberName, _visit(target), _visit(node.argumentList)]);
     } else {
       code = '#.#(#)';
     }
 
-    return js.call(
-        code, [_visit(target), memberName, _visit(node.argumentList)]);
+    return js
+        .call(code, [_visit(target), memberName, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (isInlineJS(e)) {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
       var code = args[1];
       var templateArgs;
@@ skipping 65 matching lines @@
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
   bool _isNamedParam(FormalParameter param) =>
       param.kind == ParameterKind.NAMED;
 
   /// We cannot destructure named params that clash with JS reserved names:
   /// see discussion in https://github.com/dart-lang/dev_compiler/issues/392.
   bool _isDestructurableNamedParam(FormalParameter param) =>
       _isNamedParam(param) &&
-          !invalidVariableName(param.identifier.name) &&
-          options.destructureNamedParams;
+      !invalidVariableName(param.identifier.name) &&
+      options.destructureNamedParams;
 
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) =>
       _emitFormalParameterList(node);
 
   List<JS.Parameter> _emitFormalParameterList(FormalParameterList node,
       {bool allowDestructuring: true}) {
     var result = <JS.Parameter>[];
 
     var namedVars = <JS.DestructuredVariable>[];
@@ skipping 151 matching lines @@
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) return _emitStaticField(node);
 
     var name = new JS.Identifier(node.name.name);
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
-  bool _isFinalJSDecl(AstNode field) => field is VariableDeclaration &&
+  bool _isFinalJSDecl(AstNode field) =>
+      field is VariableDeclaration &&
       field.isFinal &&
       _isJSInvocation(field.initializer);
 
   /// Emits a static or top-level field.
   JS.Statement _emitStaticField(VariableDeclaration field) {
     PropertyInducingElement element = field.element;
     assert(element.isStatic);
 
     bool eagerInit;
     JS.Expression jsInit;
@@ skipping 81 matching lines @@
             _findAccessor(element, getter: false)));
       }
     }
 
     JS.Expression objExpr = _exportsVar;
     var target = _lazyFields[0].element.enclosingElement;
     if (target is ClassElement) {
       objExpr = new JS.Identifier(target.type.name);
     }
 
-    return js.statement(
-        'dart.defineLazyProperties(#, { # });', [objExpr, methods]);
+    return js
+        .statement('dart.defineLazyProperties(#, { # });', [objExpr, methods]);
   }
 
   PropertyAccessorElement _findAccessor(VariableElement element,
       {bool getter}) {
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       return getter
           ? parent.getGetter(element.name)
           : parent.getSetter(element.name);
     }
@@ skipping 199 matching lines @@
       } else {
         // TODO(vsm): When do Dart ops not map to JS?
         code = '# $op #';
       }
       return js.call(code, [notNull(left), notNull(right)]);
     }
 
     return _emitSend(left, op.lexeme, [right]);
   }
 
-  /// If the type [t] is [int] or [double], returns [num].
+  /// If the type [t] is [int] or [double], or a type parameter
+  /// bounded by [int], [double] or [num] returns [num].
   /// Otherwise returns [t].
   DartType _canonicalizeNumTypes(DartType t) {
     var numType = types.numType;
-    if (t is InterfaceType && t.superclass == numType) return numType;
+    if (rules.isSubtypeOf(t, numType)) return numType;
     return t;
   }
 
   bool _canUsePrimitiveEquality(Expression left, Expression right) {
     if (_isNull(left) || _isNull(right)) return true;
 
     var leftType = _canonicalizeNumTypes(getStaticType(left));
     var rightType = _canonicalizeNumTypes(getStaticType(right));
     return _isJSBuiltinType(leftType) && leftType == rightType;
   }
@@ skipping 280 matching lines @@
       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)) {
+    if (!_isObjectProperty(memberName)) {
       return false;
     }
     if (!type.isObject &&
         !_isJSBuiltinType(type) &&
         _isNonNullableExpression(target)) {
       return false;
     }
     return true;
   }
 
@@ skipping 190 matching lines @@
     var createStreamIter = _emitInstanceCreationExpression(
         StreamIterator_T.element.unnamedConstructor,
         StreamIterator_T,
         null,
         AstBuilder.argumentList([node.iterable]),
         false);
     var iter = _visit(_createTemporary('it', StreamIterator_T));
 
     var init = _visit(node.identifier);
     if (init == null) {
-      init = js.call(
-          'let # = #.current', [node.loopVariable.identifier.name, iter]);
+      init = js
+          .call('let # = #.current', [node.loopVariable.identifier.name, iter]);
     } else {
       init = js.call('# = #.current', [init, iter]);
     }
     return js.statement(
         '{'
         '  let # = #;'
         '  try {'
         '    while (#) { #; #; }'
         '  } finally { #; }'
         '}',
         [
-      iter,
-      createStreamIter,
-      new JS.Yield(js.call('#.moveNext()', iter)),
-      init,
-      _visit(node.body),
-      new JS.Yield(js.call('#.cancel()', iter))
-    ]);
+          iter,
+          createStreamIter,
+          new JS.Yield(js.call('#.moveNext()', iter)),
+          init,
+          _visit(node.body),
+          new JS.Yield(js.call('#.cancel()', iter))
+        ]);
   }
 
   @override
   visitBreakStatement(BreakStatement node) {
     var label = node.label;
     return new JS.Break(label?.name);
   }
 
   @override
   visitContinueStatement(ContinueStatement node) {
@@ skipping 58 matching lines @@
   /// Visits the catch clause body. This skips the exception type guard, if any.
   /// That is handled in [_visitCatch].
   @override
   JS.Statement visitCatchClause(CatchClause node) {
     var body = <JS.Statement>[];
 
     var savedCatch = _catchParameter;
     if (node.catchKeyword != null) {
       var name = node.exceptionParameter;
       if (name != null && name != _catchParameter) {
-        body.add(js.statement(
-            'let # = #;', [_visit(name), _visit(_catchParameter)]));
+        body.add(js
+            .statement('let # = #;', [_visit(name), _visit(_catchParameter)]));
         _catchParameter = name;
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
         body.add(js.statement(
             'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
       }
     }
 
     body.add(
@@ skipping 167 matching lines @@
     return result;
   }
 
   /// 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;
+  }
+
   /// 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) {
       name = e.variable.name;
     } else {
@@ skipping 68 matching lines @@
       name = 'unary-';
     } else if (name == 'constructor' || name == 'prototype') {
       // This uses an illegal (in Dart) character for a member, avoiding the
       // conflict. We could use practically any character for this.
       name = '+$name';
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
     if (allowExtensions &&
         _extensionTypes.contains(type.element) &&
-        !_objectMembers.containsKey(name)) {
+        !_isObjectProperty(name)) {
       return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
   JS.Identifier _libraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
-  DartType getStaticType(Expression e) => rules.getStaticType(e);
+  DartType getStaticType(Expression e) =>
+      e.staticType ?? DynamicTypeImpl.instance;
 
   @override
   String getQualifiedName(TypeDefiningElement type) {
     JS.TemporaryId id = _imports[type.library];
     return id == null ? type.name : '${id.name}.${type.name}';
   }
 
   JS.Node annotate(JS.Node method, ExecutableElement e) =>
       options.closure && e != null
           ? method.withClosureAnnotation(
@@ skipping 15 matching lines @@
       options.closure && e != null
           ? node.withClosureAnnotation(closureAnnotationForTypeDef(e))
           : node;
 
   /// Returns true if this is any kind of object represented by `Number` in JS.
   ///
   /// In practice, this is 4 types: num, int, double, and JSNumber.
   ///
   /// JSNumber is the type that actually "implements" all numbers, hence it's
   /// a subtype of int and double (and num). It's in our "dart:_interceptors".
-  bool _isNumberInJS(DartType t) => rules.isSubTypeOf(t, _types.numType);
+  bool _isNumberInJS(DartType t) => rules.isSubtypeOf(t, _types.numType);
+
+  bool _isObjectGetter(String name) {
+    PropertyAccessorElement element = _types.objectType.element.getGetter(name);
+    return (element != null && !element.isStatic);
+  }
+
+  bool _isObjectMethod(String name) {
+    MethodElement element = _types.objectType.element.getMethod(name);
+    return (element != null && !element.isStatic);
+  }
+
+  bool _isObjectProperty(String name) {
+    return _isObjectGetter(name) || _isObjectMethod(name);
+  }
+
+  // TODO(leafp): Various analyzer pieces computed similar things.
+  // Share this logic somewhere?
+  DartType _getExpectedReturnType(FunctionBody body) {
+    FunctionType functionType;
+    var parent = body.parent;
+    if (parent is Declaration) {
+      functionType = (parent.element as dynamic)?.type;
+    } else {
+      assert(parent is FunctionExpression);
+      functionType = parent.staticType;
+    }
+    if (functionType == null) {
+      return DynamicTypeImpl.instance;
+    }
+    var type = functionType.returnType;
+
+    InterfaceType expectedType = null;
+    if (body.isAsynchronous) {
+      if (body.isGenerator) {
+        // Stream<T> -> T
+        expectedType = _types.streamType;
+      } else {
+        // Future<T> -> T
+        // TODO(vsm): Revisit with issue #228.
+        expectedType = _types.futureType;
+      }
+    } else {
+      if (body.isGenerator) {
+        // Iterable<T> -> T
+        expectedType = _types.iterableType;
+      } else {
+        // T -> T
+        return type;
+      }
+    }
+    if (type.isDynamic) {
+      return type;
+    } else if (type is InterfaceType && type.element == expectedType.element) {
+      return type.typeArguments[0];
+    } else {
+      // TODO(leafp): The above only handles the case where the return type
+      // is exactly Future/Stream/Iterable.  Handle the subtype case.
+      return DynamicTypeImpl.instance;
+    }
+  }
 }
 
 class JSGenerator extends CodeGenerator {
   final _extensionTypes = new HashSet<ClassElement>();
-
-  JSGenerator(AbstractCompiler compiler) : super(compiler) {
+  final TypeProvider _types;
+  JSGenerator(AbstractCompiler compiler)
+      : _types = compiler.context.typeProvider,
+        super(compiler) {
     // TODO(jacobr): determine the the set of types with extension methods from
     // the annotations rather than hard coding the list once the analyzer
     // supports summaries.
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     for (var t in ['JSArray', 'JSString', 'JSNumber', 'JSBool']) {
       _addExtensionType(interceptors.getType(t).type);
     }
     // TODO(jmesserly): manually add `int` and `double`
     // Unfortunately our current analyzer rejects "implements int".
     // Fix was landed, so we can remove this hack once we're updated:
     // https://github.com/dart-lang/sdk/commit/d7cd11f86a02f55269fc8d9843e7758ebeeb81c8
-    _addExtensionType(context.typeProvider.intType);
-    _addExtensionType(context.typeProvider.doubleType);
+    _addExtensionType(_types.intType);
+    _addExtensionType(_types.doubleType);
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
-    t = fillDynamicTypeArgs(t, rules.provider) as InterfaceType;
+    t = fillDynamicTypeArgs(t, _types) as InterfaceType;
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
   String generateLibrary(LibraryUnit unit) {
     // Clone the AST first, so we can mutate it.
     unit = unit.clone();
     var library = unit.library.element.library;
     var fields = findFieldsNeedingStorage(unit, _extensionTypes);
+    var rules = new StrongTypeSystemImpl();
     var codegen =
         new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
     var out = compiler.getOutputPath(library.source.uri);
     return writeJsLibrary(module, out,
         emitSourceMaps: options.emitSourceMaps,
         arrowFnBindThisWorkaround: options.arrowFnBindThisWorkaround);
   }
 }
 
@@ skipping 15 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);
 }