fix #29182, generate top level const fields lazily

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 23 matching lines @@
 import 'package:analyzer/src/task/strong/ast_properties.dart'
     show isDynamicInvoke, setIsDynamicInvoke, getImplicitAssignmentCast;
 import 'package:path/path.dart' show separator;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
-import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_interop.dart';
 import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'property_model.dart';
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
@@ skipping 10 matching lines @@
   /// 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 dart:_runtime SDK functions; these are assumed by other code
+  /// in the SDK to be generated before anything else.
+  final _internalSdkFunctions = <JS.ModuleItem>[];
+
   /// The list of output module items, in the order they need to be emitted in.
   final _moduleItems = <JS.ModuleItem>[];
 
   /// Table of named and possibly hoisted types.
   TypeTable _typeTable;
 
   /// The global extension type table.
   final ExtensionTypeSet _extensionTypes;
 
   /// The variable for the target of the current `..` cascade expression.
@@ skipping 13 matching lines @@
       new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _initializingFormalTemps =
       new HashMap<ParameterElement, JS.TemporaryId>();
 
   JS.Identifier _extensionSymbolsModule;
   JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
-  final _eagerTopLevelFields = new HashSet<Element>.identity();
-
   /// 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;
 
   final ClassElement boolClass;
   final ClassElement intClass;
   final ClassElement interceptorClass;
   final ClassElement nullClass;
   final ClassElement numClass;
   final ClassElement objectClass;
   final ClassElement stringClass;
   final ClassElement functionClass;
   final ClassElement privateSymbolClass;
 
   ConstFieldVisitor _constants;
 
   /// The current function body being compiled.
   FunctionBody _currentFunction;
 
-  /// Helper class for emitting elements in the proper order to allow
-  /// JS to load the module.
-  ElementLoader _loader;
+  HashMap<TypeDefiningElement, AstNode> _declarationNodes;
+
+  /// The stack of currently emitting elements, if generating top-level code
+  /// for them. This is not used when inside method bodies, because order does
+  /// not matter for those.
+  final _topLevelElements = <TypeDefiningElement>[];
+
+  /// The current element being loaded.
+  /// We can use this to determine if we're loading top-level code or not:
+  ///
+  ///     _currentElements.last == _topLevelElements.last
+  //
+  // TODO(jmesserly): ideally we'd only track types here, in other words,
+  // TypeDefiningElement. However we still rely on this for [currentLibrary] so
+  // we need something to be pushed always.
+  final _currentElements = <Element>[];
+
+  final _deferredProperties = new HashMap<PropertyAccessorElement, JS.Method>();
 
   BuildUnit _buildUnit;
 
   String _libraryRoot;
 
   bool _superAllowed = true;
 
   List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
   List<JS.Method> _superHelpers = <JS.Method>[];
 
@@ skipping 25 matching lines @@
         intClass = _getLibrary(c, 'dart:core').getType('int'),
         numClass = _getLibrary(c, 'dart:core').getType('num'),
         nullClass = _getLibrary(c, 'dart:core').getType('Null'),
         objectClass = _getLibrary(c, 'dart:core').getType('Object'),
         stringClass = _getLibrary(c, 'dart:core').getType('String'),
         functionClass = _getLibrary(c, 'dart:core').getType('Function'),
         privateSymbolClass =
             _getLibrary(c, 'dart:_internal').getType('PrivateSymbol'),
         dartJSLibrary = _getLibrary(c, 'dart:js');
 
