Implement modular compilation

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 HashSet, HashMap, SplayTreeSet;
+import 'dart:collection' show HashMap, HashSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
-import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/ast/ast.dart' hide ConstantEvaluator;
-import 'package:analyzer/src/generated/constant.dart';
+
 //TODO(leafp): Remove deprecated dependency
 //ignore: DEPRECATED_MEMBER_USE
 import 'package:analyzer/src/generated/element.dart'
-    show DynamicElementImpl, DynamicTypeImpl, LocalVariableElementImpl;
+    show DynamicTypeImpl, LocalVariableElementImpl;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
-import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
-import 'package:analyzer/src/dart/ast/token.dart'
-    show StringToken, Token, TokenType;
+import 'package:analyzer/src/generated/resolver.dart'
+    show TypeProvider, NamespaceBuilder;
+import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
-import 'package:analyzer/src/task/strong/info.dart';
+import 'package:analyzer/src/summary/summarize_elements.dart'
+    show PackageBundleAssembler;
+import 'package:analyzer/src/task/strong/info.dart' show DynamicInvoke;
+
+import '../js_ast/js_ast.dart' as JS;
+import '../js_ast/js_ast.dart' show js;
+import '../closure/closure_annotator.dart' show ClosureAnnotator;
 
 import 'ast_builder.dart' show AstBuilder;
-import 'reify_coercions.dart' show CoercionReifier, Tuple2;
-
-import '../js/js_ast.dart' as JS;
-import '../js/js_ast.dart' show js;
-
-import '../closure/closure_annotator.dart' show ClosureAnnotator;
-import '../compiler.dart'
-    show AbstractCompiler, corelibOrder, getCorelibModuleName;
-import '../options.dart' show CodegenOptions;
-import '../utils.dart';
-
-import 'js_field_storage.dart';
+import 'compiler.dart'
+    show BuildUnit, CompilerOptions, JSModuleFile, ModuleFormat;
+import 'element_helpers.dart';
+import 'element_loader.dart' show ElementLoader;
+import 'extension_types.dart' show ExtensionTypeSet;
+import 'js_field_storage.dart' show findFieldsNeedingStorage;
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
-import 'js_module_item_order.dart';
-import 'js_names.dart';
-import 'js_printer.dart' show writeJsLibrary;
-import 'js_typeref_codegen.dart';
-import 'module_builder.dart';
-import 'nullable_type_inference.dart';
-import 'side_effect_analysis.dart';
+import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
+import 'module_builder.dart'
+    show LegacyModuleBuilder, NodeModuleBuilder, pathToJSIdentifier;
+import 'nullable_type_inference.dart' show NullableTypeInference;
+import 'reify_coercions.dart' show CoercionReifier;
+import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
+import 'source_map_printer.dart' show SourceMapPrintingContext;
+import 'package:source_maps/source_maps.dart';
 
-// Various dynamic helpers we call.
-// If renaming these, make sure to check other places like the
-// _runtime.js file and comments.
-// TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
-// import and generate calls to, rather than dart_runtime.js
-const DPUT = 'dput';
-const DLOAD = 'dload';
-const DINDEX = 'dindex';
-const DSETINDEX = 'dsetindex';
-const DCALL = 'dcall';
-const DSEND = 'dsend';
+class CodeGenerator extends GeneralizingAstVisitor
+    with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
+  final AnalysisContext context;
+  final CompilerOptions options;
+  final rules = new StrongTypeSystemImpl();
 
-class JSCodegenVisitor extends GeneralizingAstVisitor
-    with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
-  final AbstractCompiler compiler;
-  final CodegenOptions options;
-  final LibraryElement currentLibrary;
-  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
+  /// name scoping requirements.
+  final _libraries = new Map<LibraryElement, JS.Identifier>();
+
+  /// Imported libraries, and the temporaries used to refer to them.
+  final _imports = new Map<LibraryElement, JS.TemporaryId>();
+
+  /// The list of output module items, in the order they need to be emitted in.
+  final _moduleItems = <JS.ModuleItem>[];
 
   /// The global extension type table.
   final ExtensionTypeSet _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
-  final HashSet<FieldElement> _fieldsNeedingStorage;
+  HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   ///
   /// Usually a [SimpleIdentifier], but it can also be other expressions
   /// that are safe to evaluate multiple times, such as `this`.
   Expression _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   /// In an async* function, this represents the stream controller parameter.
   JS.TemporaryId _asyncStarController;
 
-  /// Imported libraries, and the temporaries used to refer to them.
-  final _imports = new Map<LibraryElement, JS.TemporaryId>();
-  final _exports = <String, String>{};
-  final _properties = <FunctionDeclaration>[];
-  final _privateNames = new HashMap<String, JS.TemporaryId>();
-  final _moduleItems = <JS.Statement>[];
+  final _privateNames =
+      new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _temps = new HashMap<Element, JS.TemporaryId>();
-  final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
-
-  /// The name for the library's exports inside itself.
-  /// `exports` was chosen as the most similar to ES module patterns.
+
   final _dartxVar = new JS.Identifier('dartx');
-  final _exportsVar = new JS.TemporaryId('exports');
   final _runtimeLibVar = new JS.Identifier('dart');
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
-  final TypeProvider _types;
+  final _hasDeferredSupertype = new HashSet<ClassElement>();
+
+  /// The  type provider from the current Analysis [context].
+  final TypeProvider types;
+
+  final LibraryElement dartCoreLibrary;
+  final LibraryElement dartJSLibrary;
+
+  /// The dart:async `StreamIterator<>` type.
+  final InterfaceType _asyncStreamIterator;
+
+  /// The dart:_interceptors JSArray element.
+  final ClassElement _jsArray;
 
   ConstFieldVisitor _constField;
 
-  ModuleItemLoadOrder _loader;
-
-  /// _interceptors.JSArray<E>, used for List literals.
-  ClassElement _jsArray;
-
   /// The current function body being compiled.
   FunctionBody _currentFunction;
 
-  /// The default value of the module object. See [visitLibraryDirective].
-  String _jsModuleValue;
-
-  bool _isDartRuntime;
-
-  JSCodegenVisitor(AbstractCompiler compiler, this.rules, this.currentLibrary,
-      this._extensionTypes, this._fieldsNeedingStorage)
-      : compiler = compiler,
-        options = compiler.options.codegenOptions,
-        _types = compiler.context.typeProvider {
-    _loader = new ModuleItemLoadOrder(_emitModuleItem);
-
-    var context = compiler.context;
-    var src = context.sourceFactory.forUri('dart:_interceptors');
-    var interceptors = context.computeLibraryElement(src);
-    _jsArray = interceptors.getType('JSArray');
-    _isDartRuntime = currentLibrary.source.uri.toString() == 'dart:_runtime';
-  }
-
-  TypeProvider get types => _types;
-
-  JS.Program emitLibrary(List<CompilationUnit> units) {
-    // Modify the AST to make coercions explicit.
-    units = new CoercionReifier().reify(units);
-
-    units.last.directives.forEach(_visit);
-
-    // Rather than directly visit declarations, we instead use [_loader] to
-    // visit them. It has the ability to sort elements on demand, so
-    // dependencies between top level items are handled with a minimal
-    // reordering of the user's input code. The loader will call back into
-    // this visitor via [_emitModuleItem] when it's ready to visit the item
-    // for real.
-    _loader.collectElements(currentLibrary, units);
-
+  /// Helper class for emitting elements in the proper order to allow
+  /// JS to load the module.
+  ElementLoader _loader;
+
+  BuildUnit _buildUnit;
+
+  CodeGenerator(AnalysisContext c, this.options, this._extensionTypes)
+      : context = c,
+        types = c.typeProvider,
+        _asyncStreamIterator =
+            _getLibrary(c, 'dart:async').getType('StreamIterator').type,
+        _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
+        dartCoreLibrary = _getLibrary(c, 'dart:core'),
+        dartJSLibrary = _getLibrary(c, 'dart:js');
+
+  LibraryElement get currentLibrary => _loader.currentElement.library;
+
+  /// The main entry point to JavaScript code generation.
+  ///
+  /// Takes the metadata for the build unit, as well as resolved trees and
+  /// errors, and computes the output module code and optionally the source map.
+  JSModuleFile compile(BuildUnit unit, List<CompilationUnit> compilationUnits,
+      List<String> errors) {
+    _buildUnit = unit;
+
+    var jsTree = _emitModule(compilationUnits);
+    var codeAndSourceMap = _writeJSText(unit, jsTree);
+
+    List<int> summary;
+    if (options.summarizeApi) {
+      var assembler = new PackageBundleAssembler();
+      compilationUnits
+          .map((u) => u.element.library)
+          .toSet()
+          .forEach(assembler.serializeLibraryElement);
+      summary = assembler.assemble().toBuffer();
+    }
+
+    return new JSModuleFile(
+        unit.name, errors, codeAndSourceMap.e0, codeAndSourceMap.e1, summary);
+  }
+
+  Tuple2<String, Map> _writeJSText(BuildUnit unit, JS.Program jsTree) {
+    var opts = new JS.JavaScriptPrintingOptions(
+        emitTypes: options.closure,
+        allowKeywordsInProperties: true,
+        allowSingleLineIfStatements: true);
+    JS.SimpleJavaScriptPrintingContext printer;
+    SourceMapBuilder sourceMap;
+    if (options.sourceMap) {
+      var sourceMapContext = new SourceMapPrintingContext();
+      sourceMap = sourceMapContext.sourceMap;
+      printer = sourceMapContext;
+    } else {
+      printer = new JS.SimpleJavaScriptPrintingContext();
+    }
+
+    jsTree.accept(new JS.Printer(opts, printer,
+        localNamer: new JS.TemporaryNamer(jsTree)));
+
+    if (options.sourceMap && options.sourceMapComment) {
+      printer.emit('\n//# sourceMappingURL=${unit.name}.js.map\n');
+    }
+
+    return new Tuple2(printer.getText(), sourceMap?.build(unit.name + '.js'));
+  }
+
+  JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
+    if (_moduleItems.isNotEmpty) {
+      throw new StateError('Can only call emitModule once.');
+    }
+
+    _fieldsNeedingStorage = findFieldsNeedingStorage(
+        compilationUnits.map((u) => u.element), _extensionTypes);
+
+    // Transform the AST to make coercions explicit.
+    compilationUnits = CoercionReifier.reify(compilationUnits);
+
+    // Initialize our library variables.
+    var items = <JS.ModuleItem>[];
+    for (var unit in compilationUnits) {
+      var library = unit.element.library;
+      if (unit.element != library.definingCompilationUnit) continue;
+
+      var libraryTemp = _isDartRuntime(library)
+          ? _runtimeLibVar
+          : new JS.TemporaryId(jsLibraryName(library));
+      _libraries[library] = libraryTemp;
+      items.add(new JS.ExportDeclaration(
+          js.call('const # = Object.create(null)', [libraryTemp])));
+
+      // dart:_runtime has a magic module that holds extenstion method symbols.
+      // TODO(jmesserly): find a cleaner design for this.
+      if (_isDartRuntime(library)) {
+        items.add(new JS.ExportDeclaration(
+            js.call('const # = Object.create(null)', [_dartxVar])));
+      }
+    }
+
+    // Collect all Element -> Node mappings, in case we need to forward declare
+    // any nodes.
+    var nodes = new HashMap<Element, AstNode>.identity();
+    compilationUnits.map(_collectElements).forEach(nodes.addAll);
+    _loader = new ElementLoader(_emitModuleItem, nodes);
+
+    // 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(visitCompilationUnit);
+
+    // Declare imports
+    _finishImports(items);
+
+    // Add the module's code (produced by visiting compilation units, above)
+    _copyAndFlattenBlocks(items, _moduleItems);
+
+    // Build the module.
+    var module = new JS.Program(items, name: _buildUnit.name);
+
+    // Optional: lower module format. Otherwise just return it.
+    switch (options.moduleFormat) {
+      case ModuleFormat.legacy:
+        return new LegacyModuleBuilder().build(module);
+      case ModuleFormat.node:
+        return new NodeModuleBuilder().build(module);
+      case ModuleFormat.es6:
+        return module;
+    }
+  }
+
+  /// Flattens blocks in [items] to a single list.
+  ///
+  /// This will not flatten blocks that are marked as being scopes.
+  void _copyAndFlattenBlocks(
+      List<JS.ModuleItem> result, Iterable<JS.ModuleItem> items) {
+    for (var item in items) {
+      if (item is JS.Block && !item.isScope) {
+        _copyAndFlattenBlocks(result, item.statements);
+      } else {
+        result.add(item);
+      }
+    }
+  }
+
+  String _libraryToModule(LibraryElement library) {
+    assert(!_libraries.containsKey(library));
+    var moduleName = _buildUnit.libraryToModule(library.source);
+    if (moduleName == null) {
+      throw new StateError('Could not find module containing "$library".');
+    }
+    return moduleName;
+  }
+
+  void _finishImports(List<JS.ModuleItem> items) {
+    var modules = new Map<String, List<LibraryElement>>();
+
+    for (var import in _imports.keys) {
+      modules.putIfAbsent(_libraryToModule(import), () => []).add(import);
+    }
+
+    String coreModuleName;
+    if (!_libraries.containsKey(dartCoreLibrary)) {
+      coreModuleName = _libraryToModule(dartCoreLibrary);
+    }
+    modules.forEach((module, libraries) {
+      // Generate import directives.
+      //
+      // Our import variables are temps and can get renamed. Since our renaming
+      // is integrated into js_ast, it is aware of this possibility and will
+      // generate an "as" if needed. For example:
+      //
+      //     import {foo} from 'foo';         // if no rename needed
+      //     import {foo as foo$} from 'foo'; // if rename was needed
+      //
+      var imports =
+          libraries.map((l) => new JS.NameSpecifier(_imports[l])).toList();
+      if (module == coreModuleName) {
+        imports.add(new JS.NameSpecifier(_runtimeLibVar));
+        imports.add(new JS.NameSpecifier(_dartxVar));
+      }
+      items.add(new JS.ImportDeclaration(
+          namedImports: imports, from: js.string(module, "'")));
+    });
+  }
+
+  /// Collect toplevel elements and nodes we need to emit, and returns
+  /// an ordered map of these.
+  static Map<Element, AstNode> _collectElements(CompilationUnit unit) {
+    var map = <Element, AstNode>{};
+    for (var declaration in unit.declarations) {
+      if (declaration is TopLevelVariableDeclaration) {
+        for (var field in declaration.variables.variables) {
+          map[field.element] = field;
+        }
+      } else {
+        map[declaration.element] = declaration;
+      }
+    }
+    return map;
+  }
+
+  void _emitModuleItem(AstNode node) {
     // TODO(jmesserly): ideally we could do this at a smaller granularity.
     // We'll need to be consistent about when we're generating functions, and
     // only run this on the outermost function.
-    inferNullableTypesInLibrary(units);
-
-    _constField = new ConstFieldVisitor(types, currentLibrary.source);
-
-    for (var unit in units) {
-      for (var decl in unit.declarations) {
-        if (decl is TopLevelVariableDeclaration) {
-          visitTopLevelVariableDeclaration(decl);
-        } else {
-          _loader.loadDeclaration(decl, decl.element);
-        }
-      }
-    }
-
-    // Flush any unwritten fields/properties.
-    _flushLibraryProperties(_moduleItems);
-
-    // Mark all qualified names as qualified or not, depending on if they need
-    // to be loaded lazily or not.
-    for (var elementIdPairs in _qualifiedIds) {
-      var element = elementIdPairs.e0;
-      var id = elementIdPairs.e1;
-      id.setQualified(!_loader.isLoaded(element));
-    }
-
-    var moduleBuilder = new ModuleBuilder(options.moduleFormat);
-
-    _exports.forEach(moduleBuilder.addExport);
-
-    var currentModuleName = compiler.getModuleName(currentLibrary.source.uri);
-    var items = <JS.ModuleItem>[];
-    if (!_isDartRuntime) {
-      if (currentLibrary.source.isInSystemLibrary) {
-        // Force the import order of runtime libs.
-        // TODO(ochafik): Reduce this to a minimum.
-        for (var libUri in corelibOrder.reversed) {
-          var moduleName = compiler.getModuleName(libUri);
-          if (moduleName == currentModuleName) continue;
-          moduleBuilder.addImport(moduleName, null);
-        }
-      }
-      moduleBuilder.addImport('dart/_runtime', _runtimeLibVar);
-
-      var dartxImport =
-          js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
-      items.add(dartxImport);
-    }
-    items.addAll(_moduleItems);
-
-    _imports.forEach((LibraryElement lib, JS.TemporaryId temp) {
-      moduleBuilder.addImport(compiler.getModuleName(lib.source.uri), temp,
-          isLazy: _isDartRuntime || !_loader.libraryIsLoaded(lib));
-    });
-
-    // TODO(jmesserly): scriptTag support.
-    // Enable this if we know we're targetting command line environment?
-    // It doesn't work in browser.
-    // var jsBin = compiler.options.runnerOptions.v8Binary;
-    // String scriptTag = null;
-    // if (library.library.scriptTag != null) scriptTag = '/usr/bin/env $jsBin';
-    return moduleBuilder.build(
-        currentModuleName, _jsModuleValue, _exportsVar, items);
-  }
-
-  void _emitModuleItem(AstNode node) {
-    // Attempt to group adjacent properties.
-    if (node is! FunctionDeclaration) _flushLibraryProperties(_moduleItems);
+    inferNullableTypes(node);
 
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
   }
 
   @override
-  void visitLibraryDirective(LibraryDirective node) {
-    assert(_jsModuleValue == null);
-
-    var jsName = findAnnotation(node.element, isJSAnnotation);
-    _jsModuleValue =
-        getConstantField(jsName, 'name', types.stringType)?.toStringValue();
-  }
+  void visitCompilationUnit(CompilationUnit unit) {
+    _constField = new ConstFieldVisitor(types, unit.element.source);
+
+    for (var declaration in unit.declarations) {
+      var element = declaration.element;
+      if (element != null) {
+        _loader.emitDeclaration(element);
+      } else {
+        declaration.accept(this);
+      }
+    }
+    for (var directive in unit.directives) {
+      directive.accept(this);
+    }
+  }
+
+  @override
+  void visitLibraryDirective(LibraryDirective node) {}
 
   @override
   void visitImportDirective(ImportDirective node) {
-    // Nothing to do yet, but we'll want to convert this to an ES6 import once
-    // we have support for modules.
+    // 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?
   }
 
   @override
   void visitPartDirective(PartDirective node) {}
+
   @override
   void visitPartOfDirective(PartOfDirective node) {}
 
   @override
   void visitExportDirective(ExportDirective node) {
-    var exportName = emitLibraryName(node.uriElement);
-
-    var currentLibNames = currentLibrary.publicNamespace.definedNames;
-
-    var args = [_exportsVar, exportName];
-    if (node.combinators.isNotEmpty) {
-      var shownNames = <JS.Expression>[];
-      var hiddenNames = <JS.Expression>[];
-
-      var show = node.combinators.firstWhere((c) => c is ShowCombinator,
-          orElse: () => null) as ShowCombinator;
-      var hide = node.combinators.firstWhere((c) => c is HideCombinator,
-          orElse: () => null) as HideCombinator;
-      if (show != null) {
-        shownNames.addAll(show.shownNames
-            .map((i) => i.name)
-            .where((s) => !currentLibNames.containsKey(s))
-            .map((s) => js.string(s, "'")));
-      }
-      if (hide != null) {
-        hiddenNames.addAll(hide.hiddenNames.map((i) => js.string(i.name, "'")));
-      }
-      args.add(new JS.ArrayInitializer(shownNames));
-      args.add(new JS.ArrayInitializer(hiddenNames));
-    }
-
-    _moduleItems.add(js.statement('dart.export(#);', [args]));
-  }
-
-  JS.Identifier _initSymbol(JS.Identifier id) {
-    var s =
-        js.statement('const # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
-    _moduleItems.add(s);
-    return id;
-  }
-
-  // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
-  // until we have better name tracking.
-  String get _SYMBOL {
-    var name = currentLibrary.name;
-    if (name == 'dart.core' || name == 'dart._internal') return 'dart.JsSymbol';
-    return 'Symbol';
-  }
-
-  bool isPublic(String name) => !name.startsWith('_');
+    ExportElement element = node.element;
+    var currentLibrary = element.library;
+
+    var currentNames = currentLibrary.publicNamespace.definedNames;
+    var exportedNames =
+        new NamespaceBuilder().createExportNamespaceForDirective(element);
+
+    // TODO(jmesserly): we could collect all of the names for bulk re-export,
+    // but this is easier to implement for now.
+    void emitExport(Element export, {String suffix: ''}) {
+      var name = _emitTopLevelName(export, suffix: suffix);
+      _moduleItems.add(js.statement(
+          '#.# = #;', [emitLibraryName(currentLibrary), name.selector, name]));
+    }
+
+    for (var export in exportedNames.definedNames.values) {
+      // Don't allow redefining names from this library.
+      if (currentNames.containsKey(export.name)) continue;
+
+      _loader.emitDeclaration(export);
+      if (export is ClassElement && export.typeParameters.isNotEmpty) {
+        // Export the generic name as well.
+        // TODO(jmesserly): revisit generic classes
+        emitExport(export, suffix: r'$');
+      }
+      emitExport(export);
+    }
+  }
 
   @override
   visitAsExpression(AsExpression node) {
     var from = getStaticType(node.expression);
     var to = node.type.type;
 
     var fromExpr = _visit(node.expression);
 
     // Skip the cast if it's not needed.
     if (rules.isSubtypeOf(from, to)) return fromExpr;
 
     // All Dart number types map to a JS double.
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
-      if (from != _types.intType && to == _types.intType) {
+      if (from != types.intType && to == types.intType) {
         return js.call('dart.asInt(#)', [fromExpr]);
       }
 
       // A no-op in JavaScript.
       return fromExpr;
     }
 
     return js.call('dart.as(#, #)', [fromExpr, _emitTypeName(to)]);
   }
 
@@ skipping 12 matching lines @@
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
     }
     return result;
   }
 
   String _jsTypeofName(DartType t) {
     if (_isNumberInJS(t)) return 'number';
-    if (t == _types.stringType) return 'string';
-    if (t == _types.boolType) return 'boolean';
+    if (t == types.stringType) return 'string';
+    if (t == types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
-    var element = node.element;
-    var type = element.type;
-    var name = element.name;
+    FunctionTypeAliasElement element = node.element;
 
-    var fnType = annotate(
-        js.statement('const # = dart.typedef(#, () => #);', [
-          name,
-          js.string(name, "'"),
-          _emitTypeName(type, lowerTypedef: true)
+    JS.Expression body = annotate(
+        js.call('dart.typedef(#, () => #)', [
+          js.string(element.name, "'"),
+          _emitTypeName(element.type, lowerTypedef: true)
         ]),
         node,
-        node.element);
+        element);
 
-    return _finishClassDef(type, fnType);
+    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
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
-    var element = node.element;
+    ClassElement element = node.element;
 
     // Forward all generative constructors from the base class.
-    var body = <JS.Method>[];
+    var methods = <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)]) as JS.Fun;
-        body.add(new JS.Method(_constructorName(ctor), fun));
+        methods.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
-    var cls = _emitClassDeclaration(element, body);
-    return _finishClassDef(element.type, cls);
+    var classExpr = _emitClassExpression(element, methods);
+
+    var typeFormals = element.typeParameters;
+    if (typeFormals.isNotEmpty) {
+      return _defineClassTypeArguments(
+          element, typeFormals, new JS.ClassDeclaration(classExpr));
+    } else {
+      return js.statement('# = #;', [_emitTopLevelName(element), classExpr]);
+    }
   }
 
-  JS.Statement _emitJsType(String dartClassName, DartObject jsName) {
-    var jsTypeName =
-        getConstantField(jsName, 'name', types.stringType)?.toStringValue();
+  JS.Statement _emitJsType(Element e) {
+    var jsTypeName = getAnnotationName(e, isJSAnnotation);
+    if (jsTypeName == null || jsTypeName == e.name) return null;
 
-    if (jsTypeName != null && jsTypeName != dartClassName) {
-      // We export the JS type as if it was a Dart type. For example this allows
-      // `dom.InputElement` to actually be HTMLInputElement.
-      // TODO(jmesserly): if we had the JS name on the Element, we could just
-      // generate it correctly when we refer to it.
-      if (isPublic(dartClassName)) _addExport(dartClassName);
-      return js.statement('const # = #;', [dartClassName, jsTypeName]);
-    }
-    return null;
+    // We export the JS type as if it was a Dart type. For example this allows
+    // `dom.InputElement` to actually be HTMLInputElement.
+    // TODO(jmesserly): if we had the JS name on the Element, we could just
+    // generate it correctly when we refer to it.
+    return js.statement('# = #;', [_emitTopLevelName(e), jsTypeName]);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     var classElem = node.element;
-    var type = classElem.type;
-    var jsName = findAnnotation(classElem, isJSAnnotation);
 
-    if (jsName != null) return _emitJsType(node.name.name, jsName);
+    // If this is a JavaScript type, emit it now and then exit.
+    var jsTypeDef = _emitJsType(classElem);
+    if (jsTypeDef != null) return jsTypeDef;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
       }
     }
 
     var allFields = new List.from(fields)..addAll(staticFields);
-
-    var classDecl = _emitClassDeclaration(
+    var classExpr = _emitClassExpression(
         classElem, _emitClassMethods(node, ctors, fields),
         fields: allFields);
 
-    String jsPeerName;
-    var jsPeer = findAnnotation(classElem, isJsPeerInterface);
-    // Only look at "Native" annotations on registered extension types.
-    // E.g., we're current ignoring the ones in dart:html.
-    if (jsPeer == null && _extensionTypes.contains(classElem)) {
-      jsPeer = findAnnotation(classElem, isNativeAnnotation);
-    }
-    if (jsPeer != null) {
-      jsPeerName =
-          getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
-      if (jsPeerName.contains(',')) {
-        jsPeerName = jsPeerName.split(',')[0];
-      }
+    var body = <JS.Statement>[];
+    var extensions = _extensionsToImplement(classElem);
+    _initExtensionSymbols(classElem, methods, fields, body);
+
+    // Emit the class, e.g. `core.Object = class Object { ... }`
+    JS.Expression className = _defineClass(classElem, classExpr, body);
+
+    // Emit things that come after the ES6 `class ... { ... }`.
+    _setBaseClass(classElem, className, body);
+    _defineNamedConstructors(ctors, body, className);
+    _emitVirtualFields(fields, className, body);
+    _emitClassSignature(methods, classElem, ctors, extensions, className, body);
+    _defineExtensionMembers(extensions, className, body);
+    _emitClassMetadata(node.metadata, className, body);
+
+    JS.Statement classDef = _statement(body);
+    var typeFormals = classElem.typeParameters;
+    if (typeFormals.isNotEmpty) {
+      classDef = _defineClassTypeArguments(classElem, typeFormals, classDef);
     }
 
-    var body = _finishClassMembers(classElem, classDecl, ctors, fields,
-        staticFields, methods, node.metadata, jsPeerName);
+    body = <JS.Statement>[classDef];
+    _emitStaticFields(staticFields, classElem, body);
+    _registerExtensionType(classElem, body);
+    return _statement(body);
+  }
 
-    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.
-      // If we wanted to support laziness, we could defer the hookup until
-      // the end of the Dart library cycle load.
-      assert(_loader.isLoaded(classElem));
-
-      // TODO(jmesserly): this copies the dynamic members.
-      // Probably fine for objects coming from JS, but not if we actually
-      // want to support construction of instances with generic types other
-      // than dynamic. See issue #154 for Array and List<E> related bug.
-      var copyMembers = js.statement(
-          'dart.registerExtension(dart.global.#, #);',
-          [_propertyName(jsPeerName), classElem.name]);
-      return _statement([result, copyMembers]);
+  JS.Expression _defineClass(ClassElement classElem,
+      JS.ClassExpression classExpr, List<JS.Statement> body) {
+    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 = classExpr.name;
+      body.add(new JS.ClassDeclaration(classExpr));
+    } else {
+      className = _emitTopLevelName(classElem);
+      body.add(js.statement('# = #;', [className, classExpr]));
     }
-    return result;
+    return className;
   }
 
   List<JS.Identifier> _emitTypeFormals(List<TypeParameterElement> typeFormals) {
     return typeFormals
         .map((t) => new JS.Identifier(t.name))
         .toList(growable: false);
   }
 
   /// Emits a field declaration for TypeScript & Closure's ES6_TYPED
   /// (e.g. `class Foo { i: string; }`)
   JS.VariableDeclarationList _emitTypeScriptField(FieldDeclaration field) {
     return new JS.VariableDeclarationList(
         field.isStatic ? 'static' : null,
         field.fields.variables
             .map((decl) => new JS.VariableInitialization(
                 new JS.Identifier(
                     // TODO(ochafik): use a refactored _emitMemberName instead.
                     decl.name.name,
                     type: emitTypeRef(decl.element.type)),
                 null))
             .toList(growable: false));
   }
 
   @override
   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; }') as JS.Fun);
     var fields = new List<FieldElement>.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) as JS.Fun);
 
     // Create enum class
