fix #29346, ensure all nodes are implemented by DDC's code generator

pkg/dev_compiler/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';
@@ skipping 35 matching lines @@
 import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'property_model.dart';
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'type_utilities.dart';
 
-class CodeGenerator extends GeneralizingAstVisitor
-    with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
+/// The code generator for Dart Dev Compiler.
+///
+/// Takes as input resolved Dart ASTs for every compilation unit in every
+/// library in the module. Produces a single JavaScript AST for the module as
+/// output, along with its source map.
+///
+/// This class attempts to preserve identifier names and structure of the input
+/// Dart code, whenever this is possible to do in the generated code.
+//
+// TODO(jmesserly): we should use separate visitors for statements and
+// expressions. Declarations are handled directly, and many minor component
+// AST nodes aren't visited, so the visitor pattern isn't helping except for
+// expressions (which result in JS.Expression) and statements
+// (which result in (JS.Statement).
+class CodeGenerator extends Object
+    with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference
+    implements AstVisitor<JS.Node> {
   final AnalysisContext context;
   final SummaryDataStore summaryData;
 
   final CompilerOptions options;
   final StrongTypeSystemImpl rules;
 
   /// The set of libraries we are currently compiling, and the temporaries used
   /// to refer to them.
   ///
   /// We sometimes special case codegen for a single library, as it simplifies
@@ skipping 164 matching lines @@
           null,
           sdk is SummaryBasedDartSdk
               ? sdk.bundle
               : (sdk as FolderBasedDartSdk).getSummarySdkBundle(true));
     }
 
     var assembler = new PackageBundleAssembler();
     assembler.recordDependencies(summaryData);
 
     var uriToUnit = new Map<String, UnlinkedUnit>.fromIterable(units,
-        key: (u) => u.element.source.uri.toString(), value: (unit) {
-      var unlinked = serializeAstUnlinked(unit);
-      assembler.addUnlinkedUnit(unit.element.source, unlinked);
-      return unlinked;
-    });
+        key: (u) => u.element.source.uri.toString(),
+        value: (unit) {
+          var unlinked = serializeAstUnlinked(unit);
+          assembler.addUnlinkedUnit(unit.element.source, unlinked);
+          return unlinked;
+        });
 
     summary_link
         .link(
             uriToUnit.keys.toSet(),
             (uri) => summaryData.linkedMap[uri],
             (uri) => summaryData.unlinkedMap[uri] ?? uriToUnit[uri],
             context.declaredVariables.get,
             true)
         .forEach(assembler.addLinkedLibrary);
 
@@ skipping 65 matching lines @@
     }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Visit each compilation unit and emit its code.
     //
     // NOTE: declarations are not necessarily emitted in this order.
     // Order will be changed as needed so the resulting code can execute.
     // This is done by forward declaring items.
-    compilationUnits.forEach(_emitCompilationUnit);
+    compilationUnits.forEach(visitCompilationUnit);
     assert(_deferredProperties.isEmpty);
 
     // Visit directives (for exports)
     compilationUnits.forEach(_emitExportDirectives);
 
     // Declare imports
     _finishImports(items);
 
     // Discharge the type table cache variables and
     // hoisted definitions.
@@ skipping 215 matching lines @@
   void _declareBeforeUse(TypeDefiningElement e) {
     if (e == null) return;
 
     var topLevel = _topLevelElements;
     if (topLevel.isNotEmpty && identical(currentElement, topLevel.last)) {
       // If the item is from our library, try to emit it now.
       _emitTypeDeclaration(e);
     }
   }
 
