some fixes for --strong warnings

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 104 matching lines @@
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, compiler).reify();
 
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var libraryDir = unit.directives.first;
       if (libraryDir is LibraryDirective) {
         var jsName = findAnnotation(libraryDir.element, _isJsNameAnnotation);
-        jsDefaultValue = getConstantField(jsName, 'name', types.stringType);
+        jsDefaultValue =
+            getConstantField(jsName, 'name', types.stringType) as String;
       }
     }
 
     // TODO(jmesserly): visit scriptTag, directives?
 
     _loader.collectElements(currentLibrary, library.partsThenLibrary);
 
     for (var unit in library.partsThenLibrary) {
       _constField = new ConstFieldVisitor(types, unit);
 
@@ skipping 41 matching lines @@
     // TODO(jmesserly): it would be great to run the renamer on the body,
     // then figure out if we really need each of these parameters.
     // See ES6 modules: https://github.com/dart-lang/dev_compiler/issues/34
     var params = [_exportsVar, _runtimeLibVar];
     var processImport = (LibraryElement library, JS.TemporaryId temp,
         List list) {
       params.add(temp);
       list.add(js.string(compiler.getModuleName(library.source.uri), "'"));
     };
 
-    var imports = [js.string('dart_runtime/dart')];
+    var imports = <JS.Expression>[js.string('dart_runtime/dart')];
     _imports.forEach((library, temp) {
       if (_loader.libraryIsLoaded(library)) {
         processImport(library, temp, imports);
       }
     });
 
-    var lazyImports = [];
+    var lazyImports = <JS.Expression>[];
     _imports.forEach((library, temp) {
       if (!_loader.libraryIsLoaded(library)) {
         processImport(library, temp, lazyImports);
       }
     });
 
     var dartxImport =
         js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
 
     var module = js.call("function(#) { 'use strict'; #; #; }", [
       params,
       dartxImport,
       _moduleItems
     ]);
 
-    var program = [
+    var program = <JS.Statement>[
       js.statement("dart_library.library(#, #, #, #, #)", [
         js.string(jsPath, "'"),
         jsDefaultValue != null ? jsDefaultValue : new JS.LiteralNull(),
         js.commentExpression(
             "Imports", new JS.ArrayInitializer(imports, multiline: true)),
         js.commentExpression("Lazy imports",
             new JS.ArrayInitializer(lazyImports, multiline: true)),
         module
       ])
     ];
@@ skipping 97 matching lines @@
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     var element = node.element;
 
     // Forward all generative constructors from the base class.
-    var body = [];
+    var body = <JS.Method>[];
 
     var supertype = element.supertype;
     if (!supertype.isObject) {
       for (var ctor in element.constructors) {
         var parentCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
         var fun = js.call('function() { super.#(...arguments); }',
-            [_constructorName(parentCtor)]);
+            [_constructorName(parentCtor)]) as JS.Fun;
         body.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
     var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
         new JS.Identifier(element.name), _classHeritage(element), body));
 
     return _finishClassDef(element.type, classDecl);
   }
 
@@ skipping 31 matching lines @@
         methods.add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, _isJsPeerInterface);
     if (jsPeer != null) {
-      jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
+      jsPeerName = getConstantField(jsPeer, 'name', types.stringType) as String;
     }
 
     var body = _finishClassMembers(classElem, classExpr, ctors, fields, methods,
         node.metadata, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
     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.
@@ skipping 19 matching lines @@
   JS.Statement visitEnumDeclaration(EnumDeclaration node) {
     var element = node.element;
     var type = element.type;
     var name = js.string(type.name);
     var id = new JS.Identifier(type.name);
 
     // Generate a class per section 13 of the spec.
     // TODO(vsm): Generate any accompanying metadata
 
     // Create constructor and initialize index
-    var constructor =
-        new JS.Method(name, js.call('function(index) { this.index = index; }'));
+    var constructor = new JS.Method(
+        name, js.call('function(index) { this.index = index; }') as JS.Fun);
     var fields = new List<ConstFieldElementImpl>.from(
         element.fields.where((f) => f.type == type));
 
     // Create toString() method
     var properties = new List<JS.Property>();
     for (var i = 0; i < fields.length; ++i) {
       properties.add(new JS.Property(
           js.number(i), js.string('${type.name}.${fields[i].name}')));
     }
     var nameMap = new JS.ObjectInitializer(properties, multiline: true);
     var toStringF = new JS.Method(js.string('toString'),
-        js.call('function () { return #[this.index]; }', nameMap));
+        js.call('function() { return #[this.index]; }', nameMap) as JS.Fun);
 
     // Create enum class
     var classExpr = new JS.ClassExpression(
         id, _classHeritage(element), [constructor, toStringF]);
-    var result = [js.statement('#', classExpr)];
+    var result = <JS.Statement>[js.statement('#', classExpr)];
 
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
       result.add(js.statement('#.# = dart.const(new #(#));', [
         id,
         fields[i].name,
         id,
         js.number(i)
       ]));
     }
 
     // Create static values list
-    var values = new JS.ArrayInitializer(
-        fields.map((f) => js.call('#.#', [id, f.name])).toList());
+    var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
+        fields.map((f) => js.call('#.#', [id, f.name]))));
     result.add(js.statement('#.values = dart.const(dart.list(#, #));', [
       id,
       values,
       _emitTypeName(type)
     ]));
 
     return _statement(result);
   }
 
   /// Given a class element and body, complete the class declaration.
@@ skipping 134 matching lines @@
     // simple code size optimization.
     var parent = t.lookUpGetterInSuperclass('iterator', t.element.library);
     if (parent != null) return null;
     var parentType = findSupertype(t, _implementsIterable);
     if (parentType != null) return null;
 
     // Otherwise, emit the adapter method, which wraps the Dart iterator in
     // an ES6 iterator.
     return new JS.Method(js.call('$_SYMBOL.iterator'), js.call(
         'function() { return new dart.JsIterator(this.#); }',
-        [_emitMemberName('iterator', type: t)]));
+        [_emitMemberName('iterator', type: t)]) as JS.Fun);
   }
 
   JS.Expression _instantiateAnnotation(Annotation node) {
     var element = node.element;
     if (element is ConstructorElement) {
       return _emitInstanceCreationExpression(element, element.returnType,
           node.constructorName, node.arguments, true);
     } else {
       return _visit(node.name);
     }
   }
 
   /// 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<MethodDeclaration> methods,
       List<Annotation> metadata, String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (_extensionTypes.contains(classElem)) {
-      var dartxNames = [];
+      var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
 
     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())
+        new JS.ArrayInitializer(new List<JS.Expression>.from(
+            classElem.interfaces.map(_emitTypeName)))
       ]));
     }
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);', [
           name,
           _emitMemberName(member.name.name, isStatic: true)
         ]));
       }
     }
 
     // Instance fields, if they override getter/setter pairs
     for (FieldDeclaration member in fields) {
       for (VariableDeclaration fieldDecl in member.fields.variables) {
-        var field = fieldDecl.element;
+        var field = fieldDecl.element as FieldElement;
         if (_fieldsNeedingStorage.contains(field)) {
           body.add(_overrideField(field));
         }
       }
     }
 
     // Emit the signature on the class recording the runtime type information
     {
-      var tStatics = [];
-      var tMethods = [];
-      var sNames = [];
+      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;
           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);
           }
         }
       }
 
-      var tCtors = [];
+      var tCtors = <JS.Property>[];
       for (ConstructorDeclaration node in ctors) {
         var memberName = _constructorName(node.element);
         var element = node.element;
         var parts = _emitFunctionTypeParts(element.type);
         var property =
             new JS.Property(memberName, new JS.ArrayInitializer(parts));
         tCtors.add(property);
       }
 