-    var classExpr = new JS.ClassExpression(
-        id, _emitClassHeritage(element), [constructor, toStringF]);
-    var result = <JS.Statement>[js.statement('#', classExpr)];
+    var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
+        _emitClassHeritage(element), [constructor, toStringF]);
+    var id = _emitTopLevelName(element);
+    var result = [
+      js.statement('# = #', [id, 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(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)]));
 
-    if (isPublic(type.name)) _addExport(type.name);
     return _statement(result);
   }
 
-  /// Given a class element and body, complete the class declaration.
-  /// This handles generic type parameters, laziness (in library-cycle cases),
-  /// and ensuring dependencies are loaded first.
-  JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
-    var name = type.name;
-    var genericName = '$name\$';
+  /// Wraps a possibly generic class in its type arguments.
+  JS.Statement _defineClassTypeArguments(TypeDefiningElement element,
+      List<TypeParameterElement> formals, JS.Statement body) {
+    assert(formals.isNotEmpty);
+    var genericDef =
+        js.statement('# = dart.generic((#) => { #; return #; });', [
+      _emitTopLevelName(element, suffix: r'$'),
+      _emitTypeFormals(formals),
+      body,
+      element.name
+    ]);
 
-    JS.Statement genericDef = null;
-    if (_typeFormalsOf(type).isNotEmpty) {
-      genericDef = _emitGenericClassDef(type, body);
-    }
-    // The base class and all mixins must be declared before this class.
-    if (!_loader.isLoaded(type.element)) {
-      // TODO(jmesserly): the lazy class def is a simple solution for now.
-      // We may want to consider other options in the future.
-
-      if (genericDef != null) {
-        return js.statement(
-            '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }',
-            [genericDef, _exportsVar, _propertyName(name), genericName]);
-      }
-
-      return js.statement(
-          'dart.defineLazyClass(#, { get #() { #; return #; } });',
-          [_exportsVar, _propertyName(name), body, name]);
-    }
-
-    if (isPublic(name)) _addExport(name);
-
-    if (genericDef != null) {
-      var dynType = fillDynamicTypeArgs(type, types);
-      var genericInst = _emitTypeName(dynType, lowerGeneric: true);
-      return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
-    }
-    return body;
+    var dynType = fillDynamicTypeArgs(element.type);
+    var genericInst = _emitTypeName(dynType, lowerGeneric: true);
+    return js.statement(
+        '{ #; # = #; }', [genericDef, _emitTopLevelName(element), genericInst]);
   }
 
-  JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
-    var name = type.name;
-    var genericName = '$name\$';
-    var typeParams = _typeFormalsOf(type).map((p) => p.name);
-    if (isPublic(name)) _addExport(genericName);
-    return js.statement('const # = dart.generic(function(#) { #; return #; });',
-        [genericName, typeParams, body, name]);
-  }
-
-  final _hasDeferredSupertype = new HashSet<ClassElement>();
-
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
         var typeElement = typeArg.element;
         // FIXME(vsm): This does not track mutual recursive dependences.
         if (current == typeElement || _deferIfNeeded(typeArg, current)) {
           return true;
         }
       }
     }
     return false;
   }
 
-  JS.Statement _emitClassDeclaration(
+  JS.ClassExpression _emitClassExpression(
       ClassElement element, List<JS.Method> methods,
       {List<FieldDeclaration> fields}) {
     String name = element.name;
     var heritage = _emitClassHeritage(element);
     var typeParams = _emitTypeFormals(element.typeParameters);
     var jsFields = fields?.map(_emitTypeScriptField)?.toList();
 
-    // Workaround for Closure: super classes must be qualified paths.
-    // TODO(jmesserly): is there a bug filed? we need to get out of the business
-    // of working around bugs in other transpilers...
-    JS.Statement workaroundSuper = null;
-    if (options.closure && heritage is JS.Call) {
-      var superVar = new JS.TemporaryId('$name\$super');
-      workaroundSuper = js.statement('const # = #;', [superVar, heritage]);
-      heritage = superVar;
-    }
-    var decl = new JS.ClassDeclaration(new JS.ClassExpression(
-        new JS.Identifier(name), heritage, methods,
-        typeParams: typeParams, fields: jsFields));
-    if (workaroundSuper != null) {
-      return new JS.Block([workaroundSuper, decl]);
-    }
-    return decl;
+    return new JS.ClassExpression(new JS.Identifier(name), heritage, methods,
+        typeParams: typeParams, fields: jsFields);
   }
 
   JS.Expression _emitClassHeritage(ClassElement element) {
     var type = element.type;
     if (type.isObject) return null;
 
-    // Assume we can load eagerly, until proven otherwise.
     _loader.startTopLevel(element);
 
     // Find the super type
     JS.Expression heritage;
     var supertype = type.superclass;
     if (_deferIfNeeded(supertype, element)) {
       // Fall back to raw type.
-      supertype = fillDynamicTypeArgs(supertype.element.type, _types);
+      supertype = fillDynamicTypeArgs(supertype.element.type);
       _hasDeferredSupertype.add(element);
     }
     heritage = _emitTypeName(supertype);
 
     if (type.mixins.isNotEmpty) {
       var mixins = type.mixins.map(_emitTypeName).toList();
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
 
     _loader.finishTopLevel(element);
+
     return heritage;
   }
 
   /// Provide Dart getters and setters that forward to the underlying native
   /// field.  Note that the Dart names are always symbolized to avoid
   /// 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 name = decl.name.name;
-        var annotation = findAnnotation(field, isJsName);
-        if (annotation != null) {
-          name = getConstantField(annotation, 'name', types.stringType)
-              ?.toStringValue();
-        }
+        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');
           fn = new JS.Fun(
@@ skipping 69 matching lines @@
     // Iterable, we know the adapter is already there, so we can skip it as a
     // 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('Symbol.iterator'),
         js.call('function() { return new dart.JsIterator(this.#); }',
             [_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.Statement classDecl,
-      List<ConstructorDeclaration> ctors,
-      List<FieldDeclaration> fields,
-      List<FieldDeclaration> staticFields,
-      List<MethodDeclaration> methods,
-      List<Annotation> metadata,
-      String jsPeerName) {
-    var name = classElem.name;
-    var body = <JS.Statement>[];
+  /// Gets the JS pper for this Dart type, if any, otherwise null.

[vsm, 2016/04/14 00:18:24]

pper -> peer

[Jennifer Messerly, 2016/04/14 18:28:40]

Done.

+  ///
+  /// For example for dart:_interceptors `JSArray` this will return "Array",
+  /// referring to the JavaScript built-in `Array` type.
+  String _getJSPeerName(ClassElement classElem) {
+    var jsPeerName = getAnnotationName(
+        classElem,
+        (a) =>
+            isJsPeerInterface(a) ||
+            isNativeAnnotation(a) && _extensionTypes.contains(classElem));
+    if (jsPeerName != null && jsPeerName.contains(',')) {
+      jsPeerName = jsPeerName.split(',')[0];
+    }
+    return jsPeerName;
+  }
 
-    if (_extensionTypes.contains(classElem)) {
-      var dartxNames = <JS.Expression>[];
-      for (var m in methods) {
-        if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
-          dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
+  void _registerExtensionType(ClassElement classElem, List<JS.Statement> body) {
+    var jsPeerName = _getJSPeerName(classElem);
+    if (jsPeerName != null) {
+      // TODO(jmesserly): this copies the dynamic members.
+      // Probably fine for objects coming from JS, but not if we actually
+      // want to support construction of instances with generic types other
+      // than dynamic. See issue #154 for Array and List<E> related bug.
+      body.add(js.statement('dart.registerExtension(dart.global.#, #);',
+          [_propertyName(jsPeerName), _emitTopLevelName(classElem)]));
+    }
+  }
+
+  void _setBaseClass(ClassElement classElem, JS.Expression className,
+      List<JS.Statement> body) {
+    String jsPeerName = _getJSPeerName(classElem);
+    JS.Expression newBaseClass;
+    if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
+      // TODO(jmesserly): we should really just extend Array in the first place.
+      newBaseClass = js.call('dart.global.#', [jsPeerName]);
+    } else if (_hasDeferredSupertype.contains(classElem)) {
+      newBaseClass = _emitTypeName(classElem.type.superclass);
+    }
+    if (newBaseClass != null) {
+      body.add(
+          js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
+    }
+  }
+
+  /// Emits instance fields, if they are virtual
+  /// (in other words, they override a getter/setter pair).
+  void _emitVirtualFields(List<FieldDeclaration> fields,
+      JS.Expression className, List<JS.Statement> body) {
+    for (FieldDeclaration member in fields) {
+      for (VariableDeclaration field in member.fields.variables) {
+        if (_fieldsNeedingStorage.contains(field.element)) {
+          body.add(_overrideField(className, field.element));
         }
       }
-      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, allowExtensions: false));
-            }
-          }
-        }
-      }
-      if (dartxNames.isNotEmpty) {
-        body.add(js.statement('dart.defineExtensionNames(#)',
-            [new JS.ArrayInitializer(dartxNames, multiline: true)]));
-      }
     }
+  }
 
-    body.add(classDecl);
-
-    // 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)]));
-    }
-
-    // Deferred Superclass
-    if (_hasDeferredSupertype.contains(classElem)) {
-      body.add(js.statement('#.prototype.__proto__ = #.prototype;',
-          [name, _emitTypeName(classElem.type.superclass)]));
-    }
-
-    // Interfaces
-    if (classElem.interfaces.isNotEmpty) {
-      body.add(js.statement('#[dart.implements] = () => #;', [
-        name,
-        new JS.ArrayInitializer(new List<JS.Expression>.from(
-            classElem.interfaces.map(_emitTypeName)))
-      ]));
-    }
-
-    // Named constructors
+  void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
+      List<JS.Statement> body, JS.Expression className) {
     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)]));
