add checks needed for covariant generics, and List<E>

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;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 314 matching lines @@
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(node), _emitClassMethods(node, ctors, fields));
 
-    var body =
-        _finishClassMembers(classElem, classExpr, ctors, fields, staticFields);
+    String jsPeerName;
+    var jsPeer = getAnnotationValue(node, _isJsPeerInterface);
+    if (jsPeer != null) {
+      jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
+    }
+
+    var body = _finishClassMembers(
+        classElem, classExpr, ctors, fields, staticFields, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
-    var jsPeer = getAnnotationValue(node, _isJsPeerInterface);
-    if (jsPeer != null) {
-      var jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
-      if (jsPeerName != null) {
-        // This class isn't allowed to be lazy, because we need to set up
-        // the native JS type eagerly at this point.
-        // If we wanted to support laziness, we could defer the hookup until
-        // the end of the Dart library cycle load.
-        assert(!_lazyClass(type));
+    if (jsPeerName != null) {
+      // This class isn't allowed to be lazy, because we need to set up
+      // the native JS type eagerly at this point.
+      // If we wanted to support laziness, we could defer the hookup until
+      // the end of the Dart library cycle load.
+      assert(!_lazyClass(type));
 
-        // TODO(jmesserly): this copies the dynamic members.
-        // Probably fine for objects coming from JS, but not if we actually
-        // want to support construction of instances with generic types other
-        // than dynamic. See issue #154 for Array and List<E> related bug.
-        var copyMembers = js.statement(
-            'dart.registerExtension(dart.global.#, #);', [
-          _propertyName(jsPeerName),
-          classElem.name
-        ]);
-        return _statement([result, copyMembers]);
-      }
+      // TODO(jmesserly): this copies the dynamic members.
+      // Probably fine for objects coming from JS, but not if we actually
+      // want to support construction of instances with generic types other
+      // than dynamic. See issue #154 for Array and List<E> related bug.
+      var copyMembers = js.statement(
+          'dart.registerExtension(dart.global.#, #);', [
+        _propertyName(jsPeerName),
+        classElem.name
+      ]);
+      return _statement([result, copyMembers]);
     }
     return result;
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) =>
       _unimplementedCall("Unimplemented enum: $node").toStatement();
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
@@ skipping 224 matching lines @@
       jsMethods.add(new JS.Method(js.call('$_SYMBOL.iterator'), body));
     }
     return jsMethods.where((m) => m != null).toList(growable: false);
   }
 
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
   /// inside the ES6 `class { ... }` node.
   JS.Statement _finishClassMembers(ClassElement classElem,
       JS.ClassExpression cls, List<ConstructorDeclaration> ctors,
-      List<FieldDeclaration> fields, List<FieldDeclaration> staticFields) {
+      List<FieldDeclaration> fields, List<FieldDeclaration> staticFields,
+      String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
     body.add(new JS.ClassDeclaration(cls));
 
+    // TODO(jmesserly): we should really just extend native Array.
+    if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
+      body.add(js.statement('dart.setBaseClass(#, dart.global.#);', [
+        classElem.name,
+        _propertyName(jsPeerName)
+      ]));
+    }
+
     // Interfaces
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         name,
         new JS.ArrayInitializer(
             classElem.interfaces.map(_emitTypeName).toList())
       ]));
     }
 
     // Named constructors
@@ skipping 117 matching lines @@
         _visit(node.redirectedConstructor),
         _visit(node.parameters)
       ]);
     }
 
     var body = <JS.Statement>[];
 
     // Generate optional/named argument value assignment. These can not have
     // side effects, and may be used by the constructor's initializers, so it's
     // nice to do them first.
-    var init = _emitArgumentInitializers(node.parameters);
+    var init = _emitArgumentInitializers(node, constructor: true);
     if (init != null) body.add(init);
 
     // Redirecting constructors: these are not allowed to have initializers,
     // and the redirecting ctor invocation runs before field initializers.
     var redirectCall = node.initializers.firstWhere(
         (i) => i is RedirectingConstructorInvocation, orElse: () => null);
 
     if (redirectCall != null) {
       body.add(_visit(redirectCall));
       return new JS.Block(body);
@@ skipping 125 matching lines @@
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
       var access = _emitMemberName(e.name, type: e.enclosingElement.type);
       body.add(js.statement('this.# = #;', [access, initialValue]));
     });
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
-    // Note: ConstructorDeclaration is intentionally skipped here so we can
-    // emit the argument initializers in a different place.
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
     // lowering pass.
+    if (node is ConstructorDeclaration) return node.parameters;
     if (node is MethodDeclaration) return node.parameters;
     if (node is FunctionDeclaration) node = node.functionExpression;
-    if (node is FunctionExpression) return node.parameters;
-    return null;
+    return (node as FunctionExpression).parameters;
   }
 
-  bool _hasArgumentInitializers(FormalParameterList parameters) {
-    if (parameters == null) return false;
-    return parameters.parameters.any((p) => p.kind != ParameterKind.REQUIRED);
-  }
+  /// Emits argument initializers, which handles optional/named args, as well
+  /// as generic type checks needed due to our covariance.
+  JS.Statement _emitArgumentInitializers(node, {bool constructor: false}) {
+    // Constructor argument initializers are emitted earlier in the code, rather
+    // than always when we visit the function body, so we control it explicitly.
+    if (node is ConstructorDeclaration != constructor) return null;
 
-  JS.Statement _emitArgumentInitializers(FormalParameterList parameters) {
-    if (parameters == null || !_hasArgumentInitializers(parameters)) {
-      return null;
-    }
+    var parameters = _parametersOf(node);
+    if (parameters == null) return null;
 
     var body = [];
     for (var param in parameters.parameters) {
       var jsParam = _visit(param.identifier);
 
       if (param.kind == ParameterKind.NAMED) {
         // Parameters will be passed using their real names, not the (possibly
         // renamed) local variable.
         var paramName = js.string(param.identifier.name, "'");
         body.add(js.statement('let # = # && # in # ? #.# : #;', [
           jsParam,
           _namedArgTemp,
           paramName,
           _namedArgTemp,
           _namedArgTemp,
           paramName,
           _defaultParamValue(param),
         ]));
       } 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)]));
+      }
     }
-    return _statement(body);
+    return body.isEmpty ? null : _statement(body);
   }
 
+  bool _hasTypeParameter(DartType t) => t is TypeParameterType ||
+      t is ParameterizedType && t.typeArguments.any(_hasTypeParameter);
+
   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) {
     if (node.isAbstract || _externalOrNative(node)) {
@@ skipping 280 matching lines @@
         _emitMemberName(id.name, type: getStaticType(target)),
         _visit(rhs)
       ]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
   @override
   JS.Block visitExpressionFunctionBody(ExpressionFunctionBody node) {
-    var initArgs = _emitArgumentInitializers(_parametersOf(node.parent));
+    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(_parametersOf(node.parent));
+    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));
 
   @override
   visitMethodInvocation(MethodInvocation node) {
@@ skipping 288 matching lines @@
     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 Conversion) {
       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) {
       type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
       type = getStaticType(expr.operand);
     } else if (expr is PostfixExpression) {
       type = getStaticType(expr.operand);
     }
     if (type != null && _isJSBuiltinType(type)) {
       return true;
@@ skipping 940 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;