-      build(name, elements) {
+      JS.Property build(String name, List<JS.Property> elements) {
         var o =
             new JS.ObjectInitializer(elements, multiline: elements.length > 1);
         var e = js.call('() => #', o);
-        var p = new JS.Property(_propertyName(name), e);
-        return p;
+        return new JS.Property(_propertyName(name), e);
       }
-      var sigFields = [];
+      var sigFields = <JS.Property>[];
       if (!tCtors.isEmpty) sigFields.add(build('constructors', tCtors));
       if (!tMethods.isEmpty) sigFields.add(build('methods', tMethods));
       if (!tStatics.isEmpty) {
         assert(!sNames.isEmpty);
         var aNames = new JS.Property(
             _propertyName('names'), new JS.ArrayInitializer(sNames));
         sigFields.add(build('statics', tStatics));
         sigFields.add(aNames);
       }
       if (!sigFields.isEmpty) {
         var sig = new JS.ObjectInitializer(sigFields);
         var classExpr = new JS.Identifier(name);
         body.add(js.statement('dart.setSignature(#, #);', [classExpr, sig]));
       }
     }
 
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     var extensions = _extensionsToImplement(classElem);
     if (extensions.isNotEmpty) {
-      var methodNames = [];
+      var methodNames = <JS.Expression>[];
       for (var e in extensions) {
         methodNames.add(_elementMemberName(e));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         name,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
 
     // Metadata
     if (metadata.isNotEmpty) {
       body.add(js.statement('#[dart.metadata] = () => #;', [
         name,
-        new JS.ArrayInitializer(metadata.map(_instantiateAnnotation).toList())
+        new JS.ArrayInitializer(
+            new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
       ]));
     }
 
     return _statement(body);
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.contains(element)) return members;
 
@@ skipping 49 matching lines @@
       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]];
     var name = _constructorName(node.element.unnamedConstructor);
-    return new JS.Method(name, js.call('function() { #; }', body));
+    return new JS.Method(name, js.call('function() { #; }', body) as JS.Fun);
   }
 
   JS.Method _emitConstructor(ConstructorDeclaration node, InterfaceType type,
       List<FieldDeclaration> fields, bool isObject) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(node.element);
 
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     var redirect = node.redirectedConstructor;
     if (redirect != null) {
       var newKeyword = redirect.staticElement.isFactory ? '' : 'new';
       // Pass along all arguments verbatim, and let the callee handle them.
       // TODO(jmesserly): we'll need something different once we have
       // rest/spread support, but this should work for now.
       var params = _visit(node.parameters);
       var fun = js.call('function(#) { return $newKeyword #(#); }', [
         params,
         _visit(redirect),
         params,
-      ]);
+      ]) as JS.Fun;
       return new JS.Method(name, fun, isStatic: true)..sourceInformation = node;
     }
 
     // Factory constructors are essentially static methods.
     if (node.factoryKeyword != null) {
       var body = <JS.Statement>[];
       var init = _emitArgumentInitializers(node, constructor: true);
       if (init != null) body.add(init);
       body.add(_visit(node.body));
-      var fun = new JS.Fun(_visit(node.parameters), new JS.Block(body));
+      var fun = new JS.Fun(
+          _visit(node.parameters) as List<JS.Parameter>, new JS.Block(body));
       return new JS.Method(name, fun, isStatic: true)..sourceInformation = node;
     }
 
     // Code generation for Object's constructor.
     JS.Block body;
     if (isObject &&
         node.body is EmptyFunctionBody &&
         node.constKeyword != null &&
         node.name == null) {
       // Implements Dart constructor behavior. Because of V8 `super`
       // [constructor restrictions]
       // (https://code.google.com/p/v8/issues/detail?id=3330#c65)
       // we cannot currently emit actual ES6 constructors with super calls.
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
       // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
       // Performance of this pattern is likely to be bad.
       name = _propertyName('constructor');
       // 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 {
       body = _emitConstructorBody(node, fields);
     }
 
     // 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 new JS.Method(name, new JS.Fun(_visit(node.parameters), body))
+    return new JS.Method(
+        name, new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body))
       ..sourceInformation = node;
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name != '') {
       return _emitMemberName(name, isStatic: true);
     }
 
     // Factory default constructors use `new` as their name, for readability
@@ skipping 26 matching lines @@
 
     if (redirectCall != null) {
       body.add(_visit(redirectCall));
       return new JS.Block(body);
     }
 
     // Generate field initializers.
     // These are expanded into each non-redirecting constructor.
     // In the future we may want to create an initializer function if we have
     // multiple constructors, but it needs to be balanced against readability.
-    body.add(_initializeFields(node.parent, fields, node));
+    body.add(_initializeFields(cls, fields, node));
 
     var superCall = node.initializers.firstWhere(
-        (i) => i is SuperConstructorInvocation, orElse: () => null);
+        (i) => i is SuperConstructorInvocation,
+        orElse: () => null) as SuperConstructorInvocation;
 
     // If no superinitializer is provided, an implicit superinitializer of the
     // form `super()` is added at the end of the initializer list, unless the
     // enclosing class is class Object.
     var jsSuper = _superConstructorCall(cls.element, superCall);
     if (jsSuper != null) body.add(jsSuper);
 
     body.add(_visit(node.body));
     return new JS.Block(body)..sourceInformation = node;
   }