+            [className, _emitMemberName(member.name.name, isStatic: true)]));
       }
     }
+  }
 
-    // Emits instance fields, if they are virtual
-    // (in other words, they override a getter/setter pair).
-    for (FieldDeclaration member in fields) {
+  /// Emits static fields for a class, and initialize them eagerly if possible,
+  /// otherwise define them as lazy properties.
+  void _emitStaticFields(List<FieldDeclaration> staticFields,
+      ClassElement classElem, List<JS.Statement> body) {
+    var lazyStatics = <VariableDeclaration>[];
+    for (FieldDeclaration member in staticFields) {
       for (VariableDeclaration field in member.fields.variables) {
-        if (_fieldsNeedingStorage.contains(field.element)) {
-          body.add(_overrideField(field.element));
+        JS.Statement eagerField = _emitConstantStaticField(classElem, field);
+        if (eagerField != null) {
+          body.add(eagerField);
+        } else {
+          lazyStatics.add(field);
         }
       }
     }
+    if (lazyStatics.isNotEmpty) {
+      body.add(_emitLazyFields(classElem, lazyStatics));
+    }
+  }
 
-    // Emit the signature on the class recording the runtime type information
-    var extensions = _extensionsToImplement(classElem);
-    {
-      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);
-          }
-        }
-      }
+  void _emitClassMetadata(List<Annotation> metadata, JS.Expression className,
+      List<JS.Statement> body) {
+    // TODO(vsm): Make this optional per #268.
+    // Metadata
+    if (metadata.isNotEmpty) {
+      body.add(js.statement('#[dart.metadata] = () => #;', [
+        className,
+        new JS.ArrayInitializer(
+            new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
+      ]));
+    }
+  }
 
-      var tCtors = <JS.Property>[];
-      for (ConstructorDeclaration node in ctors) {
-        var memberName = _constructorName(node.element);
-        var element = node.element;
-        var parts = _emitFunctionTypeParts(element.type, node.parameters);
-        var property =
-            new JS.Property(memberName, new JS.ArrayInitializer(parts));
-        tCtors.add(property);
-      }
-
-      JS.Property build(String name, List<JS.Property> elements) {
-        var o =
-            new JS.ObjectInitializer(elements, multiline: elements.length > 1);
-        var e = js.call('() => #', o);
-        return new JS.Property(_propertyName(name), e);
-      }
-      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 || extensions.isNotEmpty) {
-        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.
+  void _defineExtensionMembers(List<ExecutableElement> extensions,
+      JS.Expression className, List<JS.Statement> body) {
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     if (extensions.isNotEmpty) {
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
         methodNames.add(_elementMemberName(e));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
-        name,
+        className,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
+  }
 
-    // TODO(vsm): Make this optional per #268.
-    // Metadata
-    if (metadata.isNotEmpty) {
-      body.add(js.statement('#[dart.metadata] = () => #;', [
-        name,
-        new JS.ArrayInitializer(
-            new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
+  /// Emit the signature on the class recording the runtime type information
+  void _emitClassSignature(
+      List<MethodDeclaration> methods,
+      ClassElement classElem,
+      List<ConstructorDeclaration> ctors,
+      List<ExecutableElement> extensions,
+      JS.Expression className,
+      List<JS.Statement> body) {
+    if (classElem.interfaces.isNotEmpty) {
+      body.add(js.statement('#[dart.implements] = () => #;', [
+        className,
+        new JS.ArrayInitializer(new List<JS.Expression>.from(
+            classElem.interfaces.map(_emitTypeName)))
       ]));
     }
 
-    // Emits static fields. These are eager initialized if possible, otherwise
-    // they are made lazy.
-    var lazyStatics = <VariableDeclaration>[];
-    for (FieldDeclaration member in staticFields) {
-      for (VariableDeclaration field in member.fields.variables) {
-        JS.Statement eagerField = _emitConstantStaticField(classElem, field);
-        if (eagerField != null) {
-          body.add(eagerField);
+    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 {
-          lazyStatics.add(field);
+          tMethods.add(property);
         }
       }
     }
-    if (lazyStatics.isNotEmpty) {
-      body.add(_emitLazyFields(classElem, lazyStatics));
+
+    var tCtors = <JS.Property>[];
+    for (ConstructorDeclaration node in ctors) {
+      var memberName = _constructorName(node.element);
+      var element = node.element;
+      var parts = _emitFunctionTypeParts(element.type, node.parameters);
+      var property =
+          new JS.Property(memberName, new JS.ArrayInitializer(parts));
+      tCtors.add(property);
     }
 
-    return _statement(body);
+    JS.Property build(String name, List<JS.Property> elements) {
+      var o =
+          new JS.ObjectInitializer(elements, multiline: elements.length > 1);
+      var e = js.call('() => #', o);
+      return new JS.Property(_propertyName(name), e);
+    }
+    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 || extensions.isNotEmpty) {
+      var sig = new JS.ObjectInitializer(sigFields);
+      body.add(js.statement('dart.setSignature(#, #);', [className, sig]));
+    }
+  }
+
+  /// Ensure `dartx.` symbols we will use are present.
+  void _initExtensionSymbols(
+      ClassElement classElem,
+      List<MethodDeclaration> methods,
+      List<FieldDeclaration> fields,
+      List<JS.Statement> body) {
+    if (_extensionTypes.contains(classElem)) {
+      var dartxNames = <JS.Expression>[];
+      for (var m in methods) {
+        if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
+          dartxNames.add(_elementMemberName(m.element, allowExtensions: 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, allowExtensions: false));
+            }
+          }
+        }
+      }
+      if (dartxNames.isNotEmpty) {
+        body.add(js.statement('dart.defineExtensionNames(#)',
+            [new JS.ArrayInitializer(dartxNames, multiline: true)]));
+      }
+    }
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.contains(element)) return members;
 
     // Collect all extension types we implement.
     var type = element.type;
     var types = new Set<ClassElement>();
     _collectExtensions(type, types);
@@ skipping 24 matching lines @@
     if (_extensionTypes.contains(element)) types.add(element);
     for (var m in type.mixins.reversed) {
       _collectExtensions(m, types);
     }
     for (var i in type.interfaces) {
       _collectExtensions(i, types);
     }
     _collectExtensions(type.superclass, types);
   }
 
-  JS.Statement _overrideField(FieldElement e) {
+  JS.Statement _overrideField(JS.Expression className, FieldElement e) {
     var cls = e.enclosingElement;
     return js.statement('dart.virtualField(#, #)',
-        [cls.name, _emitMemberName(e.name, type: cls.type)]);
+        [className, _emitMemberName(e.name, type: cls.type)]);
   }
 
   /// Generates the implicit default constructor for class C of the form
   /// `C() : super() {}`.
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node, List<FieldDeclaration> fields) {
     assert(_hasUnnamedConstructor(node.element) == fields.isNotEmpty);
 
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
@@ skipping 107 matching lines @@
     // Other default constructors use the class name, as they aren't called
     // from call sites, but rather from Object's constructor.
     // TODO(jmesserly): revisit in the context of Dart metaclasses, and cleaning
     // up constructors to integrate more closely with ES6.
     return _propertyName(ctor.isFactory ? 'new' : ctor.enclosingElement.name);
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node, List<FieldDeclaration> fields) {
     var body = <JS.Statement>[];
+    ClassDeclaration cls = node.parent;
 
     // Generate optional/named argument value assignment. These can not have
     // side effects, and may be used by the constructor's initializers, so it's
     // nice to do them first.
     // Also for const constructors we need to ensure default values are
     // available for use by top-level constant initializers.
-    ClassDeclaration cls = node.parent;
     if (node.constKeyword != null) _loader.startTopLevel(cls.element);
     var init = _emitArgumentInitializers(node, constructor: true);
     if (node.constKeyword != null) _loader.finishTopLevel(cls.element);
     if (init != null) body.add(init);
 
     // Redirecting constructors: these are not allowed to have initializers,
     // and the redirecting ctor invocation runs before field initializers.
     var redirectCall = node.initializers.firstWhere(
         (i) => i is RedirectingConstructorInvocation,
         orElse: () => null);
@@ skipping 35 matching lines @@
     ConstructorElement superCtor;
     if (node != null) {
       superCtor = node.staticElement;
     } else {
       // Get the supertype's unnamed constructor.
       superCtor = element.supertype.element.unnamedConstructor;
       if (superCtor == null) {
         // This will only happen if the code has errors:
         // we're trying to generate an implicit constructor for a type where
         // we don't have a default constructor in the supertype.
-        assert(options.forceCompile);
+        assert(options.unsafeForceCompile);
         return null;
       }
     }
 
     if (superCtor == null) {
       print('Error generating: ${element.displayName}');
     }
     if (superCtor.name == '' && !_shouldCallUnnamedSuperCtor(element)) {
       return null;
     }
@@ skipping 158 matching lines @@
     }
   }
 
   JS.Fun _emitNativeFunctionBody(MethodDeclaration node) {
     if (node.isStatic) {
       // TODO(vsm): Do we need to handle this case?
       return null;
     }
 
     var params = visitFormalParameterList(node.parameters, destructure: false);
-    String name = node.name.name;
-    var annotation = findAnnotation(node.element, isJsName);
-    if (annotation != null) {
-      name = getConstantField(annotation, 'name', types.stringType)
-          ?.toStringValue();
-    }
+    String name =
+        getAnnotationName(node.element, isJSAnnotation) ?? node.name.name;
     if (node.isGetter) {
       return new JS.Fun(params, js.statement('{ return this.#; }', [name]));
     } else if (node.isSetter) {
       return new JS.Fun(
           params, js.statement('{ this.# = #; }', [name, params.last]));
     } else {
       return new JS.Fun(
           params, js.statement('{ return this.#(#); }', [name, params]));
     }
   }
@@ skipping 49 matching lines @@
         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) {
-      // Add these later so we can use getter/setter syntax.
-      _properties.add(node);
-      return null;
+      // If we have a getter/setter pair, they need to be defined together.
+      PropertyAccessorElement element = node.element;
+      var props = <JS.Method>[];
+      var getter = element.variable.getter;
+      if (getter != null) {
+        props.add(_loader.customEmitDeclaration(getter, _emitTopLevelProperty));
+      }
+      var setter = element.variable.setter;
+      if (setter != null) {
+        props.add(_loader.customEmitDeclaration(setter, _emitTopLevelProperty));
+      }
+
+      return js.statement('dart.copyProperties(#, { # });',
+          [emitLibraryName(currentLibrary), props]);
     }
 
     var body = <JS.Statement>[];
-    _flushLibraryProperties(body);
-
-    var name = node.name.name;
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
-    var id = new JS.Identifier(name);
-    body.add(annotate(new JS.FunctionDeclaration(id, fn), node, node.element));
-    if (!_isDartRuntime) {
-      body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
+    var element = node.element;
+    var nameExpr = _emitTopLevelName(element);
+    body.add(annotate(js.statement('# = #', [nameExpr, fn]), node, element));
+    if (!_isDartRuntime(element.library)) {
+      body.add(_emitFunctionTagged(nameExpr, element.type, topLevel: true)
           .toStatement());
     }
 
-    if (isPublic(name)) {
-      _addExport(name, getJSExportName(node.element, types) ?? name);
-    }
     return _statement(body);
   }
 
   bool _isInlineJSFunction(FunctionExpression functionExpression) {
     var body = functionExpression.body;
     if (body is ExpressionFunctionBody) {
       return _isJSInvocation(body.expression);
     } else if (body is BlockFunctionBody) {
-      if (body.block.statements.length == 1) {
-        var stat = body.block.statements.single;
+      var statements = body.block.statements;
+      if (statements.length == 1) {
+        var stat = statements[0];
         if (stat is ReturnStatement) {
           return _isJSInvocation(stat.expression);
         }
       }
     }
     return false;
   }
 
   bool _isJSInvocation(Expression expr) =>
       expr is MethodInvocation && isInlineJS(expr.methodName.staticElement);
@@ skipping 55 matching lines @@
     var name = type.name;
     var lazy = topLevel && !_typeIsLoaded(type);
 
     if (type is FunctionType && (name == '' || name == null)) {
       if (type.returnType.isDynamic &&
           type.optionalParameterTypes.isEmpty &&
           type.namedParameterTypes.isEmpty &&
           type.normalParameterTypes.every((t) => t.isDynamic)) {
         return js.call('dart.fn(#)', [fn]);
       }
-      if (lazy) {
-        return js.call('dart.fn(#, () => #)', [fn, _emitFunctionRTTI(type)]);
-      }
-      return js.call('dart.fn(#, #)', [fn, _emitFunctionTypeParts(type)]);
+
+      String code = lazy ? '() => dart.definiteFunctionType(#)' : '#';
+      return js.call('dart.fn(#, $code)', [fn, _emitFunctionTypeParts(type)]);
     }
     throw 'Function has non function type: $type';
   }
 
   /// Emits an arrow FunctionExpression node.
   ///
   /// This should be used for all places in Dart's AST where FunctionExpression
   /// appears and the function is actually in an Expression context. These
   /// correspond to arrow functions in Dart.
   ///
@@ skipping 156 matching lines @@
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _loader.declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
-      return _emitTypeName(
-          fillDynamicTypeArgs((element as dynamic).type, types));
+      return _emitTypeName(fillDynamicTypeArgs(element.type));
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _emitTopLevelName(element);
     }
 
     var name = element.name;
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
       var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
       // 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.
       if (isStatic) {
-        var dynType = _emitTypeName(fillDynamicTypeArgs(type, types));
+        var dynType = _emitTypeName(fillDynamicTypeArgs(type));
         return new JS.PropertyAccess(dynType, member);
       }
 
       // For instance members, we add implicit-this.
       // For method tear-offs, we ensure it's a bound method.
       var tearOff = element is MethodElement && !inInvocationContext(node);
       var code = (tearOff) ? 'dart.bind(this, #)' : 'this.#';
       return js.call(code, member);
     }
 