-  void _emitCompilationUnit(CompilationUnit unit) {
+  @override
+  visitCompilationUnit(CompilationUnit unit) {
     // NOTE: this method isn't the right place to initialize
     // per-compilation-unit state. Declarations can be visited out of order,
     // this is only to catch things that haven't been emitted yet.
     //
     // See _emitTypeDeclaration.
     var library = unit.element.library;
     bool internalSdk = isSdkInternalRuntime(library);
     _currentElements.add(library);
 
     List<VariableDeclaration> fields;
@@ skipping 35 matching lines @@
 
   void _emitExportDirectives(CompilationUnit unit) {
     for (var directive in unit.directives) {
       _currentElements.add(directive.element);
       directive.accept(this);
       _currentElements.removeLast();
     }
   }
 
   @override
-  void visitLibraryDirective(LibraryDirective node) {}
+  visitLibraryDirective(LibraryDirective node) => null;
 
   @override
-  void visitImportDirective(ImportDirective node) {
+  visitImportDirective(ImportDirective node) {
     // We don't handle imports here.
     //
     // Instead, we collect imports whenever we need to generate a reference
     // to another library. This has the effect of collecting the actually used
     // imports.
     //
     // TODO(jmesserly): if this is a prefixed import, consider adding the prefix
     // as an alias?
+    return null;
   }
 
   @override
-  void visitPartDirective(PartDirective node) {}
+  visitPartDirective(PartDirective node) => null;
 
   @override
-  void visitPartOfDirective(PartOfDirective node) {}
+  visitPartOfDirective(PartOfDirective node) => null;
 
   @override
-  void visitExportDirective(ExportDirective node) {
+  visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     var currentLibrary = element.library;
 
     var currentNames = currentLibrary.publicNamespace.definedNames;
     var exportedNames =
         new NamespaceBuilder().createExportNamespaceForDirective(element);
 
     // We only need to export main as it is the only method part of the
     // publicly exposed JS API for a library.
     // TODO(jacobr): add a library level annotation indicating that all
     // contents of a library need to be exposed to JS.
     // https://github.com/dart-lang/sdk/issues/26368
     var export = exportedNames.get('main');
 
     if (export is FunctionElement) {
       // Don't allow redefining names from this library.
-      if (currentNames.containsKey(export.name)) return;
+      if (currentNames.containsKey(export.name)) return null;
 
       var name = _emitTopLevelName(export);
       _moduleItems.add(js.statement(
           '#.# = #;', [emitLibraryName(currentLibrary), name.selector, name]));
     }
   }
 
   @override
   visitAsExpression(AsExpression node) {
     Expression fromExpr = node.expression;
@@ skipping 75 matching lines @@
     var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(element, typeFormals,
           js.statement('const # = #;', [element.name, body]));
     } else {
       return js.statement('# = #;', [_emitTopLevelName(element), body]);
     }
   }
 
   @override
+  visitGenericTypeAlias(GenericTypeAlias node) {
+    throw new UnimplementedError('Generic type aliases are not implemented. '
+        'See https://github.com/dart-lang/sdk/issues/27971');
+  }
+
+  @override
   JS.Expression visitTypeName(TypeName node) {
     if (node.type == null) {
       // TODO(jmesserly): if the type fails to resolve, should we generate code
       // that throws instead?
       assert(options.unsafeForceCompile || options.replCompile);
       return _callHelper('dynamic');
     }
     return _emitType(node.type);
   }
 
@@ skipping 21 matching lines @@
             [jsParams, _constructorName(parentCtor), jsParams]) as JS.Fun;
         methods.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
     var typeFormals = element.typeParameters;
     var isGeneric = typeFormals.isNotEmpty;
     var className = isGeneric ? element.name : _emitTopLevelName(element);
     JS.Statement declareInterfaces(JS.Statement decl) {
       if (element.interfaces.isNotEmpty) {
-        var body = [decl]
-          ..add(js.statement('#[#.implements] = () => #;', [
+        var body = [decl]..add(js.statement('#[#.implements] = () => #;', [
             className,
             _runtimeModule,
             new JS.ArrayInitializer(
                 new List<JS.Expression>.from(element.interfaces.map(_emitType)))
           ]));
         decl = _statement(body);
       }
       return decl;
     }
 
@@ skipping 1255 matching lines @@
     var redirect = node.redirectedConstructor;
     if (redirect != null) {
       var newKeyword =
           resolutionMap.staticElementForConstructorReference(redirect).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 =
-          visitFormalParameterList(node.parameters, destructure: false);
+          _emitFormalParameterList(node.parameters, destructure: false);
 
       var fun = new JS.Fun(
           params,
-          js.statement('{ return $newKeyword #(#); }',
-              [_visit(redirect) as JS.Node, params]),
+          js.statement(
+              '{ return $newKeyword #(#); }', [_visit(redirect), params]),
           returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
-    var params = visitFormalParameterList(node.parameters);
+    var params = _emitFormalParameterList(node.parameters);
 
     // 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(params, new JS.Block(body), returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
@@ skipping 72 matching lines @@
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     var ctor = resolutionMap.staticElementForConstructorReference(node);
     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)
+      _emitArgumentList(node.argumentList)
     ]);
   }
 
   JS.Statement _superConstructorCall(ClassElement element,
       [SuperConstructorInvocation node]) {
     if (element.supertype == null) {
       assert(element.type.isObject || options.unsafeForceCompile);
       return null;
     }
 
@@ skipping 11 matching lines @@
       // we don't have a default constructor in the supertype.
       assert(options.unsafeForceCompile);
       return null;
     }
 
     if (superCtor.name == '' && !_hasUnnamedSuperConstructor(element)) {
       return null;
     }
 
     var name = _constructorName(superCtor);
-    var args = node != null ? _visit(node.argumentList) : [];
+    var args = node != null ? _emitArgumentList(node.argumentList) : [];
     return annotate(js.statement('super.#(#);', [name, args]), node);
   }
 
   bool _hasUnnamedSuperConstructor(ClassElement e) {
     var supertype = e.supertype;
     if (supertype == null) return false;
     if (_hasUnnamedConstructor(supertype.element)) return true;
     for (var mixin in e.mixins) {
       if (_hasUnnamedConstructor(mixin.element)) return true;
     }
@@ skipping 39 matching lines @@
         if (element is FieldFormalParameterElement) {
           fields[element.field] = _emitSimpleIdentifier(p.identifier);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
       for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
           var element = init.fieldName.staticElement as FieldElement;
           fields[element] = _visit(init.expression);
+        } else if (init is AssertInitializer) {
+          throw new UnimplementedError(
+              'Assert initializers are not implemented. '
+              'See https://github.com/dart-lang/sdk/issues/27809');
         }
       }
     }
 
     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 101 matching lines @@
     }
   }
 
   JS.Fun _emitNativeFunctionBody(MethodDeclaration node) {
     String name =
         getAnnotationName(node.element, isJSAnnotation) ?? node.name.name;
     if (node.isGetter) {
       return new JS.Fun([], js.statement('{ return this.#; }', [name]));
     } else if (node.isSetter) {
       var params =
-          visitFormalParameterList(node.parameters, destructure: false);
+          _emitFormalParameterList(node.parameters, destructure: false);
       return new JS.Fun(
           params, js.statement('{ this.# = #; }', [name, params.last]));
     } else {
       return js.call(
           'function (...args) { return this.#.apply(this, args); }', name);
     }
   }
 
   JS.Method _emitMethodDeclaration(InterfaceType type, MethodDeclaration node) {
     if (node.isAbstract) {
@@ skipping 39 matching lines @@
     if (JS.Return.foundIn(fn)) {
       // If a return is inside body, transform `(params) { body }` to
       // `(params) { (() => { body })(); return value; }`.
       // TODO(jmesserly): we could instead generate the return differently,
       // and avoid the immediately invoked function.
       body = new JS.Call(new JS.ArrowFun([], fn.body), []).toStatement();
     }
     // Rewrite the function to include the return.
     return new JS.Fun(
         fn.params, new JS.Block([body, new JS.Return(fn.params.last)]),
-        typeParams: fn.typeParams,
-        returnType: fn.returnType)..sourceInformation = fn.sourceInformation;
+        typeParams: fn.typeParams, returnType: fn.returnType)
+      ..sourceInformation = fn.sourceInformation;
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     if (node.isGetter || node.isSetter) {
       PropertyAccessorElement element = node.element;
@@ skipping 184 matching lines @@
     var fn = _emitFunctionBody(node.element, node.parameters, node.body);
     return annotate(_makeGenericFunction(fn), node);
   }
 
   JS.Fun _emitFunctionBody(ExecutableElement element,
       FormalParameterList parameters, FunctionBody body) {
     FunctionType type = element.type;
 
     // normal function (sync), vs (sync*, async, async*)
     var stdFn = !(element.isAsynchronous || element.isGenerator);
-    var formals = visitFormalParameterList(parameters, destructure: stdFn);
+    var formals = _emitFormalParameterList(parameters, destructure: stdFn);
     var code = (stdFn)
         ? _visit(body)
         : new JS.Block(
             [_emitGeneratorFunctionBody(element, parameters, body).toReturn()]);
     var typeFormals = _emitTypeFormals(type.typeFormals);
     var returnType = emitTypeRef(type.returnType);
     if (type.typeFormals.isNotEmpty) {
       code = new JS.Block(<JS.Statement>[
         new JS.Block(_typeTable.discharge(type.typeFormals)),
         code
@@ skipping 32 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;
-    var jsParams = visitFormalParameterList(parameters);
+    var jsParams = _emitFormalParameterList(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);
     _superAllowed = savedSuperAllowed;
     _asyncStarController = savedController;
 
     DartType returnType = _getExpectedReturnType(element);
     JS.Expression gen = new JS.Fun(jsParams, jsBody,
         isGenerator: true, returnType: emitTypeRef(returnType));
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
 
     var T = _emitType(returnType);
     return _callHelper('#(#)', [
       kind,
-      [gen, T]..addAll(visitFormalParameterList(parameters, destructure: false))
+      [gen, T]..addAll(_emitFormalParameterList(parameters, destructure: false))
     ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
@@ skipping 627 matching lines @@
     JS.Expression target;
     if (element is TemporaryVariableElement) {
       // If this is one of our compiler's temporary variables, use its JS form.
       target = element.jsVariable;
     } else if (element is ParameterElement) {
       target = _emitParameter(element);
     } else {
       target = new JS.Identifier(element.name);
     }
 
-    return _visit(rhs).toAssignExpression(annotate(target, node));
+    return _visit<JS.Expression>(rhs)
+        .toAssignExpression(annotate(target, node));
   }
 
   /// Emits assignment to library scope element [element].
   JS.Expression _emitSetTopLevel(
       Expression lhs, Element element, Expression rhs) {
-    return _visit(rhs)
+    return _visit<JS.Expression>(rhs)
         .toAssignExpression(annotate(_emitTopLevelName(element), lhs));
   }
 
   /// Emits assignment to a static field element or property.
   JS.Expression _emitSetStaticProperty(
       Expression lhs, Element element, Expression rhs) {
     // For static methods, we add the raw type name, without generics or
     // library prefix. We don't need those because static calls can't use
     // the generic type.
     ClassElement classElement = element.enclosingElement;
     var type = classElement.type;
     var dynType = _emitStaticAccess(type);
     var member = _emitMemberName(element.name,
         isStatic: true, type: type, element: element);
-    return _visit(rhs).toAssignExpression(
+    return _visit<JS.Expression>(rhs).toAssignExpression(
         annotate(new JS.PropertyAccess(dynType, member), lhs));
   }
 
   /// Emits an assignment to the [element] property of instance referenced by
   /// [jsTarget].
   JS.Expression _emitWriteInstanceProperty(Expression lhs,
       JS.Expression jsTarget, Element element, JS.Expression value) {
     String memberName = element.name;
     var type = (element.enclosingElement as ClassElement).type;
     var name = _emitMemberName(memberName, type: type, element: element);
     return value.toAssignExpression(
         annotate(new JS.PropertyAccess(jsTarget, name), lhs));
   }
 
   JS.Expression _emitSetSuper(Expression lhs, SuperExpression target,
       SimpleIdentifier id, Expression rhs) {
     // TODO(sra): Determine whether and access helper is required for the
     // setter. For now fall back on the r-value path.
-    return _visit(rhs).toAssignExpression(_visit(lhs));
+    return _visit<JS.Expression>(rhs).toAssignExpression(_visit(lhs));
   }
 
   JS.Expression _emitNullSafeSet(PropertyAccess node, Expression right) {
     // Emit `obj?.prop = expr` as:
     //
     //     (_ => _ == null ? null : _.prop = expr)(obj).
     //
     // We could use a helper, e.g.:  `nullSafeSet(e1, _ => _.v = e2)`
     //
     // However with MetaLet, we get clean code in statement or void context,
@@ skipping 56 matching lines @@
     }
     if (node.methodName.name == 'call') {
       var targetType = resolutionMap.staticTypeForExpression(target);
       if (targetType is FunctionType) {
         // Call methods on function types should be handled as regular function
         // invocations.
         return _emitFunctionCall(node, node.target);
       }
       if (targetType.isDartCoreFunction || targetType.isDynamic) {
         // TODO(vsm): Can a call method take generic type parameters?
-        return _emitDynamicInvoke(node, _visit(target),
-            _visit(node.argumentList) as List<JS.Expression>);
+        return _emitDynamicInvoke(
+            node, _visit(target), _emitArgumentList(node.argumentList));
       }
     }
 
     return _emitMethodCall(target, node);
   }
 
   JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
-    var args = _visit(node.argumentList) as List<JS.Expression>;
+    var args = _emitArgumentList(node.argumentList);
     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 119 matching lines @@
   }
 
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node,
       [Expression function]) {
     if (function == null) {
       function = node.function;
     }
     var fn = _visit(function);
-    var args = _visit(node.argumentList) as List<JS.Expression>;
+    var args = _emitArgumentList(node.argumentList);
     if (isDynamicInvoke(function)) {
       return _emitDynamicInvoke(node, fn, args);
     } else {
       return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
     }
   }
 
   JS.Expression _applyInvokeTypeArguments(
       JS.Expression target, InvocationExpression node) {
     var typeArgs = _emitInvokeTypeArguments(node);
@@ skipping 128 matching lines @@
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
           FunctionExpressionInvocation node) =>
       _emitFunctionCall(node);
 
   @override
-  List<JS.Expression> visitArgumentList(ArgumentList node) {
+  visitArgumentList(ArgumentList node) {
+    assert(false);

[vsm, 2017/04/14 13:14:39]

Should this just be in your unreachable list below?

[Jennifer Messerly, 2017/04/14 17:03:58]

yes! oops :) done

+  }
+
+  List<JS.Expression> _emitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
     for (var arg in node.arguments) {
       if (arg is NamedExpression) {
         named.add(_visit(arg));
       } else if (arg is MethodInvocation && isJsSpreadInvocation(arg)) {
         args.add(
             new JS.RestParameter(_visit(arg.argumentList.arguments.single)));
       } else {
         args.add(_visit(arg));
       }
     }
     if (named.isNotEmpty) {
       args.add(new JS.ObjectInitializer(named));
     }
     return args;
   }
 
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
     assert(node.parent is ArgumentList);
     return new JS.Property(
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
-  @override
-  List<JS.Parameter> visitFormalParameterList(FormalParameterList node,
+  List<JS.Parameter> _emitFormalParameterList(FormalParameterList node,
       {bool destructure: true}) {
     if (node == null) return [];
 
     destructure = destructure && options.destructureNamedParams;
 
     var result = <JS.Parameter>[];
     var namedVars = <JS.DestructuredVariable>[];
     var hasNamedArgsConflictingWithObjectProperties = false;
     var needsOpts = false;
 
@@ skipping 136 matching lines @@
   JS.Statement visitVariableDeclarationStatement(
       VariableDeclarationStatement node) {
     // Special case a single variable with an initializer.
     // This helps emit cleaner code for things like:
     //     var result = []..add(1)..add(2);
     var variables = node.variables.variables;
     if (variables.length == 1) {
       var v = variables[0];
       if (v.initializer != null) {
         var name = new JS.Identifier(v.name.name);
-        return _visit(v.initializer).toVariableDeclaration(name);
+        return _visit<JS.Expression>(v.initializer).toVariableDeclaration(name);
       }
     }
-    return _visit(node.variables).toStatement();
+    return _visit<JS.Expression>(node.variables).toStatement();
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     return new JS.VariableDeclarationList(
         'let', _visitList(node.variables) as List<JS.VariableInitialization>);
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
@@ skipping 118 matching lines @@
             hoistType: options.hoistInstanceCreation);
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
         var classElem = element.enclosingElement;
         isNative = _isJSNative(classElem);
       }
-      var args = _visit(argumentList) as List<JS.Expression>;
+      var args = _emitArgumentList(argumentList);
       // Native factory constructors are JS constructors - use new here.
       return isFactory && !isNative
           ? new JS.Call(ctor, args)
           : new JS.New(ctor, args);
     }
 
     if (element != null && _isObjectLiteral(element.enclosingElement)) {
       return _emitObjectLiteral(argumentList);
     }
     if (isConst) return _emitConst(emitNew);
     return emitNew();
   }
 
   bool _isObjectLiteral(ClassElement classElem) {
     return findAnnotation(classElem, isPublicJSAnnotation) != null &&
         findAnnotation(classElem, isJSAnonymousAnnotation) != null;
   }
 
   bool _isJSNative(ClassElement classElem) =>
       findAnnotation(classElem, isPublicJSAnnotation) != null;
 
   JS.Expression _emitObjectLiteral(ArgumentList argumentList) {
-    var args = _visit(argumentList) as List<JS.Expression>;
+    var args = _emitArgumentList(argumentList);
     if (args.isEmpty) {
       return js.call('{}');
     }
     assert(args.single is JS.ObjectInitializer);
     return args.single;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     var element = resolutionMap.staticElementForConstructorReference(node);
@@ skipping 576 matching lines @@
     var operatorName = op.lexeme;
     // Use the name from the Dart spec.
     if (operatorName == '-') operatorName = 'unary-';
     return _emitSend(expr, operatorName, []);
   }
 
   // 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) {
+  visitCascadeExpression(CascadeExpression node) {
     var savedCascadeTemp = _cascadeTarget;
 
     var vars = <JS.MetaLetVariable, JS.Expression>{};
     _cascadeTarget = _bindValue(vars, '_', node.target, context: node);
     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);
 
   @override
-  visitFormalParameter(FormalParameter node) {
+  visitDefaultFormalParameter(DefaultFormalParameter node) {
+    return _emitParameter(node.element, declaration: true);
+  }
+
+  JS.Parameter _emitNormalFormalParameter(NormalFormalParameter node) {
     var id = _emitParameter(node.element, declaration: true);
     var isRestArg = findAnnotation(node.element, isJsRestAnnotation) != null;
     return isRestArg ? new JS.RestParameter(id) : id;
   }
 
   @override
+  visitSimpleFormalParameter(SimpleFormalParameter node) =>
+      _emitNormalFormalParameter(node);
+
+  @override
+  visitFieldFormalParameter(FieldFormalParameter node) =>
+      _emitNormalFormalParameter(node);
+
+  @override
+  visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
+      _emitNormalFormalParameter(node);
+
+  @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (_isDeferredLoadLibrary(node.prefix, node.identifier)) {
       // We are tearing off "loadLibrary" on a library prefix.
       return _callHelper('loadLibrary');
@@ skipping 627 matching lines @@
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
   @override
   JS.Expression visitAdjacentStrings(AdjacentStrings node) =>
       _visitListToBinary(node.strings, '+');
 
   @override
   JS.Expression visitStringInterpolation(StringInterpolation node) {
+    var strings = <String>[];
+    var interpolations = <JS.Expression>[];
+
+    var expectString = true;
+    for (var e in node.elements) {
+      if (e is InterpolationString) {
+        assert(expectString);
+        expectString = false;
+
+        // Escape the string as necessary for use in the eventual `` quotes.
+        // TODO(jmesserly): this call adds quotes, and then we strip them off.
+        var str = js.escapedString(e.value, '`').value;
+        strings.add(str.substring(1, str.length - 1));
+      } else {
+        assert(!expectString);
+        expectString = true;
+        interpolations.add(_visit(e));
+      }
+    }
     return new JS.TaggedTemplate(
-        _callHelper('str'), new JS.TemplateString(_visitList(node.elements)));
+        _callHelper('str'), new JS.TemplateString(strings, interpolations));
   }
 
   @override
-  String visitInterpolationString(InterpolationString node) {
-    // TODO(jmesserly): this call adds quotes, and then we strip them off.
-    var str = js.escapedString(node.value, '`').value;
-    return str.substring(1, str.length - 1);
-  }
-
-  @override
   visitInterpolationExpression(InterpolationExpression node) =>
       _visit(node.expression);
 
   @override
   visitBooleanLiteral(BooleanLiteral node) => js.boolean(node.value);
 
-  @override
-  JS.Expression visitExpression(Expression node) =>
-      _unimplementedCall('Unimplemented ${node.runtimeType}: $node');
-
-  JS.Expression _unimplementedCall(String comment) {
-    return _callHelper('throw(#)', [js.escapedString(comment)]);
-  }
-
-  @override
-  visitNode(AstNode node) {
-    // TODO(jmesserly): verify this is unreachable.
-    throw 'Unimplemented ${node.runtimeType}: $node';
-  }
-
-  _visit(AstNode node) {
+  T _visit<T extends JS.Node>(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
-    return result is JS.Node ? annotate(result, node) : result;
+    return result != null ? annotate(result, node) : null;
   }
 
   // TODO(jmesserly): we should make sure this only returns JS AST nodes.
   List/*<R>*/ _visitList/*<T extends AstNode, R>*/(Iterable/*<T>*/ nodes) {
     if (nodes == null) return null;
     var result = /*<R>*/ [];
     for (var node in nodes) result.add(_visit(node) as dynamic/*=R*/);
     return result;
   }
 
@@ skipping 140 matching lines @@
       useExtension = baseType is InterfaceType &&
           _isSymbolizedMember(baseType, name, alwaysSymbolizeNative);
     }
 
     return useExtension
         ? js.call('#.#', [_extensionSymbolsModule, result])
         : result;
   }
 
   var _forwardingCache = new HashMap<Element, Map<String, ExecutableElement>>();
+
   Element _lookupForwardedMember(ClassElement element, String name) {
     // We only care about public methods.
     if (name.startsWith('_')) return null;
 
     var map = _forwardingCache.putIfAbsent(element, () => {});
     if (map.containsKey(name)) return map[name];
 
     // Note, for a public member, the library should not matter.
     var library = element.library;
     var member = element.lookUpMethod(name, library) ??
@@ skipping 207 matching lines @@
         return whitelisted.contains(name);
       }
     }
 
     // Dynamic calls are less risky so there is no need to whitelist at the
     // method level.
     if (isCall && _uncheckedWhitelistCalls.contains(filename)) return true;
 
     return path.endsWith(".template.dart");
   }
+
+  _unreachable(AstNode node) {
+    throw new UnsupportedError(
+        'tried to generate an unreachable node: `$node`');
+  }
+
+  /// Unused, see methods for emitting declarations.
+  @override
+  visitAnnotation(node) => _unreachable(node);
+
+  /// Unused, see [_emitFieldInitializers].
+  @override
+  visitAssertInitializer(node) => _unreachable(node);
+
+  /// Not visited, but maybe they should be?
+  /// See <https://github.com/dart-lang/sdk/issues/29347>
+  @override
+  visitComment(node) => _unreachable(node);
+
+  /// Not visited, but maybe they should be?
+  /// See <https://github.com/dart-lang/sdk/issues/29347>
+  @override
+  visitCommentReference(node) => _unreachable(node);
+
+  /// Unused, handled by imports/exports.
+  @override
+  visitConfiguration(node) => _unreachable(node);
+
+  /// Unusued, see [_emitConstructor].
+  @override
+  visitConstructorDeclaration(node) => _unreachable(node);
+
+  /// Unusued, see [_emitFieldInitializers].
+  @override
+  visitConstructorFieldInitializer(node) => _unreachable(node);
+
+  /// Unusued. Handled in [visitForEachStatement].
+  @override
+  visitDeclaredIdentifier(node) => _unreachable(node);
+
+  /// Unused, handled by imports/exports.
+  @override
+  visitDottedName(node) => _unreachable(node);
+
+  /// Unused, handled by [visitEnumDeclaration].
+  @override
+  visitEnumConstantDeclaration(node) => _unreachable(node); // see
+
+  /// Unused, see [_emitClassHeritage].
+  @override
+  visitExtendsClause(node) => _unreachable(node);
+
+  /// Unused, see [_emitFormalParameterList].
+  @override
+  visitFormalParameterList(node) => _unreachable(node);
+
+  /// Unused, handled by imports/exports.
+  @override
+  visitShowCombinator(node) => _unreachable(node);
+
+  /// Unused, handled by imports/exports.
+  @override
+  visitHideCombinator(node) => _unreachable(node);
+
+  /// Unused, see [_emitClassHeritage].
+  @override
+  visitImplementsClause(node) => _unreachable(node);
+
+  /// Unused, handled by [visitStringInterpolation].
+  @override
+  visitInterpolationString(node) => _unreachable(node);
+
+  /// Unused, labels are handled by containing statements.
+  @override
+  visitLabel(node) => _unreachable(node);
+
+  /// Unused, handled by imports/exports.
+  @override
+  visitLibraryIdentifier(node) => _unreachable(node);
+
+  /// Unused, see [visitMapLiteral].
+  @override
+  visitMapLiteralEntry(node) => _unreachable(node);
+
+  /// Unused, see [_emitMethodDeclaration].
+  @override
+  visitMethodDeclaration(node) => _unreachable(node);
+
+  /// Unused, these are not visited.
+  @override
+  visitNativeClause(node) => _unreachable(node);
+
+  /// Unused, these are not visited.
+  @override
+  visitNativeFunctionBody(node) => _unreachable(node);
+
+  /// Unused, handled by [_emitConstructor].
+  @override
+  visitSuperConstructorInvocation(node) => _unreachable(node);
+
+  /// Unused, this can be handled when emitting the module if needed.
+  @override
+  visitScriptTag(node) => _unreachable(node);
+
+  /// Unused, see [_emitType].
+  @override
+  visitTypeArgumentList(node) => _unreachable(node);
+
+  /// Unused, see [_emitType].
+  @override
+  visitTypeParameter(node) => _unreachable(node);
+
+  /// Unused, see [_emitType].
+  @override
+  visitGenericFunctionType(node) => _unreachable(node);
+
+  /// Unused, see [_emitType].
+  @override
+  visitTypeParameterList(node) => _unreachable(node);
+
+  /// Unused, see [_emitClassHeritage].
+  @override
+  visitWithClause(node) => _unreachable(node);
 }
 
 /// 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.
 String jsLibraryName(String libraryRoot, LibraryElement library) {
   var uri = library.source.uri;
   if (uri.scheme == 'dart') {
     return uri.path;
@@ skipping 100 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }