Simplify ordering of top-level declarations.

lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 216 matching lines @@
     // 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>();
     for (var unit in compilationUnits) {
       if (_isDartRuntime(unit.element.library)) {
         sdkBootstrappingFns.addAll(unit.element.functions);
       }
       _collectElements(unit, nodes);
     }
-    _loader = new ElementLoader(_emitModuleItem, nodes);
+    _loader = new ElementLoader(nodes);
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Emit SDK bootstrapping functions first, if any.
-    sdkBootstrappingFns.forEach(_loader.emitDeclaration);
+    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(visitCompilationUnit);
 
     // Declare imports
     _finishImports(items);
@@ skipping 127 matching lines @@
       if (declaration is TopLevelVariableDeclaration) {
         for (var field in declaration.variables.variables) {
           map[field.element] = field;
         }
       } else {
         map[declaration.element] = declaration;
       }
     }
   }
 
-  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.
-    inferNullableTypes(node);
+  /// 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);
+    });
 
-    var code = _visit(node);
-    if (code != null) _moduleItems.add(code);
+    if (item != null) _moduleItems.add(item);
+  }
+
+  void _declareBeforeUse(Element e) {
+    _loader.declareBeforeUse(e, _emitDeclaration);
   }
 
   @override
   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);
+        _emitDeclaration(element);
       } else {
         declaration.accept(this);
       }
     }
     for (var directive in unit.directives) {
       directive.accept(this);
     }
   }
 
   @override
@@ skipping 52 matching lines @@
 
     for (var export in exportedNames.definedNames.values) {
       if (export is PropertyAccessorElement) {
         export = (export as PropertyAccessorElement).variable;
       }
 
       // Don't allow redefining names from this library.
       if (currentNames.containsKey(export.name)) continue;
 
       if (export.isSynthetic && export is PropertyInducingElement) {
-        _loader.emitDeclaration(export.getter);
-        _loader.emitDeclaration(export.setter);
+        _emitDeclaration(export.getter);
+        _emitDeclaration(export.setter);
       } else {
-        _loader.emitDeclaration(export);
+        _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);
     }
   }
 
@@ skipping 1290 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 (node.isGetter || node.isSetter) {
-      // If we have a getter/setter pair, they need to be defined together.
+    // If we have a getter/setter pair, they need to be defined together.
+    if (node.isGetter) {
       PropertyAccessorElement element = node.element;
-      var props = <JS.Method>[];
-      var getter = element.variable.getter;
-      if (getter != null) {
-        props.add(_loader.customEmitDeclaration(getter, _emitTopLevelProperty));
+      var props = <JS.Method>[_emitTopLevelProperty(node)];
+      var setter = element.correspondingSetter;
+      if (setter != null) {
+        props.add(_loader.emitDeclaration(setter, _emitTopLevelProperty));
       }
-      var setter = element.variable.setter;
-      if (setter != null) {
-        props.add(_loader.customEmitDeclaration(setter, _emitTopLevelProperty));
-      }
-
       return js.statement('dart.copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
     }
+    if (node.isSetter) {
+      PropertyAccessorElement element = node.element;
+      var props = <JS.Method>[_emitTopLevelProperty(node)];
+      var getter = element.correspondingGetter;
+      if (getter != null) {
+        props.add(_loader.emitDeclaration(getter, _emitTopLevelProperty));
+      }
+      return js.statement('dart.copyProperties(#, { # });',
+          [emitLibraryName(currentLibrary), props]);
+    }
 
     var body = <JS.Statement>[];
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
     var element = node.element;
@@ skipping 301 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;
 
-    _loader.declareBeforeUse(element);
+    _declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
       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 = js.call('dart.wrapType(#)', typeName);
       }
@@ skipping 169 matching lines @@
       JS.Expression className}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
     } else if (type.isBottom) {
       return js.call('dart.bottom');
     }
 
-    _loader.declareBeforeUse(type.element);
+    _declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // 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) {
       // TODO(jmesserly): should we change how typedefs work? They currently
       // go through use similar logic as generic classes. This makes them
       // different from universal function types.
@@ skipping 529 matching lines @@
   }
 
   @override
   JS.Expression visitAwaitExpression(AwaitExpression node) {
     return new JS.Yield(_visit(node.expression));
   }
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     for (var variable in node.variables.variables) {
-      _loader.emitDeclaration(variable.element);
+      _emitDeclaration(variable.element);
     }
   }
 
   /// This is not used--we emit fields as we are emitting the class,
   /// see [visitClassDeclaration].
   @override
   visitFieldDeclaration(FieldDeclaration node) {
     assert(false);
   }
 
@@ skipping 1254 matching lines @@
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
           _visitList(node.elements) as List<JS.Expression>);
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       // TODO(jmesserly): analyzer will usually infer `List<Object>` because
       // that is the least upper bound of the element types. So we rarely
       // generate a plain `List<dynamic>` anymore.
       if (!elementType.isDynamic) {
         // dart.list helper internally depends on _interceptors.JSArray.
-        _loader.declareBeforeUse(_jsArray);
+        _declareBeforeUse(_jsArray);
         list = js.call('dart.list(#, #)', [list, _emitType(elementType)]);
       }
       return list;
     }
     if (node.constKeyword != null) return _emitConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
@@ skipping 377 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';