@@ skipping 82 matching lines @@
     }
     if (!optionalTypes.isEmpty) {
       assert(namedTypes.isEmpty);
       var oa = _emitTypeNames(
           optionalTypes, parameters?.sublist(parameterTypes.length));
       return [rt, ra, oa];
     }
     return [rt, ra];
   }
 
-  JS.Expression _emitFunctionRTTI(FunctionType type) {
-    var parts = _emitFunctionTypeParts(type);
-    return js.call('dart.definiteFunctionType(#)', [parts]);
-  }
-
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
   JS.Expression _emitTypeName(DartType type,
       {bool lowerTypedef: false, bool lowerGeneric: false}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
@@ skipping 10 matching lines @@
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
       var parts = _emitFunctionTypeParts(type as FunctionType);
       return js.call('dart.functionType(#)', [parts]);
     }
     // For now, reify generic method parameters as dynamic
     bool _isGenericTypeParameter(DartType type) =>
-        (type is TypeParameterType) &&
-        !(type.element.enclosingElement is ClassElement ||
-            type.element.enclosingElement is FunctionTypeAliasElement);
+        type is TypeParameterType &&
+        type.element.enclosingElement is! TypeDefiningElement;
 
     if (_isGenericTypeParameter(type)) {
       return js.call('dart.dynamic');
     }
 
     if (type is TypeParameterType) {
       return new JS.Identifier(name);
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
-      var isCurrentClass =
-          args.isNotEmpty && _loader.isCurrentElement(type.element);
       Iterable jsArgs = null;
-      if (args
-          .any((a) => a != types.dynamicType && !_isGenericTypeParameter(a))) {
+      if (args.any((a) => !a.isDynamic && !_isGenericTypeParameter(a))) {
         jsArgs = args.map(_emitTypeName);
-      } else if (lowerGeneric || isCurrentClass) {
-        // When creating a `new S<dynamic>` we try and use the raw form
-        // `new S()`, but this does not work if we're inside the same class,
-        // because `S` refers to the current S<T> we are generating.
+      } else if (lowerGeneric) {
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
   }
 
-  JS.Expression _emitTopLevelName(Element e, {String suffix: ''}) {
-    var libName = emitLibraryName(e.library);
-
-    // Always qualify:
-    // * mutable top-level fields
-    // * elements from other libraries
-    bool mutableTopLevel = e is TopLevelVariableElement &&
-        !e.isConst &&
-        !_isFinalJSDecl(e.computeNode());
-    bool fromAnotherLibrary = e.library != currentLibrary;
-    var nameExpr;
-    if (fromAnotherLibrary) {
-      nameExpr = _propertyName((getJSExportName(e, types) ?? e.name) + suffix);
-    } else {
-      nameExpr = _propertyName(e.name + suffix);
-    }
-    if (mutableTopLevel || fromAnotherLibrary) {
-      return new JS.PropertyAccess(libName, nameExpr);
-    }
-
-    var id = new JS.MaybeQualifiedId(libName, nameExpr);
-    _qualifiedIds.add(new Tuple2(e, id));
-    return id;
+  JS.PropertyAccess _emitTopLevelName(Element e, {String suffix: ''}) {
+    String name = getJSExportName(e) + suffix;
+    return new JS.PropertyAccess(
+        emitLibraryName(e.library), _propertyName(name));
   }
 
   @override
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
     var op = node.operator.lexeme;
     assert(op.endsWith('='));
     op = op.substring(0, op.length - 1); // remove trailing '='
@@ skipping 48 matching lines @@
       }
 
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
     }
 
     if (target != null && DynamicInvoke.get(target)) {
-      return js.call('dart.$DPUT(#, #, #)',
+      return js.call('dart.dput(#, #, #)',
           [_visit(target), _emitMemberName(id.name), _visit(rhs)]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
   JS.Expression _emitNullSafeSet(PropertyAccess node, Expression right) {
     // Emit `obj?.prop = expr` as:
     //
     //     (_ => _ == null ? null : _.prop = expr)(obj).
@@ skipping 44 matching lines @@
       return _emitNullSafe(node);
     }
 
     var target = _getTarget(node);
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     String code;
     if (target == null || isLibraryPrefix(target)) {
       if (DynamicInvoke.get(node.methodName)) {
-        code = 'dart.$DCALL(#, #)';
+        code = 'dart.dcall(#, #)';
       } else {
         code = '#(#)';
       }
       return js
           .call(code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     if (DynamicInvoke.get(target)) {
-      code = 'dart.$DSEND(#, #, #)';
+      code = 'dart.dsend(#, #, #)';
     } else if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically known target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
-      code = 'dart.$DCALL(#.#, #)';
+      code = 'dart.dcall(#.#, #)';
     } else if (_requiresStaticDispatch(target, name)) {
       // Object methods require a helper for null checks.
       return js.call('dart.#(#, #)',
           [memberName, _visit(target), _visit(node.argumentList)]);
     } else {
       code = '#.#(#)';
     }
 
     return js
         .call(code, [_visit(target), memberName, _visit(node.argumentList)]);
@@ skipping 34 matching lines @@
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     var code;
     if (DynamicInvoke.get(node.function)) {
-      code = 'dart.$DCALL(#, #)';
+      code = 'dart.dcall(#, #)';
     } else {
       code = '#(#)';
     }
     return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
@@ skipping 34 matching lines @@
 
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         if (destructure) {
           if (_jsObjectProperties.contains(param.identifier.name)) {
             hasNamedArgsConflictingWithObjectProperties = true;
           }
           JS.Expression name;
           JS.SimpleBindingPattern structure = null;
           String paramName = param.identifier.name;
-          if (invalidVariableName(paramName)) {
+          if (JS.invalidVariableName(paramName)) {
             name = js.string(paramName);
             structure = new JS.SimpleBindingPattern(_visit(param.identifier));
           } else {
             name = _visit(param.identifier);
           }
           namedVars.add(new JS.DestructuredVariable(
               name: name,
               structure: structure,
               defaultValue: _defaultParamValue(param)));
         } else {
@@ skipping 87 matching lines @@
     return jsExpr.toYieldStatement(star: star);
   }
 
   @override
   JS.Expression visitAwaitExpression(AwaitExpression node) {
     return new JS.Yield(_visit(node.expression));
   }
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    for (var v in node.variables.variables) {
-      _loader.loadDeclaration(v, v.element);
+    for (var variable in node.variables.variables) {
+      _loader.emitDeclaration(variable.element);
     }
   }
 
-  /// Emits static fields.
-  ///
-  /// Instance fields are emitted in [_initializeFields].
-  ///
-  /// These are generally treated the same as top-level fields, see
-  /// [visitTopLevelVariableDeclaration].
+  /// This is not used--we emit fields as we are emitting the class,
+  /// see [visitClassDeclaration].
   @override
   visitFieldDeclaration(FieldDeclaration node) {
-    if (!node.isStatic) return;
-
-    node.fields.variables.forEach(_emitModuleItem);
-  }
-
-  _addExport(String name, [String exportName]) {
-    if (_exports.containsKey(name)) {
-      throw 'Duplicate top level name found: $name';
-    }
-    _exports[name] = exportName ?? name;
+    assert(false);
   }
 
   @override
   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);
-    if (node.variables.variables.length == 1) {
-      var v = node.variables.variables.single;
+    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(node.variables).toStatement();
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
@@ skipping 41 matching lines @@
     JS.Expression jsInit = _visitInitializer(field);
     bool isLoaded = _loader.finishCheckingReferences();
 
     bool eagerInit =
         isLoaded && (field.isConst || _constField.isFieldInitConstant(field));
 
     var fieldName = field.name.name;
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return annotate(
           js.statement('#.# = #;', [
-            classElem.name,
+            _emitTopLevelName(classElem),
             _emitMemberName(fieldName, isStatic: true),
             jsInit
           ]),
           field,
           field.element);
     }
 
     // This means it should be treated as a lazy field.
     // TODO(jmesserly): we're throwing away the initializer expression,
     // which will force us to regenerate it.
     return null;
   }
 
   /// Emits a top-level field.
-  JS.Statement _emitTopLevelField(VariableDeclaration field) {
+  JS.ModuleItem _emitTopLevelField(VariableDeclaration field) {
     TopLevelVariableElement element = field.element;
     assert(element.isStatic);
 
     bool eagerInit;
     JS.Expression jsInit;
     if (field.isConst || _constField.isFieldInitConstant(field)) {
       // If the field is constant, try and generate it at the top level.
       _loader.startTopLevel(element);
       jsInit = _visitInitializer(field);
       _loader.finishTopLevel(element);
       eagerInit = _loader.isLoaded(element);
     } else {
       // TODO(jmesserly): we're visiting the initializer here, and again
       // later on when we emit lazy fields. That seems busted.
       jsInit = _visitInitializer(field);
       eagerInit = false;
     }
 
     // Treat `final x = JS('', '...')` as a const (non-lazy) to help compile
     // runtime helpers.
+    // TODO(jmesserly): we don't track dependencies correctly for these.
     var isJSTopLevel = field.isFinal && _isFinalJSDecl(field);
-    if (isJSTopLevel) eagerInit = true;
-
-    var fieldName = field.name.name;
-    var exportName = fieldName;
-    if (element is TopLevelVariableElement) {
-      exportName = getJSExportName(element, types) ?? fieldName;
-    }
-    if ((field.isConst && eagerInit && element is TopLevelVariableElement) ||
-        isJSTopLevel) {
-      // constant fields don't change, so we can generate them as `let`
-      // but add them to the module's exports. However, make sure we generate
-      // anything they depend on first.
-
-      if (isPublic(fieldName)) _addExport(fieldName, exportName);
-      var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
-      if (isJSTopLevel && jsInit is JS.ClassExpression) {
-        return new JS.ClassDeclaration(jsInit);
-      }
-      return js.statement('#;', [
-        annotate(
-            new JS.VariableDeclarationList(declKeyword, [
-              new JS.VariableInitialization(
-                  new JS.Identifier(fieldName,
-                      type: emitTypeRef(field.element.type)),
-                  jsInit)
-            ]),
-            field,
-            field.element)
-      ]);
+    if (eagerInit || isJSTopLevel) {
+      return annotate(
+          js.statement('# = #;', [_emitTopLevelName(element), jsInit]),
+          field,
+          element);
     }
 
-    if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
-      return annotate(js.statement('# = #;', [_visit(field.name), jsInit]),
-          field, field.element);
-    }
-
-    return _emitLazyFields(currentLibrary, [field]);
+    assert(element.library == currentLibrary);
+    return _emitLazyFields(element.library, [field]);
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value ?? new JS.LiteralNull();
   }
 
   JS.Statement _emitLazyFields(
@@ skipping 17 matching lines @@
         methods.add(annotate(
             new JS.Method(access, js.call('function(_) {}') as JS.Fun,
                 isSetter: true),
             node,
             _findAccessor(element, getter: false)));
       }
     }
 
     JS.Expression objExpr;
     if (target is ClassElement) {
-      objExpr = new JS.Identifier(target.type.name);
+      objExpr = _emitTopLevelName(target);
     } else {
       objExpr = emitLibraryName(target);
     }
 
-    return js
-        .statement('dart.defineLazyProperties(#, { # });', [objExpr, methods]);
+    return js.statement('dart.defineLazy(#, { # });', [objExpr, methods]);
   }
 
   PropertyAccessorElement _findAccessor(VariableElement element,
       {bool getter}) {
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       return getter
           ? parent.getGetter(element.name)
           : parent.getSetter(element.name);
     }
     return null;
   }
 
-  void _flushLibraryProperties(List<JS.Statement> body) {
-    if (_properties.isEmpty) return;
-    body.add(js.statement('dart.copyProperties(#, { # });',
-        [_exportsVar, _properties.map(_emitTopLevelProperty)]));
-    _properties.clear();
-  }
-
   JS.Expression _emitConstructorName(
       ConstructorElement element, DartType type, SimpleIdentifier name) {
     var typeName = _emitTypeName(type);
     if (name != null || element.isFactory) {
       var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
@@ skipping 38 matching lines @@
     var type = constructor.type.type;
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool isPrimitiveType(DartType t) =>
-      typeIsPrimitiveInJS(t) || t == _types.stringType;
+      typeIsPrimitiveInJS(t) || t == types.stringType;
 
   bool typeIsPrimitiveInJS(DartType t) =>
-      _isNumberInJS(t) || t == _types.boolType;
+      _isNumberInJS(t) || t == types.boolType;
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
     var jsExpr = _visit(expr);
     if (!isNullable(expr)) return jsExpr;
@@ skipping 31 matching lines @@
 
       var vars = <String, JS.Expression>{};
       // Desugar `l ?? r` as `l != null ? l : r`
       var l = _visit(_bindValue(vars, 'l', left, context: left));
       return new JS.MetaLet(vars, [
         js.call('# != null ? # : #', [l, l, _visit(right)])
       ]);
     }
 
     if (binaryOperationIsPrimitive(leftType, rightType) ||
-        leftType == _types.stringType && op.type == TokenType.PLUS) {
+        leftType == types.stringType && op.type == TokenType.PLUS) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         var div = AstBuilder.binaryExpression(left, '/', right)
           ..staticType = node.staticType;
         return _emitSend(div, 'truncate', []);
       } else {
@@ skipping 328 matching lines @@
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
     if (DynamicInvoke.get(target)) {
-      return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
+      return js.call('dart.dload(#, #)', [_visit(target), name]);
     }
 
     String code;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       if (target is SuperExpression) {
         return js.call('dart.bind(this, #, #.#)', [name, _visit(target), name]);
       } else if (_requiresStaticDispatch(target, memberId.name)) {
         var type = member.type;
         var clos = js.call('dart.#.bind(#)', [name, _visit(target)]);
@@ skipping 13 matching lines @@
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
     if (DynamicInvoke.get(target)) {
       // dynamic dispatch
-      var dynamicHelper = const {'[]': DINDEX, '[]=': DSETINDEX}[name];
+      var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
       if (dynamicHelper != null) {
         return js.call(
             'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
       }
-      return js.call('dart.$DSEND(#, #, #)',
+      return js.call('dart.dsend(#, #, #)',
           [_visit(target), memberName, _visitList(args)]);
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
@@ skipping 110 matching lines @@
     //   }
     // } finally {
     //   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 context = compiler.context;
-    var dart_async = context
-        .computeLibraryElement(context.sourceFactory.forUri('dart:async'));
-    var _streamIteratorType =
-        rules.instantiateToBounds(dart_async.getType('StreamIterator').type);
-
+    var streamIterator = rules.instantiateToBounds(_asyncStreamIterator);
     var createStreamIter = _emitInstanceCreationExpression(
-        _streamIteratorType.element.unnamedConstructor,
-        _streamIteratorType,
+        streamIterator.element.unnamedConstructor,
+        streamIterator,
         null,
         AstBuilder.argumentList([node.iterable]),
         false);
-    var iter =
-        _visit(_createTemporary('it', _streamIteratorType, nullable: 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]);
     } else {
       init = js.call('# = #.current', [init, iter]);
     }
     return js.statement(
         '{'
@@ skipping 277 matching lines @@
     return result;
   }
 
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
     return new JS.Expression.binary(
         _visitList(nodes) as List<JS.Expression>, operator);
   }
 
-  /// Return the bound type parameters for a ParameterizedType
-  List<TypeParameterElement> _typeFormalsOf(ParameterizedType type) {
-    return type is FunctionType ? type.typeFormals : type.typeParameters;
-  }
-
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
   JS.Expression _elementMemberName(ExecutableElement e,
       {bool allowExtensions: true}) {
     String name;
     if (e is PropertyAccessorElement) {
       name = e.variable.name;
     } else {
@@ skipping 49 matching lines @@
   ///
   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)) as JS.TemporaryId);
+      return _emitPrivateNameSymbol(currentLibrary, name);
     }
 
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
       name = 'unary-';
     } else if (name == 'constructor' || name == 'prototype') {
       // This uses an illegal (in Dart) character for a member, avoiding the
       // conflict. We could use practically any character for this.
       name = '+$name';
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
     var baseType = type;
     while (baseType is TypeParameterType) {
       baseType = baseType.element.bound;
     }
     if (allowExtensions &&
         baseType != null &&
         _extensionTypes.contains(baseType.element) &&
         !isObjectProperty(name)) {
       return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
+  JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
+    return _privateNames
+        .putIfAbsent(library, () => new HashMap())
+        .putIfAbsent(name, () {
+      var id = new JS.TemporaryId(name);
+      _moduleItems.add(
+          js.statement('const # = Symbol(#);', [id, js.string(id.name, "'")]));
+      return id;
+    });
+  }
+
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
-  /// Choose a canonical name from the library element.
-  /// This never uses the library's name (the identifier in the `library`
-  /// declaration) as it doesn't have any meaningful rules enforced.
+  /// Returns the canonical name to refer to the Dart library.
   JS.Identifier emitLibraryName(LibraryElement library) {
-    if (library == currentLibrary) return _exportsVar;
-    if (library.name == 'dart._runtime') return _runtimeLibVar;
-    return _imports.putIfAbsent(
-        library, () => new JS.TemporaryId(jsLibraryName(library)));
+    // It's either one of the libraries in this module, or it's an import.
+    return _libraries[library] ??
+        _imports.putIfAbsent(
+            library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   JS.Node annotate(JS.Node node, AstNode original, [Element element]) {
     if (options.closure && element != null) {
       node = node.withClosureAnnotation(closureAnnotationFor(
           node, original, element, namedArgumentTemp.name));
     }
     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".
-  bool _isNumberInJS(DartType t) => rules.isSubtypeOf(t, _types.numType);
+  bool _isNumberInJS(DartType t) => rules.isSubtypeOf(t, types.numType);
 
   bool _isObjectGetter(String name) {
-    PropertyAccessorElement element = _types.objectType.element.getGetter(name);
+    PropertyAccessorElement element = types.objectType.element.getGetter(name);
     return (element != null && !element.isStatic);
   }
 
   bool _isObjectMethod(String name) {
-    MethodElement element = _types.objectType.element.getMethod(name);
+    MethodElement element = types.objectType.element.getMethod(name);
     return (element != null && !element.isStatic);
   }
 
   bool isObjectProperty(String name) {
     return _isObjectGetter(name) || _isObjectMethod(name);
   }
 
   // TODO(leafp): Various analyzer pieces computed similar things.
   // Share this logic somewhere?
   DartType _getExpectedReturnType(ExecutableElement element) {
     FunctionType functionType = element.type;
     if (functionType == null) {
       return DynamicTypeImpl.instance;
     }
     var type = functionType.returnType;
 
     InterfaceType expectedType = null;
     if (element.isAsynchronous) {
       if (element.isGenerator) {
         // Stream<T> -> T
-        expectedType = _types.streamType;
+        expectedType = types.streamType;
       } else {
         // Future<T> -> T
         // TODO(vsm): Revisit with issue #228.
-        expectedType = _types.futureType;
+        expectedType = types.futureType;
       }
     } else {
       if (element.isGenerator) {
         // Iterable<T> -> T
-        expectedType = _types.iterableType;
+        expectedType = types.iterableType;
       } else {
         // T -> T
         return type;
       }
     }
     if (type.isDynamic) {
       return type;
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // TODO(leafp): The above only handles the case where the return type
       // is exactly Future/Stream/Iterable.  Handle the subtype case.
       return DynamicTypeImpl.instance;
     }
   }
 }
 
-class ExtensionTypeSet extends GeneralizingElementVisitor {
-  final AnalysisContext _context;
-  final TypeProvider _types;
-
-  final _extensionTypes = new HashSet<ClassElement>();
-  final _pendingLibraries = new HashSet<String>();
-
-  ExtensionTypeSet(AbstractCompiler compiler)
-      : _context = compiler.context,
-        _types = compiler.context.typeProvider;
-
-  visitClassElement(ClassElement element) {
-    if (findAnnotation(element, isJsPeerInterface) != null ||
-        findAnnotation(element, isNativeAnnotation) != null) {
-      _addExtensionType(element.type);
-    }
-  }
-
-  void _addExtensionType(InterfaceType t) {
-    if (t.isObject || !_extensionTypes.add(t.element)) return;
-    t = fillDynamicTypeArgs(t, _types) as InterfaceType;
-    t.interfaces.forEach(_addExtensionType);
-    t.mixins.forEach(_addExtensionType);
-    _addExtensionType(t.superclass);
-  }
-
-  void _addExtensionTypesForLibrary(String libraryUri, List<String> typeNames) {
-    var sourceFactory = _context.sourceFactory.forUri(libraryUri);
-    var library = _context.computeLibraryElement(sourceFactory);
-    for (var typeName in typeNames) {
-      var element = library.getType(typeName);
-      _addExtensionType(element.type);
-    }
-  }
-
-  void _addExtensionTypes(String libraryUri) {
-    var sourceFactory = _context.sourceFactory.forUri(libraryUri);
-    var library = _context.computeLibraryElement(sourceFactory);
-    visitLibraryElement(library);
-  }
-
-  void _addPendingExtensionTypes(String libraryUri) {
-    _pendingLibraries.add(libraryUri);
-  }
-
-  bool contains(Element element) {
-    if (_extensionTypes.contains(element)) return true;
-    if (_pendingLibraries.isEmpty) return false;
-    if (element is ClassElement) {
-      var uri = element.library.source.uri.toString();
-      if (_pendingLibraries.contains(uri)) {
-        // Load all pending libraries
-        for (var libraryUri in _pendingLibraries) {
-          _addExtensionTypes(libraryUri);
-        }
-        _pendingLibraries.clear();
-        return _extensionTypes.contains(element);
-      }
-    }
-    return false;
-  }
-}
-
-class JSGenerator {
-  final AbstractCompiler compiler;
-  final ExtensionTypeSet _extensionTypes;
-  final TypeProvider _types;
-
-  JSGenerator(AbstractCompiler compiler)
-      : compiler = compiler,
-        _types = compiler.context.typeProvider,
-        _extensionTypes = new ExtensionTypeSet(compiler) {
-    // TODO(vsm): Eventually, we want to make this extensible - i.e., find
-    // annotations in user code as well.  It would need to be summarized in
-    // the element model - not searched this way on every compile.  To make this
-    // a little more efficient now, we do this in two phases.
-
-    // First, core types:
-    _extensionTypes._addExtensionTypes('dart:_interceptors');
-    _extensionTypes._addExtensionTypes('dart:_native_typed_data');
-    // TODO(vsm): If we're analyzing against the main SDK, those
-    // types are not explicitly annotated.
-    _extensionTypes._addExtensionType(_types.intType);
-    _extensionTypes._addExtensionType(_types.doubleType);
-    _extensionTypes._addExtensionType(_types.boolType);
-    _extensionTypes._addExtensionType(_types.stringType);
-    // These are used natively by dart:html but also not annotated.
-    _extensionTypes
-        ._addExtensionTypesForLibrary('dart:core', ['Comparable', 'Map']);
-    _extensionTypes
-        ._addExtensionTypesForLibrary('dart:collection', ['ListMixin']);
-    _extensionTypes._addExtensionTypesForLibrary('dart:math', ['Rectangle']);
-
-    // Second, html types - these are only searched if we use dart:html, etc.:
-    _extensionTypes._addPendingExtensionTypes('dart:html');
-    _extensionTypes._addPendingExtensionTypes('dart:indexed_db');
-    _extensionTypes._addPendingExtensionTypes('dart:svg');
-    _extensionTypes._addPendingExtensionTypes('dart:web_audio');
-    _extensionTypes._addPendingExtensionTypes('dart:web_gl');
-    _extensionTypes._addPendingExtensionTypes('dart:web_sql');
-  }
-
-  void generateLibrary(List<CompilationUnit> units) {
-    var library = units.first.element.library;
-    var fields =
-        findFieldsNeedingStorage(units.map((c) => c.element), _extensionTypes);
-    var rules = new StrongTypeSystemImpl();
-    var codegen =
-        new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
-    var module = codegen.emitLibrary(units);
-    var out = compiler.getOutputPath(library.source.uri);
-    var options = compiler.options.codegenOptions;
-    writeJsLibrary(module, out, compiler.inputBaseDir,
-        emitTypes: options.closure,
-        emitSourceMaps: options.emitSourceMaps,
-        fileSystem: compiler.fileSystem);
-  }
-}
-
 /// 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(LibraryElement library) => canonicalLibraryName(library);
+String jsLibraryName(LibraryElement library) {
+  return pathToJSIdentifier(library.source.uri.pathSegments.last);
+}
 
 /// Shorthand for identifier-like property names.
 /// For now, we emit them as strings and the printer restores them to
 /// identifiers if it can.
 // TODO(jmesserly): avoid the round tripping through quoted form.
 JS.LiteralString _propertyName(String name) => js.string(name, "'");
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }
+
+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';