-  LibraryElement get currentLibrary => _loader.currentElement.library;
+  Element get currentElement => _currentElements.last;
+
+  LibraryElement get currentLibrary => 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;
     _libraryRoot = _buildUnit.libraryRoot;
     if (!_libraryRoot.endsWith(separator)) {
@@ skipping 82 matching lines @@
           js.call('const # = Object.create(null)', [libraryTemp])));
 
       // dart:_runtime has a magic module that holds extension method symbols.
       // TODO(jmesserly): find a cleaner design for this.
       if (isSdkInternalRuntime(library)) {
         items.add(new JS.ExportDeclaration(js
             .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
-    // Collect all Element -> Node mappings, in case we need to forward declare
-    // any nodes.
-    var nodes = new HashMap<Element, AstNode>.identity();
-    var sdkBootstrappingFns = new List<FunctionElement>();
+    // Collect all class/type Element -> Node mappings
+    // in case we need to forward declare any classes.
+    _declarationNodes = new HashMap<TypeDefiningElement, AstNode>.identity();
     for (var unit in compilationUnits) {
-      if (isSdkInternalRuntime(
-          resolutionMap.elementDeclaredByCompilationUnit(unit).library)) {
-        sdkBootstrappingFns.addAll(
-            resolutionMap.elementDeclaredByCompilationUnit(unit).functions);
+      for (var declaration in unit.declarations) {
+        var element = declaration.element;
+        if (element is TypeDefiningElement) {
+          _declarationNodes[element] = declaration;
+        }
       }
-      _collectElements(unit, nodes);
     }
-    _loader = new ElementLoader(nodes);
     if (compilationUnits.isNotEmpty) {
       _constants = new ConstFieldVisitor(context,
           dummySource: resolutionMap
               .elementDeclaredByCompilationUnit(compilationUnits.first)
               .source);
     }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
-    // Emit SDK bootstrapping functions first, if any.
-    sdkBootstrappingFns.forEach(_emitDeclaration);
-
     // 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(_finishDeclarationsInUnit);
+    compilationUnits.forEach(_emitCompilationUnit);
+    assert(_deferredProperties.isEmpty);
+
+    // Visit directives (for exports)
+    compilationUnits.forEach(_emitExportDirectives);
 
     // Declare imports
     _finishImports(items);
 
     // Discharge the type table cache variables and
     // hoisted definitions.
     items.addAll(_typeTable.discharge());
+    items.addAll(_internalSdkFunctions);
 
     // Track the module name for each library in the module.
     // This data is only required for debugging.
     _moduleItems.add(js.statement(
         '#.trackLibraries(#, #, ${JSModuleFile.sourceMapHoleID});',
         [_runtimeModule, js.string(name), _librariesDebuggerObject()]));
 
     // Add the module's code (produced by visiting compilation units, above)
     _copyAndFlattenBlocks(items, _moduleItems);
 
@@ skipping 88 matching lines @@
   }
 
   /// 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 {
+      } else if (item != null) {
         result.add(item);
       }
     }
   }
 
   String _libraryToModule(LibraryElement library) {
     assert(!_libraries.containsKey(library));
     var source = library.source;
     // TODO(jmesserly): we need to split out HTML.
     if (source.uri.scheme == 'dart') {
@@ skipping 32 matching lines @@
       if (module == coreModuleName) {
         imports.add(new JS.NameSpecifier(_runtimeModule));
         imports.add(new JS.NameSpecifier(_extensionSymbolsModule));
       }
 
       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 void _collectElements(
-      CompilationUnit unit, Map<Element, AstNode> map) {
-    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;
-      }
-    }
-  }
-
   /// Called to emit all top-level declarations.
   ///
   /// During the course of emitting one item, we may emit another. For example
   ///
   ///     class D extends B { C m() { ... } }
   ///
   /// Because D depends on B, we'll emit B first if needed. However C is not
   /// used by top-level JavaScript code, so we can ignore that dependency.