@@ skipping 49 matching lines @@
 
   /// Initialize fields. They follow the sequence:
   ///
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(
       ClassDeclaration cls, List<FieldDeclaration> fieldDecls,
       [ConstructorDeclaration ctor]) {
-    var unit = cls.getAncestor((a) => a is CompilationUnit);
+    var unit = cls.getAncestor((a) => a is CompilationUnit) as CompilationUnit;
     var constField = new ConstFieldVisitor(types, unit);
     bool isConst = ctor != null && ctor.constKeyword != null;
     if (isConst) _loader.startTopLevel(cls.element);
 
     // Run field initializers if they can have side-effects.
     var fields = new Map<FieldElement, JS.Expression>();
     var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fieldDecls) {
       for (var fieldNode in declaration.fields.variables) {
         var element = fieldNode.element;
         if (constField.isFieldInitConstant(fieldNode)) {
-          unsetFields[element] = fieldNode;
+          unsetFields[element as FieldElement] = fieldNode;
         } else {
-          fields[element] = _visitInitializer(fieldNode);
+          fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
         var element = p.element;
         if (element is FieldFormalParameterElement) {
           fields[element.field] = _visit(p);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
       for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
-          fields[init.fieldName.staticElement] = _visit(init.expression);
+          fields[init.fieldName.staticElement as FieldElement] =
+              _visit(init.expression);
         }
       }
     }
 
     for (var f in fields.keys) unsetFields.remove(f);
 
     // Initialize all remaining fields
     unsetFields.forEach((element, fieldNode) {
       JS.Expression value;
       if (fieldNode.initializer != null) {
@@ skipping 31 matching lines @@
   /// 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;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
-    var body = [];
+    var body = <JS.Statement>[];
     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,
@@ skipping 31 matching lines @@
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
-    var params = _visit(node.parameters);
-    if (params == null) params = [];
+    var params = _visit(node.parameters) as List<JS.Parameter>;
+    if (params == null) params = <JS.Parameter>[];
 
     return new JS.Method(
         _elementMemberName(node.element), _emitJsFunction(params, node.body),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
@@ skipping 63 matching lines @@
       if (lazy) {
         return js.call('dart.fn(#, () => #)', [clos, _emitFunctionRTTI(type)]);
       }
       return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
     }
     throw 'Function has non function type: $type';
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
-    var params = _visit(node.parameters);
-    if (params == null) params = [];
+    var params = _visit(node.parameters) as List<JS.Parameter>;
+    if (params == null) params = <JS.Parameter>[];
 
     var parent = node.parent;
     var inStmt = parent.parent is FunctionDeclarationStatement;
     if (parent is FunctionDeclaration) {
       return _emitJsFunction(params, node.body);
     } else {
       String code;
       AstNode body;
       var nodeBody = node.body;
       if (nodeBody is ExpressionFunctionBody) {
@@ skipping 114 matching lines @@
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
         return _getTemp(element, name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
-  JS.TemporaryId _getTemp(Object key, String name) =>
+  JS.TemporaryId _getTemp(Element key, String name) =>
       _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
   JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
-    var build = (t) => _emitTypeName(t);
-    return new JS.ArrayInitializer(types.map(build).toList());
+    return new JS.ArrayInitializer(
+        new List<JS.Expression>.from(types.map(_emitTypeName)));
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
       var value = _emitTypeName(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
@@ skipping 101 matching lines @@
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
     return _emitOpAssign(
         left, right, node.operator.lexeme[0], node.staticElement,
         context: node);
   }
 
   JS.MetaLet _emitOpAssign(
-      Expression left, Expression right, String op, ExecutableElement element,
+      Expression left, Expression right, String op, MethodElement element,
       {Expression context}) {
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
-    var vars = {};
+    var vars = <String, JS.Expression>{};
     var lhs = _bindLeftHandSide(vars, left, context: context);
     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);
@@ skipping 37 matching lines @@
 
   @override
   JS.Block visitBlockFunctionBody(BlockFunctionBody node) {
     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));
+  JS.Block visitBlock(Block node) =>
+      new JS.Block(_visitList(node.statements) as List<JS.Statement>);
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     String code;
     if (target == null || isLibraryPrefix(target)) {
@@ skipping 149 matching lines @@
       if (v.initializer != null) {
         var name = new JS.Identifier(v.name.name);
         return _visit(v.initializer).toVariableDeclaration(name);
       }
     }
     return _visit(node.variables).toStatement();
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
-    return new JS.VariableDeclarationList('let', _visitList(node.variables));
+    return new JS.VariableDeclarationList(
+        'let', _visitList(node.variables) as List<JS.VariableInitialization>);
   }
 
   @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));
   }
 
@@ skipping 22 matching lines @@
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName);
       return js.statement('let # = #;', [new JS.Identifier(fieldName), jsInit]);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return js.statement('# = #;', [_visit(field.name), jsInit]);
     }
 
-    var body = [];
+    var body = <JS.Statement>[];
     if (_lazyFields.isNotEmpty) {
       var existingTarget = _lazyFields[0].element.enclosingElement;
       if (existingTarget != element.enclosingElement) {
         _flushLazyFields(body);
       }
     }
 
     _lazyFields.add(field);
 
     return _statement(body);
@@ skipping 11 matching lines @@
     body.add(_emitLazyFields(_lazyFields));
     _lazyFields.clear();
   }
 
   JS.Statement _emitLazyFields(List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       var element = node.element;
       var access = _emitMemberName(name, type: element.type, isStatic: true);
-      methods.add(new JS.Method(
-          access, js.call('function() { return #; }', _visit(node.initializer)),
+      methods.add(new JS.Method(access, js.call(
+              'function() { return #; }', _visit(node.initializer)) as JS.Fun,
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
-        methods.add(
-            new JS.Method(access, js.call('function(_) {}'), isSetter: true));
+        methods.add(new JS.Method(access, js.call('function(_) {}') as JS.Fun,
+            isSetter: true));
       }
     }
 
     JS.Expression objExpr = _exportsVar;
     var target = _lazyFields[0].element.enclosingElement;
     if (target is ClassElement) {
       objExpr = new JS.Identifier(target.type.name);
     }
 
     return js.statement(
@@ skipping 20 matching lines @@
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     return _emitConstructorName(node.staticElement, node.type.type, node.name);
   }
 
   JS.Expression _emitInstanceCreationExpression(ConstructorElement element,
       DartType type, SimpleIdentifier name, ArgumentList argumentList,
       bool isConst) {
-    emitNew() {
+    JS.Expression emitNew() {
       JS.Expression ctor;
       bool isFactory = false;
       // var element = node.staticElement;
       if (element == null) {
         // TODO(jmesserly): this only happens if we had a static error.
         // Should we generate a throw instead?
         ctor = _emitTypeName(type);
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
       }
-      var args = _visit(argumentList);
+      var args = _visit(argumentList) as List<JS.Expression>;
       return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
     }
     if (isConst) return _emitConst(emitNew);
     return emitNew();
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     var element = node.staticElement;
     var constructor = node.constructorName;
@@ skipping 203 matching lines @@
           index.leftBracket,
           _bindValue(scope, 'i', index.index, context: context),
           index.rightBracket);
     } else if (expr is PropertyAccess) {
       PropertyAccess prop = expr;
       result = new PropertyAccess(
           _bindValue(scope, 'o', _getTarget(prop), context: context),
           prop.operator, prop.propertyName);
     } else if (expr is PrefixedIdentifier) {
       PrefixedIdentifier ident = expr;
-      result = new PrefixedIdentifier(
-          _bindValue(scope, 'o', ident.prefix, context: context), ident.period,
+      result = new PrefixedIdentifier(_bindValue(scope, 'o', ident.prefix,
+              context: context) as SimpleIdentifier, ident.period,
           ident.identifier);
     } else {
       return expr as SimpleIdentifier;
     }
     result.staticType = expr.staticType;
     DynamicInvoke.set(result, DynamicInvoke.get(expr));
     return result;
   }
 
   /// Creates a temporary to contain the value of [expr]. The temporary can be
@@ skipping 44 matching lines @@
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('#$op', _visit(expr));
       }
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
 
     // Handle the left hand side, to ensure each of its subexpressions are
     // evaluated only once.
-    var vars = {};
+    var vars = <String, JS.Expression>{};
     var left = _bindLeftHandSide(vars, expr, context: expr);
 
     // Desugar `x++` as `(x1 = x0 + 1, x0)` where `x0` is the original value
     // and `x1` is the new value for `x`.
     var x = _bindValue(vars, 'x', left, context: expr);
 
     var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
     var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
       ..staticElement = node.staticElement
       ..staticType = getStaticType(expr);
 
-    var body = [_emitSet(left, increment), _visit(x)];
+    var body = <JS.Expression>[_emitSet(left, increment), _visit(x)];
     return new JS.MetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('$op#', _visit(expr));
       } else if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
         var mathop = op.lexeme[0];
-        var vars = {};
+        var vars = <String, JS.Expression>{};
         var x = _bindLeftHandSide(vars, expr, context: expr);
         var body = js.call('# = # $mathop 1', [_visit(x), notNull(x)]);
         return new JS.MetaLet(vars, [body]);
       } else {
         return js.call('$op#', notNull(expr));
       }
     }
 
     if (op.lexeme == '++' || op.lexeme == '--') {
       // Increment or decrement requires expansion.
       // Desugar `++x` as `x = x + 1`, ensuring that if `x` has subexpressions
       // (for example, x is IndexExpression) we evaluate those once.
       var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
       return _emitOpAssign(expr, one, op.lexeme[0], node.staticElement,
           context: expr);
     }
 
     return _emitSend(expr, op.lexeme[0], []);
   }
 
   // Cascades can contain [IndexExpression], [MethodInvocation] and
   // [PropertyAccess]. The code generation for those is handled in their
   // respective visit methods.
   @override
   JS.Node visitCascadeExpression(CascadeExpression node) {
     var savedCascadeTemp = _cascadeTarget;
 
-    var vars = {};
-    _cascadeTarget = _bindValue(vars, '_', node.target, context: node);
-    var sections = _visitList(node.cascadeSections);
+    var vars = <String, JS.Expression>{};
+    _cascadeTarget =
+        _bindValue(vars, '_', node.target, context: node) as SimpleIdentifier;
+    var sections = _visitList(node.cascadeSections) as List<JS.Expression>;
     sections.add(_visit(_cascadeTarget));
     var result = new JS.MetaLet(vars, sections, statelessResult: true);
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
@@ skipping 227 matching lines @@
     if (clause.exceptionType == null) return then;
 
     // TODO(jmesserly): this is inconsistent with [visitIsExpression], which
     // has special case for typeof.
     return new JS.If(js.call('dart.is(#, #)', [
       _visit(_catchParameter),
       _emitTypeName(clause.exceptionType.type),
     ]), then, otherwise);
   }
 
