fixes #185, track const ctor dependencies, plus a static field fix

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 651 matching lines @@
         _visit(node.redirectedConstructor),
         _visit(node.parameters)
       ]);
     }
 
     var body = <JS.Statement>[];
 
     // 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);
 
     if (redirectCall != null) {
       body.add(_visit(redirectCall));
       return new JS.Block(body);
     }
 
     // Initializers only run for non-factory constructors.
     if (node.factoryKeyword == null) {
       // Generate field initializers.
       // These are expanded into each non-redirecting constructor.
       // In the future we may want to create an initializer function if we have
       // multiple constructors, but it needs to be balanced against readability.
-      body.add(_initializeFields(node, fields));
+      body.add(_initializeFields(node.parent, fields, node));
 
       var superCall = node.initializers.firstWhere(
           (i) => i is SuperConstructorInvocation, orElse: () => null);
 
       // If no superinitializer is provided, an implicit superinitializer of the
       // form `super()` is added at the end of the initializer list, unless the
       // enclosing class is class Object.
       var jsSuper = _superConstructorCall(node.parent, superCall);
       if (jsSuper != null) body.add(jsSuper);
     }
@@ skipping 44 matching lines @@
     return e.fields.any((f) => !f.isStatic && !f.isSynthetic);
   }
 
   /// Initialize fields. They follow the sequence:
   ///
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(
-      AstNode node, List<FieldDeclaration> fieldDecls) {
-    var unit = node.getAncestor((a) => a is CompilationUnit);
+      ClassDeclaration cls, List<FieldDeclaration> fieldDecls,
+      [ConstructorDeclaration ctor]) {
+    var unit = cls.getAncestor((a) => a is CompilationUnit);
     var constField = new ConstFieldVisitor(types, unit);
+    bool isConst = ctor != null && ctor.constKeyword != null;
+    if (isConst) _loader.startTopLevel(cls.element);
 
     // Run field initializers if they can have side-effects.
     var fields = new Map<FieldElement, JS.Expression>();
     var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fieldDecls) {
       for (var fieldNode in declaration.fields.variables) {
         var element = fieldNode.element;
         if (constField.isFieldInitConstant(fieldNode)) {
           unsetFields[element] = fieldNode;
         } else {
           fields[element] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
-    if (node is ConstructorDeclaration) {
-      var parameters = node.parameters;
-      var initializers = node.initializers;
-
-      for (var p in parameters.parameters) {
+    if (ctor != null) {
+      for (var p in ctor.parameters.parameters) {
         var element = p.element;
         if (element is FieldFormalParameterElement) {
           fields[element.field] = _visit(p);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
-      for (var init in initializers) {
+      for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
           fields[init.fieldName.staticElement] = _visit(init.expression);
         }
       }
     }
 
     for (var f in fields.keys) unsetFields.remove(f);
 
     // Initialize all remaining fields
     unsetFields.forEach((element, fieldNode) {
       JS.Expression value;
       if (fieldNode.initializer != null) {
         value = _visit(fieldNode.initializer);
       } else {
         var type = rules.elementType(element);
         value = new JS.LiteralNull();
         if (rules.maybeNonNullableType(type)) {
           value = js.call('dart.as(#, #)', [value, _emitTypeName(type)]);
         }
       }
       fields[element] = value;
     });
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
       var access = _emitMemberName(e.name, type: e.enclosingElement.type);
       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 1057 matching lines @@
         !_isJSBuiltinType(type) &&
         _isNonNullableExpression(target)) {
       return false;
     }
     return true;
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
-    bool isStatic = member is ExecutableElement && member.isStatic;
+    if (member is PropertyAccessorElement) member = member.variable;
+    bool isStatic = member is ClassMemberElement && member.isStatic;
+    if (isStatic) {
+      _loader.declareBeforeUse(member);
+    }
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     }
 
     String code;
     if (member != null && member is MethodElement) {
       // Tear-off methods: explicitly bind it.
       if (_requiresStaticDispatch(target, memberId.name)) {
@@ skipping 571 matching lines @@
 
 /// 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);
 }