-  void _emitDeclaration(Element e) {
-    var item = _loader.emitDeclaration(e, (AstNode node) {
-      // TODO(jmesserly): this is not really the right place for this.
-      // Ideally we do this per function body.
-      //
-      // We'll need to be consistent about when we're generating functions, and
-      // only run this on the outermost function, and not any closures.
-      inferNullableTypes(node);
-      return _visit(node) as JS.Node;
-    });
+  void _emitTypeDeclaration(TypeDefiningElement e) {
+    var node = _declarationNodes.remove(e);
+    if (node == null) return null; // not from this module or already loaded.
 
-    if (item != null) _moduleItems.add(item);
+    _currentElements.add(e);
+
+    // TODO(jmesserly): this is not really the right place for this.
+    // Ideally we do this per function body.
+    //
+    // We'll need to be consistent about when we're generating functions, and
+    // only run this on the outermost function, and not any closures.
+    inferNullableTypes(node);
+
+    _moduleItems.add(_visit(node));
+
+    var last = _currentElements.removeLast();
+    assert(identical(e, last));
   }
 
-  void _declareBeforeUse(Element e) {
-    _loader.declareBeforeUse(e, _emitDeclaration);
+  /// Start generating top-level code for the element [e].
+  ///
+  /// Subsequent [emitDeclaration] calls will cause those elements to be
+  /// generated before this one, until [finishTopLevel] is called.
+  void _startTopLevelCodeForClass(TypeDefiningElement e) {
+    assert(identical(e, currentElement));
+    _topLevelElements.add(e);

[vsm, 2017/04/04 22:58:43]

Is it worth asserting that it's not there already?  

[Jennifer Messerly, 2017/04/04 23:18:34]

I think it's ~probably okay if we skip that assert. My worry is checking
.contains adds an O(N) check... could make checked mode a lot slower. All that
really matters is we know when we're in top level code and when we aren't.
Conceptually this is kinda part of the current element stack, it's as if we have
a stack like:

library foo
class C
class C - TOP LEVEL
class D
class D - TOP LEVEL
class E

   }
 
-  void _finishDeclarationsInUnit(CompilationUnit unit) {
+  /// Finishes the top-level code for the element [e].
+  void _finishTopLevelCodeForClass(TypeDefiningElement e) {
+    var last = _topLevelElements.removeLast();
+    assert(identical(e, last));
+  }
+
+  /// To emit top-level module items, we sometimes need to reorder them.
+  ///
+  /// This function takes care of that, and also detects cases where reordering
+  /// failed, and we need to resort to lazy loading, by marking the element as
+  /// lazy. All elements need to be aware of this possibility and generate code
+  /// accordingly.
+  ///
+  /// If we are not emitting top-level code, this does nothing, because all
+  /// declarations are assumed to be available before we start execution.
+  /// See [startTopLevel].
+  void _declareBeforeUse(TypeDefiningElement e) {
+    if (e == null) return;
+
+    var topLevel = _topLevelElements;
+    if (topLevel.isNotEmpty && identical(currentElement, topLevel.last)) {
+      // If the item is from our library, try to emit it now.
+      _emitTypeDeclaration(e);
+    }
+  }
+
+  void _emitCompilationUnit(CompilationUnit unit) {
     // NOTE: this method isn't the right place to initialize
     // per-compilation-unit state. Declarations can be visited out of order,
     // this is only to catch things that haven't been emitted yet.
     //
-    // See _emitDeclaration.
+    // See _emitTypeDeclaration.
+    var library = unit.element.library;
+    bool internalSdk = isSdkInternalRuntime(library);
+    _currentElements.add(library);
+
+    List<VariableDeclaration> fields;
     for (var declaration in unit.declarations) {
+      if (declaration is TopLevelVariableDeclaration) {
+        inferNullableTypes(declaration);
+        if (internalSdk && declaration.variables.isFinal) {
+          _emitInternalSdkFields(declaration.variables.variables);
+        } else {
+          (fields ??= []).addAll(declaration.variables.variables);
+        }
+        continue;
+      }
+
+      if (fields != null) {
+        _emitTopLevelFields(fields);
+        fields = null;
+      }
+
       var element = declaration.element;
-      if (element != null) {
-        _emitDeclaration(element);
+      if (element is TypeDefiningElement) {
+        _emitTypeDeclaration(element);
+        continue;
+      }
+
+      inferNullableTypes(declaration);
+      var item = _visit(declaration);
+      if (internalSdk && element is FunctionElement) {
+        _internalSdkFunctions.add(item);
       } else {
-        declaration.accept(this);
+        _moduleItems.add(item);
       }
     }
+
+    if (fields != null) _emitTopLevelFields(fields);
+
+    _currentElements.removeLast();
+  }
+
+  void _emitExportDirectives(CompilationUnit unit) {
     for (var directive in unit.directives) {
+      _currentElements.add(directive.element);
       directive.accept(this);
+      _currentElements.removeLast();
     }
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {}
 
   @override
   void visitImportDirective(ImportDirective node) {
     // We don't handle imports here.
     //
@@ skipping 13 matching lines @@
 
   @override
   void visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     var currentLibrary = element.library;
 
     var currentNames = currentLibrary.publicNamespace.definedNames;
     var exportedNames =
         new NamespaceBuilder().createExportNamespaceForDirective(element);
 
-    var libraryName = emitLibraryName(currentLibrary);
-
-    // 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);
-
-      if (export is TypeDefiningElement ||
-          export is FunctionElement ||
-          _eagerTopLevelFields.contains(export)) {
-        // classes, typedefs, functions, and eager init fields can be assigned
-        // directly.
-        // TODO(jmesserly): we don't know about eager init fields from other
-        // modules we import, so we will never go down this code path for them.
-        _moduleItems
-            .add(js.statement('#.# = #;', [libraryName, name.selector, name]));
-      }
-    }
-
-    // We only need to export main as it is the only method party of the
+    // We only need to export main as it is the only method part of the
     // publicly exposed JS API for a library.
     // TODO(jacobr): add a library level annotation indicating that all
     // contents of a library need to be exposed to JS.
     // https://github.com/dart-lang/sdk/issues/26368
-
     var export = exportedNames.get('main');
 
-    if (export == null) return;
-    if (export is PropertyAccessorElement) {
-      export = (export as PropertyAccessorElement).variable;
+    if (export is FunctionElement) {
+      // Don't allow redefining names from this library.
+      if (currentNames.containsKey(export.name)) return;
+
+      var name = _emitTopLevelName(export);
+      _moduleItems.add(js.statement(
+          '#.# = #;', [emitLibraryName(currentLibrary), name.selector, name]));
     }
-
-    // Don't allow redefining names from this library.
-    if (currentNames.containsKey(export.name)) return;
-
-    if (export.isSynthetic && export is PropertyInducingElement) {
-      _emitDeclaration(export.getter);
-      _emitDeclaration(export.setter);
-    } else {
-      _emitDeclaration(export);
-    }
-    emitExport(export);
   }
 
   @override
   visitAsExpression(AsExpression node) {
     Expression fromExpr = node.expression;
     var from = getStaticType(fromExpr);
     var to = node.type.type;
 
     JS.Expression jsFrom = _visit(fromExpr);
     if (_inWhitelistCode(node)) return jsFrom;
@@ skipping 676 matching lines @@
     var jsFields = fields?.map(_emitTypeScriptField)?.toList();
 
     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;
 
-    _loader.startTopLevel(element);
+    _startTopLevelCodeForClass(element);
 
     // List of "direct" supertypes (supertype + mixins)
     var basetypes = [type.superclass]..addAll(type.mixins);
 
     // If any of these are recursive (via type parameter), defer setting
     // the real superclass.
     if (basetypes.any((t) => _deferIfNeeded(t, element))) {
       // Fall back to raw type
       basetypes =
           basetypes.map((t) => fillDynamicTypeArgs(t.element.type)).toList();
       _hasDeferredSupertype.add(element);
     }
 
     // List of "direct" JS superclasses
     var baseclasses = basetypes
         .map((t) => _emitConstructorAccess(t, nameType: false))
         .toList();
     assert(baseclasses.isNotEmpty);
     var heritage = (baseclasses.length == 1)
         ? baseclasses.first
         : _callHelper('mixin(#)', [baseclasses]);
 
-    _loader.finishTopLevel(element);
+    _finishTopLevelCodeForClass(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?
@@ skipping 435 matching lines @@
 
         body.add(_callHelperStatement(code, args));
       }
     }
   }
 
   /// 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) {
-        JS.Statement eagerField = _emitConstantStaticField(classElem, field);
-        if (eagerField != null) {
-          body.add(eagerField);
-        } else {
-          lazyStatics.add(field);
-        }
-      }
-    }
+    var lazyStatics = staticFields.expand((f) => f.fields.variables).toList();
     if (lazyStatics.isNotEmpty) {
       body.add(_emitLazyFields(classElem, lazyStatics));
     }
   }
 
   void _emitClassMetadata(List<Annotation> metadata, JS.Expression className,
       List<JS.Statement> body) {
     // Metadata
     if (options.emitMetadata && metadata.isNotEmpty) {
       body.add(js.statement('#[#.metadata] = () => #;', [
@@ skipping 310 matching lines @@
 
       var fun = new JS.Fun(
           params,
           js.statement('{ return $newKeyword #(#); }',
               [_visit(redirect) as JS.Node, params]),
           returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
-    // 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 params = visitFormalParameterList(node.parameters);
-    if (node.constKeyword != null) _loader.finishTopLevel(cls.element);
 
     // Factory constructors are essentially static methods.
     if (node.factoryKeyword != null) {
       var body = <JS.Statement>[];
       var init = _emitArgumentInitializers(node, constructor: true);
       if (init != null) body.add(init);
       body.add(_visit(node.body));
       var fun = new JS.Fun(params, new JS.Block(body), returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
@@ skipping 28 matching lines @@
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     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.
-    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);
 
     if (redirectCall != null) {
       body.add(_visit(redirectCall));
@@ skipping 87 matching lines @@
   ///
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(
       ClassDeclaration cls,
       List<FieldDeclaration> fieldDecls,
       Map<FieldElement, JS.TemporaryId> virtualFields,
       [ConstructorDeclaration ctor]) {
-    bool isConst = ctor != null && ctor.constKeyword != null;
-    if (isConst) _loader.startTopLevel(cls.element);
-
     // Run field initializers if they can have side-effects.
     var fields = new Map<FieldElement, JS.Expression>();
     var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fieldDecls) {
       for (var fieldNode in declaration.fields.variables) {
         var element = fieldNode.element;
         if (_constants.isFieldInitConstant(fieldNode)) {
           unsetFields[element as FieldElement] = fieldNode;
         } else {
           fields[element as FieldElement] = _visitInitializer(fieldNode);
@@ skipping 31 matching lines @@
       }
       fields[element] = value;
     });
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
       JS.Expression access = virtualFields[e] ?? _declareMemberName(e.getter);
       body.add(js.statement('this.# = #;', [access, initialValue]));
     });
 
-    if (isConst) _loader.finishTopLevel(cls.element);
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
     // lowering pass.
     if (node is ConstructorDeclaration) return node.parameters;
     if (node is MethodDeclaration) return node.parameters;
     if (node is FunctionDeclaration) node = node.functionExpression;
@@ skipping 148 matching lines @@
         typeParams: fn.typeParams,
         returnType: fn.returnType)..sourceInformation = fn.sourceInformation;
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
-    // If we have a getter/setter pair, they need to be defined together.
-    if (node.isGetter) {
+    if (node.isGetter || node.isSetter) {
       PropertyAccessorElement element = node.element;
-      var props = <JS.Method>[_emitTopLevelProperty(node)];
-      var setter = element.correspondingSetter;
-      if (setter != null) {
-        props.add(_loader.emitDeclaration(
-            setter, (node) => _emitTopLevelProperty(node)));
+      var pairAccessor = node.isGetter
+          ? element.correspondingSetter
+          : element.correspondingGetter;
+
+      var jsCode = _emitTopLevelProperty(node);
+      var props = <JS.Method>[jsCode];
+      if (pairAccessor != null) {
+        // If we have a getter/setter pair, they need to be defined together.
+        // If this is the first one, save the generated code for later.
+        // If this is the second one, get the saved code and emit both.
+        var pairCode = _deferredProperties.remove(pairAccessor);
+        if (pairCode == null) {
+          _deferredProperties[element] = jsCode;
+          return null;
+        }
+        props.add(pairCode);
       }
       return _callHelperStatement('copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
-    }
-    if (node.isSetter) {
-      PropertyAccessorElement element = node.element;
-      var props = <JS.Method>[_emitTopLevelProperty(node)];
-      var getter = element.correspondingGetter;
-      if (getter != null) {
-        props.add(_loader.emitDeclaration(
-            getter, (node) => _emitTopLevelProperty(node)));
-      }
-      return _callHelperStatement('copyProperties(#, { # });',
-          [emitLibraryName(currentLibrary), props]);
     }
 
     var body = <JS.Statement>[];
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
@@ skipping 69 matching lines @@
     if (type is FunctionType && (type.name == '' || type.name == null)) {
       return (_typeIsLoaded(type.returnType) &&
           type.optionalParameterTypes.every(_typeIsLoaded) &&
           type.namedParameterTypes.values.every(_typeIsLoaded) &&
           type.normalParameterTypes.every(_typeIsLoaded));
     }
     if (type.isDynamic || type.isVoid || type.isBottom) return true;
     if (type is ParameterizedType && !type.typeArguments.every(_typeIsLoaded)) {
       return false;
     }
-    return _loader.isLoaded(type.element);
+    return !_declarationNodes.containsKey(type.element);
   }
 
   JS.Expression _emitFunctionTagged(JS.Expression fn, DartType type,
       {topLevel: false}) {
     var lazy = topLevel && !_typeIsLoaded(type);
     var typeRep = _emitFunctionType(type, definite: true);
     if (lazy) {
       return _callHelper('lazyFn(#, () => #)', [fn, typeRep]);
     } else {
       return _callHelper('fn(#, #)', [fn, typeRep]);
@@ skipping 200 matching lines @@
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // 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;
 
-    _declareBeforeUse(element);
-
     // type literal
     if (element is TypeDefiningElement) {
+      _declareBeforeUse(element);
+
       var typeName = _emitType(fillDynamicTypeArgs(element.type));
 
       // If the type is a type literal expression in Dart code, wrap the raw
       // runtime type in a "Type" instance.
       if (!_isInForeignJS && _isTypeLiteral(node)) {
         typeName = _callHelper('wrapType(#)', typeName);
       }
 
       return typeName;
     }
@@ skipping 281 matching lines @@
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return _callHelper('void');
     } else if (type.isDynamic) {
       return _callHelper('dynamic');
     } else if (type.isBottom) {
       return _callHelper('bottom');
     }
 
     var element = type.element;
-    _declareBeforeUse(element);
+    if (element is TypeDefiningElement) {
+      _declareBeforeUse(element);
+    }
 
     var interop = _emitJSInterop(element);
     // Type parameters don't matter as JS interop types cannot be reified.
     // We have to use lazy JS types because until we have proper module
     // loading for JS libraries bundled with Dart libraries, we will sometimes
     // need to load Dart libraries before the corresponding JS libraries are
     // actually loaded.
     // Given a JS type such as:
     //     @JS('google.maps.Location')
     //     class Location { ... }
@@ skipping 213 matching lines @@
     }
 
     var accessor = resolutionMap.staticElementForIdentifier(node);
     if (accessor == null) return unimplemented();
 
     // 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;
 
-    _declareBeforeUse(element);
+    if (element is TypeDefiningElement) {
+      _declareBeforeUse(element);
+    }
 
     if (element is LocalVariableElement || element is ParameterElement) {
       return _emitSetLocal(node, element, rhs);
     }
 
     if (element.enclosingElement is CompilationUnitElement) {
       // Top level library member.
       return _emitSetTopLevel(node, element, rhs);
     }
 
@@ skipping 598 matching lines @@
     }
     // A normal yield in a sync*
     return jsExpr.toYieldStatement(star: star);
   }
 
   @override
   JS.Expression visitAwaitExpression(AwaitExpression node) {
     return new JS.Yield(_visit(node.expression));
   }
 
+  /// This is not used--we emit top-level fields as we are emitting the
+  /// compilation unit, see [_emitCompilationUnit].
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    for (var variable in node.variables.variables) {
-      _emitDeclaration(variable.element);
-    }
+    assert(false);
   }
 
   /// This is not used--we emit fields as we are emitting the class,
   /// see [visitClassDeclaration].
   @override
   visitFieldDeclaration(FieldDeclaration node) {
     assert(false);
   }
 
   @override
@@ skipping 15 matching lines @@
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     return new JS.VariableDeclarationList(
         'let', _visitList(node.variables) as List<JS.VariableInitialization>);
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) {
-      // Static and instance fields are handled elsewhere.
-      assert(node.element is TopLevelVariableElement);
-      return _emitTopLevelField(node);
+      // All fields are handled elsewhere.
+      assert(false);
+      return null;
     }
 
     var name = new JS.Identifier(node.name.name,
         type: emitTypeRef(
             resolutionMap.elementDeclaredByVariableDeclaration(node).type));
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
-  /// Try to emit a constant static field.
-  ///
-  /// If the field's initializer does not cause side effects, and if all of
-  /// dependencies are safe to refer to while we are initializing the class,
-  /// then we can initialize it eagerly:
-  ///
-  ///     // Baz must be const constructor, and the name "Baz" must be defined
-  ///     // by this point.
-  ///     Foo.bar = dart.const(new Baz(42));
-  ///
-  /// Otherwise, we'll need to generate a lazy-static field. That ensures
-  /// correct visible behavior, as well as avoiding referencing something that
-  /// isn't defined yet (because it is defined later in the module).
-  JS.Statement _emitConstantStaticField(
-      ClassElement classElem, VariableDeclaration field) {

[vsm, 2017/04/04 22:58:43]

We could consider keeping this/below only for cases where the initializer is a
primitive literal ("foo", 42, null) - i.e., doesn't affect order.

[Jennifer Messerly, 2017/04/04 23:05:17]

yeah... thought about that. It'd certainly be a lot nicer looking. What are your
thougths about emitting it slightly out of order in a group? e.g.

final x = const Something();
final y = 42;
final z = x;

should we emit "y" after or before? it's nice if we group "x" and "z" into the
same "defineLazy" call.

BTW yet another option ... I dunno how fancy we wanna get, but this is another
option to consider for the mixes of lazy and non-lazy ...

defineLazy(theLib, {
  get x()  { return dart.const(new Something()); },
  y: 42,
  get z() { return theLib.x; }
});

-    PropertyInducingElement element = field.element;
-    assert(element.isStatic);
-
-    _loader.startCheckingReferences();
-    JS.Expression jsInit = _visitInitializer(field);
-    bool isLoaded = _loader.finishCheckingReferences();
-
-    bool eagerInit =
-        isLoaded && (field.isConst || _constants.isFieldInitConstant(field));
-
-    var fieldName = field.name.name;
-    if (eagerInit &&
-        !JS.invalidStaticFieldName(fieldName) &&
-        !_classProperties.staticFieldOverrides.contains(element)) {
-      return annotate(
-          js.statement('#.# = #;', [
-            _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 list of top-level field.
+  void _emitTopLevelFields(List<VariableDeclaration> fields) {
+    _moduleItems.add(_emitLazyFields(currentLibrary, fields));
   }
 
-  /// Emits a top-level field.
-  JS.ModuleItem _emitTopLevelField(VariableDeclaration field) {
-    TopLevelVariableElement element = field.element;
-    assert(element.isStatic);
-
-    bool eagerInit;
-    JS.Expression jsInit;
-    if (field.isConst || _constants.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 dart:_runtime fields as safe to eagerly evaluate.
+  // TODO(jmesserly): it'd be nice to avoid this special case.
+  void _emitInternalSdkFields(List<VariableDeclaration> fields) {
+    for (var field in fields) {
+      _moduleItems.add(annotate(
+          js.statement('# = #;',
+              [_emitTopLevelName(field.element), _visitInitializer(field)]),
+          field,
+          field.element));
     }
-
-    // Treat dart:runtime stuff as safe to eagerly evaluate.
-    // TODO(jmesserly): it'd be nice to avoid this special case.
-    var isJSTopLevel = field.isFinal && isSdkInternalRuntime(element.library);
-    if (eagerInit || isJSTopLevel) {
-      // Remember that we emitted it this way, so re-export can take advantage
-      // of this fact.
-      _eagerTopLevelFields.add(element);
-
-      return annotate(
-          js.statement('# = #;', [_emitTopLevelName(element), jsInit]),
-          field,
-          element);
-    }
-
-    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(
       Element target, List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       var element = node.element;
+      assert(element.getAncestor((e) => identical(e, target)) != null,
+          "target is $target but enclosing element is ${element.enclosingElement}");
       var access = _emitMemberName(name, isStatic: true);
       methods.add(annotate(
           new JS.Method(
               access,
               js.call('function() { return #; }', _visitInitializer(node))
                   as JS.Fun,
               isGetter: true),
           node,
           _findAccessor(element, getter: true)));
 
@@ skipping 1757 matching lines @@
   };
 
   static Set<String> _uncheckedWhitelistCalls = new Set()
     ..add('ng_zone_impl.dart')
     ..add('stack_zone_specification.dart')
     ..add('view_manager.dart')
     ..add('view.dart');
 
   bool _inWhitelistCode(AstNode node, {isCall: false}) {
     if (!options.useAngular2Whitelist) return false;
-    var path = _loader.currentElement.source.fullName;
+    var path = currentElement.source.fullName;
     var filename = path.split("/").last;
     if (_uncheckedWhitelist.containsKey(filename)) {
       var whitelisted = _uncheckedWhitelist[filename];
       if (whitelisted == null) return true;
       var enclosing = node;
       while (enclosing != null &&
           !(enclosing is ClassMember || enclosing is FunctionDeclaration)) {
         enclosing = enclosing.parent;
       }
       String name = (enclosing as dynamic)?.element?.name;
@@ skipping 121 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }