Enable strong mode in DDC, fix all warnings/errors

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';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 265 matching lines @@
         return module;
     }
   }
 
   List<String> _getJSName(Element e) {
     if (findAnnotation(e.library, isPublicJSAnnotation) == null) {
       return null;
     }
 
     var libraryJSName = getAnnotationName(e.library, isPublicJSAnnotation);
-    var libraryPrefix = [];
+    var libraryPrefix = <String>[];
     if (libraryJSName != null && libraryJSName.isNotEmpty) {
       libraryPrefix.addAll(libraryJSName.split('.'));
     }
 
-    var elementJSName;
+    String elementJSName;
     if (findAnnotation(e, isPublicJSAnnotation) != null) {
       elementJSName = getAnnotationName(e, isPublicJSAnnotation) ?? '';
     }
     if (e is TopLevelVariableElement &&
         e.getter != null &&
         (e.getter.isExternal ||
             findAnnotation(e.getter, isPublicJSAnnotation) != null)) {
       elementJSName = getAnnotationName(e.getter, isPublicJSAnnotation) ?? '';
     }
     if (elementJSName == null) return null;
 
-    var elementJSParts = [];
+    var elementJSParts = <String>[];
     if (elementJSName.isNotEmpty) {
       elementJSParts.addAll(elementJSName.split('.'));
     } else {
       elementJSParts.add(e.name);
     }
 
     return libraryPrefix..addAll(elementJSParts);
   }
 
   JS.Expression _emitJSInterop(Element e) {
     var jsName = _getJSName(e);
     if (jsName == null) return null;
     var fullName = ['global']..addAll(jsName);
-    var access = _runtimeLibVar;
+    JS.Expression access = _runtimeLibVar;
     for (var part in fullName) {
       access = new JS.PropertyAccess(access, js.string(part));
     }
     return access;
   }
 
   /// Flattens blocks in [items] to a single list.
   ///
   /// This will not flatten blocks that are marked as being scopes.
   void _copyAndFlattenBlocks(
@@ skipping 357 matching lines @@
 
     JS.Expression className;
     if (classElem.typeParameters.isNotEmpty) {
       // Generic classes will be defined inside a function that closes over the
       // type parameter. So we can use their local variable name directly.
       className = new JS.Identifier(classElem.name);
     } else {
       className = _emitTopLevelName(classElem);
     }
 
-    var allFields = new List.from(fields)..addAll(staticFields);
+    var allFields = fields.toList()..addAll(staticFields);
     var superclasses = getSuperclasses(classElem);
     var virtualFields = <FieldElement, JS.TemporaryId>{};
     var virtualFieldSymbols = <JS.Statement>[];
     var staticFieldOverrides = new HashSet<FieldElement>();
     _registerPropertyOverrides(classElem, className, superclasses, allFields,
         virtualFields, virtualFieldSymbols, staticFieldOverrides);
 
     var classExpr = _emitClassExpression(classElem,
         _emitClassMethods(node, ctors, fields, superclasses, virtualFields),
         fields: allFields);
@@ skipping 229 matching lines @@
   /// conflicts.  They will be installed as extension methods on the underlying
   /// native type.
   List<JS.Method> _emitNativeFieldAccessors(FieldDeclaration node) {
     // TODO(vsm): Can this by meta-programmed?
     // E.g., dart.nativeField(symbol, jsName)
     // Alternatively, perhaps it could be meta-programmed directly in
     // dart.registerExtensions?
     var jsMethods = <JS.Method>[];
     if (!node.isStatic) {
       for (var decl in node.fields.variables) {
-        var field = decl.element;
+        var field = decl.element as FieldElement;
         var name = getAnnotationName(field, isJsName) ?? field.name;
         // Generate getter
         var fn = new JS.Fun([], js.statement('{ return this.#; }', [name]));
         var method =
             new JS.Method(_elementMemberName(field.getter), fn, isGetter: true);
         jsMethods.add(method);
 
         // Generate setter
         if (!decl.isFinal) {
           var value = new JS.TemporaryId('value');
@@ skipping 381 matching lines @@
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       List<JS.Statement> body) {
     if (_extensionTypes.hasNativeSubtype(classElem.type)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, useExtension: false));
         }
       }
-      for (var f in fields) {
-        if (!f.isStatic) {
-          for (var d in f.fields.variables) {
-            if (d.element.isPublic) {
-              dartxNames.add(
-                  _elementMemberName(d.element.getter, useExtension: false));
+      for (var fieldDecl in fields) {
+        if (!fieldDecl.isStatic) {
+          for (var field in fieldDecl.fields.variables) {
+            var e = field.element as FieldElement;
+            if (e.isPublic) {
+              dartxNames.add(_elementMemberName(e.getter, useExtension: false));
             }
           }
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
   }
@@ skipping 165 matching lines @@
     if (jsSuper != null) body.add(jsSuper);
 
     body.add(_visit(node.body));
     return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     var ctor = node.staticElement;
-    var cls = ctor.enclosingElement as ClassElement;
+    var cls = ctor.enclosingElement;
     // We can't dispatch to the constructor with `this.new` as that might hit a
     // derived class constructor with the same name.
     return js.statement('#.prototype.#.call(this, #);', [
       new JS.Identifier(cls.name),
       _constructorName(ctor),
       _visit(node.argumentList)
     ]);
   }
 
   JS.Statement _superConstructorCall(ClassElement element,
@@ skipping 283 matching lines @@
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     // If we have a getter/setter pair, they need to be defined together.
     if (node.isGetter) {
       PropertyAccessorElement element = node.element;
       var props = <JS.Method>[_emitTopLevelProperty(node)];
       var setter = element.correspondingSetter;
       if (setter != null) {
-        props.add(_loader.emitDeclaration(setter, _emitTopLevelProperty));
+        props.add(_loader.emitDeclaration(
+            setter, (node) => _emitTopLevelProperty(node)));

[Leaf, 2016/05/26 17:53:37]

Annoying.  I guess alternatively emitDeclaration could take a second type
parameter for the type of the node that the function accepts and do the cast
internally to it.  Not sure that's better though.

[Jennifer Messerly, 2016/05/26 18:11:48]

yeah, that was my thought too. Seems like either way the cast is necessary.

       }
       return js.statement('dart.copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
     }
     if (node.isSetter) {
       PropertyAccessorElement element = node.element;
       var props = <JS.Method>[_emitTopLevelProperty(node)];
       var getter = element.correspondingGetter;
       if (getter != null) {
-        props.add(_loader.emitDeclaration(getter, _emitTopLevelProperty));
+        props.add(_loader.emitDeclaration(
+            getter, (node) => _emitTopLevelProperty(node)));
       }
       return js.statement('dart.copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
     }
 
     var body = <JS.Statement>[];
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
@@ skipping 104 matching lines @@
   @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) {
     JS.Fun f = _emitFunctionBody(node.element, node.parameters, node.body);
-    var body = f.body;
+    JS.Node body = f.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;
       }
     }
 
     // Convert `function(...) { ... }` to `(...) => ...`
     // This is for readability, but it also ensures correct `this` binding.
     var fn = new JS.ArrowFun(f.params, body,
         typeParams: f.typeParams, returnType: f.returnType);
 
-    return annotate(_makeGenericFunction(fn), node);
+    return annotate(_makeGenericArrowFun(fn), node);
   }
 
-  JS.FunctionExpression/*=T*/ _makeGenericFunction
-  /*<T extends JS.FunctionExpression>*/(JS.FunctionExpression/*=T*/ fn) {
+  JS.ArrowFun _makeGenericArrowFun(JS.ArrowFun fn) {
+    if (fn.typeParams == null || fn.typeParams.isEmpty) return fn;
+    return new JS.ArrowFun(fn.typeParams, fn);
+  }
+
+  JS.Fun _makeGenericFunction(JS.Fun fn) {
     if (fn.typeParams == null || fn.typeParams.isEmpty) return fn;
 
     // TODO(jmesserly): we could make these default to `dynamic`.
-    var typeParams = fn.typeParams;
-    if (fn is JS.ArrowFun) {
-      return new JS.ArrowFun(typeParams, fn);
-    }
-    var f = fn as JS.Fun;
     return new JS.Fun(
-        typeParams,
+        fn.typeParams,
         new JS.Block([
           // Convert the function to an => function, to ensure `this` binding.
-          new JS.Return(new JS.ArrowFun(f.params, f.body,
-              typeParams: f.typeParams, returnType: f.returnType))
+          new JS.Return(new JS.ArrowFun(fn.params, fn.body,
+              typeParams: fn.typeParams, returnType: fn.returnType))
         ]));
   }
 
   /// 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].
@@ skipping 53 matching lines @@
     // In the body of a `sync*` and `async`, `yield`/`await` are both generated
     // simply as `yield`.
     //
     // `async*` uses the `dart.asyncStar` helper, and also has an extra `stream`
     // argument to the generator, which is used for passing values to the
     // _AsyncStarStreamController implementation type.
     // `yield` is specially generated inside `async*`, see visitYieldStatement.
     // `await` is generated as `yield`.
     // runtime/_generators.js has an example of what the code is generated as.
     var savedController = _asyncStarController;
-    List jsParams = visitFormalParameterList(parameters);
+    var jsParams = visitFormalParameterList(parameters);
     if (kind == 'asyncStar') {
       _asyncStarController = new JS.TemporaryId('stream');
       jsParams.insert(0, _asyncStarController);
     } else {
       _asyncStarController = null;
     }
     var savedSuperAllowed = _superAllowed;
     _superAllowed = false;
     // Visit the body with our async* controller set.
     var jsBody = _visit(body);
@@ skipping 173 matching lines @@
       List<DartType> types, List<FormalParameter> parameters,
       {bool nameType: true, bool hoistType: true}) {
     var result = <JS.Expression>[];
     for (int i = 0; i < types.length; ++i) {
       var metadata =
           parameters != null ? _parameterMetadata(parameters[i]) : [];
       var typeName =
           _emitType(types[i], nameType: nameType, hoistType: hoistType);
       var value = typeName;
       if (options.emitMetadata && metadata.isNotEmpty) {
-        metadata = metadata.map(_instantiateAnnotation).toList();
-        value = new JS.ArrayInitializer([typeName]..addAll(metadata));
+        value = new JS.ArrayInitializer(
+            [typeName]..addAll(metadata.map(_instantiateAnnotation)));
       }
       result.add(value);
     }
     return new JS.ArrayInitializer(result);
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
@@ skipping 289 matching lines @@
 
     var target = _getTarget(node);
     if (target == null || isLibraryPrefix(target)) {
       return _emitFunctionCall(node);
     }
 
     return _emitMethodCall(target, node);
   }
 
   JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
-    List<JS.Expression> args = _visit(node.argumentList);
+    var args = _visit(node.argumentList) as List<JS.Expression>;
     var typeArgs = _emitInvokeTypeArguments(node);
 
     if (target is SuperExpression && !_superAllowed) {
       return _emitSuperHelperCall(typeArgs, args, target, node);
     }
 
     return _emitMethodCallInternal(target, node, args, typeArgs);
   }
 
   JS.Expression _emitSuperHelperCall(List<JS.Expression> typeArgs,
@@ skipping 61 matching lines @@
     jsTarget = new JS.PropertyAccess(jsTarget, memberName);
     if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
 
     return new JS.Call(jsTarget, args);
   }
 
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node) {
     var fn = _visit(node.function);
-    var args = _visit(node.argumentList);
+    var args = _visit(node.argumentList) as List<JS.Expression>;
     if (DynamicInvoke.get(node.function)) {
       var typeArgs = _emitInvokeTypeArguments(node);
       if (typeArgs != null) {
         return js.call('dart.dgcall(#, #, #)',
             [fn, new JS.ArrayInitializer(typeArgs), args]);
       } else {
         return js.call('dart.dcall(#, #)', [fn, args]);
       }
     } else {
       return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
@@ skipping 56 matching lines @@
     return f.typeArguments.skip(g.typeArguments.length);
   }
 
   /// Emits code for the `JS(...)` macro.
   _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;
+      List<AstNode> templateArgs;
       var source;
       if (code is StringInterpolation) {
         if (args.length > 2) {
           throw new ArgumentError(
               "Can't mix template args and string interpolation in JS calls.");
         }
         templateArgs = <Expression>[];
         source = code.elements.map((element) {
           if (element is InterpolationExpression) {
             templateArgs.add(element.expression);
             return '#';
           } else {
             return (element as InterpolationString).value;
           }
         }).join();
       } else {
-        templateArgs = args.skip(2);
+        templateArgs = args.skip(2).toList();
         source = (code as StringLiteral).stringValue;
       }
 
       // TODO(rnystrom): The JS() calls are almost never nested, and probably
       // really shouldn't be, but there are at least a couple of calls in the
       // HTML library where an argument to JS() is itself a JS() call. If those
       // go away, this can just assert(!_isInForeignJS).
       // Inside JS(), type names evaluate to the raw runtime type, not the
       // wrapped Type object.
       var wasInForeignJS = _isInForeignJS;
@@ skipping 1253 matching lines @@
     //   await iter.cancel();
     // }
     //
     // Like the Dart VM, we call cancel() always, as it's safe to call if the
     // stream has already been cancelled.
     //
     // TODO(jmesserly): we may want a helper if these become common. For now the
     // full desugaring seems okay.
     var streamIterator = rules.instantiateToBounds(_asyncStreamIterator);
     var createStreamIter = _emitInstanceCreationExpression(
-        streamIterator.element.unnamedConstructor,
+        (streamIterator.element as ClassElement).unnamedConstructor,
         streamIterator,
         null,
         AstBuilder.argumentList([node.iterable]),
         false);
     var iter = _visit(_createTemporary('it', streamIterator, nullable: false));
 
     var init = _visit(node.identifier);
     if (init == null) {
       init = js
           .call('let # = #.current', [node.loopVariable.identifier.name, iter]);
@@ skipping 275 matching lines @@
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     if (result is JS.Node) result = annotate(result, node);
     return result;
   }
 
   List/*<T>*/ _visitList/*<T extends AstNode>*/(Iterable/*<T>*/ nodes) {
     if (nodes == null) return null;
     var result = /*<T>*/ [];
-    for (var node in nodes) result.add(_visit(node));
+    for (var node in nodes) result.add(_visit(node) as dynamic/*=T*/);
     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);
   }
 
@@ skipping 112 matching lines @@
       // conflict. We could use practically any character for this.
       name = '+$name';
     }
 
     var result = _propertyName(name);
 
     if (useExtension == null) {
       // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
       var baseType = type;
       while (baseType is TypeParameterType) {
-        baseType = baseType.element.bound;
+        baseType = (baseType.element as TypeParameterElement).bound;
       }
       useExtension = baseType != null &&
           _extensionTypes.hasNativeSubtype(baseType) &&
           !isObjectMember(name);
     }
 
     return useExtension ? js.call('dartx.#', result) : result;
   }
 
   JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
@@ skipping 19 matching lines @@
     return _libraries[library] ??
         _imports.putIfAbsent(library,
             () => new JS.TemporaryId(jsLibraryName(_buildRoot, library)));
   }
 
   JS.Node/*=T*/ annotate/*<T extends JS.Node>*/(
       JS.Node/*=T*/ node, AstNode original,
       [Element element]) {
     if (options.closure && element != null) {
       node = node.withClosureAnnotation(closureAnnotationFor(
-          node, original, element, namedArgumentTemp.name));
+          node, original, element, namedArgumentTemp.name)) as dynamic/*=T*/;
     }
     return node..sourceInformation = original;
   }
 
   /// 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".
@@ skipping 107 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';