-  JS.Statement _statement(Iterable stmts) {
-    List s = stmts is List ? stmts : new List<JS.Statement>.from(stmts);
+  JS.Statement _statement(List<JS.Statement> statements) {
     // TODO(jmesserly): empty block singleton?
-    if (s.length == 0) return new JS.Block([]);
-    if (s.length == 1) return s[0];
-    return new JS.Block(s);
+    if (statements.length == 0) return new JS.Block([]);
+    if (statements.length == 1) return statements[0];
+    return new JS.Block(statements);
   }
 
   /// 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 = [];
+    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)]));
         _catchParameter = name;
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
         body.add(js.statement(
             'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
       }
     }
 
     body.add(_visit(node.body));
     _catchParameter = savedCatch;
     return _statement(body);
   }
 
   @override
   JS.Case visitSwitchCase(SwitchCase node) {
     var expr = _visit(node.expression);
-    var body = _visitList(node.statements);
+    var body = _visitList(node.statements) as List<JS.Statement>;
     if (node.labels.isNotEmpty) {
       body.insert(0, js.comment('Unimplemented case labels: ${node.labels}'));
     }
     // TODO(jmesserly): make sure we are statically checking fall through
     return new JS.Case(expr, new JS.Block(body));
   }
 
   @override
   JS.Default visitSwitchDefault(SwitchDefault node) {
-    var body = _visitList(node.statements);
+    var body = _visitList(node.statements) as List<JS.Statement>;
     if (node.labels.isNotEmpty) {
       body.insert(0, js.comment('Unimplemented case labels: ${node.labels}'));
     }
     // TODO(jmesserly): make sure we are statically checking fall through
     return new JS.Default(new JS.Block(body));
   }
 
   @override
-  JS.Switch visitSwitchStatement(SwitchStatement node) =>
-      new JS.Switch(_visit(node.expression), _visitList(node.members));
+  JS.Switch visitSwitchStatement(SwitchStatement node) => new JS.Switch(
+      _visit(node.expression),
+      _visitList(node.members) as List<JS.SwitchClause>);
 
   @override
   JS.Statement visitLabeledStatement(LabeledStatement node) {
     var result = _visit(node.statement);
     for (var label in node.labels.reversed) {
       result = new JS.LabeledStatement(label.label.name, result);
     }
     return result;
   }
 
   @override
   visitIntegerLiteral(IntegerLiteral node) => js.number(node.value);
 
   @override
   visitDoubleLiteral(DoubleLiteral node) => js.number(node.value);
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
-    emitSymbol() {
+    JS.New emitSymbol() {
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
       return new JS.New(_emitTypeName(types.symbolType), [name]);
     }
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
-    emitList() {
-      JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
+    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) {
         // 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();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
-    emitMap() {
+    JS.Expression emitMap() {
       var entries = node.entries;
       var mapArguments = null;
       if (entries.isEmpty) {
         mapArguments = [];
       } else if (entries.every((e) => e.key is StringLiteral)) {
         // Use JS object literal notation if possible, otherwise use an array.
         // We could do this any time all keys are non-nullable String type.
         // For now, support StringLiteral as the common non-nullable String case.
-        var props = [];
+        var props = <JS.Property>[];
         for (var e in entries) {
           props.add(new JS.Property(_visit(e.key), _visit(e.value)));
         }
         mapArguments = new JS.ObjectInitializer(props);
       } else {
-        var values = [];
+        var values = <JS.Expression>[];
         for (var e in entries) {
           values.add(_visit(e.key));
           values.add(_visit(e.value));
         }
         mapArguments = new JS.ArrayInitializer(values);
       }
       // TODO(jmesserly): add generic types args.
       return js.call('dart.map(#)', [mapArguments]);
     }
     if (node.constKeyword != null) return _emitConst(emitMap);
@@ skipping 44 matching lines @@
     throw 'Unimplemented ${node.runtimeType}: $node';
   }
 
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     if (result is JS.Node) result.sourceInformation = node;
     return result;
   }
 
-  List _visitList(Iterable<AstNode> nodes) {
+  // TODO(jmesserly): this will need to be a generic method, if we ever want to
+  // self-host strong mode.
+  List /*<T>*/ _visitList /*<T>*/ (Iterable<AstNode> nodes) {
     if (nodes == null) return null;
-    var result = [];
+    var result = /*<T>*/ [];
     for (var node in nodes) result.add(_visit(node));
     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), operator);
+    return new JS.Expression.binary(
+        _visitList(nodes) as List<JS.Expression>, operator);
   }
 
   /// 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 50 matching lines @@
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _emitMemberName(String name, {DartType type, bool unary: false,
       bool isStatic: false, bool allowExtensions: true}) {
 
     // Static members skip the rename steps.
     if (isStatic) return _propertyName(name);
 
     if (name.startsWith('_')) {
       return _privateNames.putIfAbsent(
-          name, () => _initSymbol(new JS.TemporaryId(name)));
+          name, () => _initSymbol(new JS.TemporaryId(name)) as JS.TemporaryId);
     }
 
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
       name = 'unary-';
     }
 
@@ skipping 35 matching lines @@
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     for (var t in ['JSArray', 'JSString', 'JSInt', 'JSDouble', 'JSBool']) {
       _addExtensionType(interceptors.getType(t).type);
     }
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
-    t = fillDynamicTypeArgs(t, rules.provider);
+    t = fillDynamicTypeArgs(t, rules.provider) as InterfaceType;
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
   String generateLibrary(LibraryUnit unit) {
     var library = unit.library.element.library;
     var fields = findFieldsNeedingStorage(unit);
     var codegen =
         new JSCodegenVisitor(compiler, library, _extensionTypes, fields);
@@ skipping 37 matching lines @@
 
 class _JsThisFinder extends JS.BaseVisitor {
   bool found = false;
   visitThis(JS.This node) {
     found = true;
   }
   visitNode(JS.Node node) {
     if (!found) super.visitNode(node);
   }
 }