js: fix core.Object, output order, static const fields

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;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 20 matching lines @@
 import 'package:dev_compiler/src/utils.dart';
 import 'code_generator.dart';
 
 // This must match the optional parameter name used in runtime.js
 const String _jsNamedParameterName = r'opt$';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
 
+  // TODO(jmesserly): this is needed because RestrictedTypeRules can send
+  // messages to CheckerReporter, for things like missing types.
+  // We should probably refactor so this can't happen, as codegen would be too
+  // late to be issuing these messages.
+  final CheckerReporter _checkerReporter;
+
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
   /// The variable for the current catch clause
   String _catchParameter;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashSet<String>();
   final _pendingPrivateNames = <String>[];
 
-  JSCodegenVisitor(LibraryInfo libraryInfo, TypeRules rules)
-      : libraryInfo = libraryInfo,
-        rules = rules;
+  JSCodegenVisitor(this.libraryInfo, this.rules, this._checkerReporter);
 
   Element get currentLibrary => libraryInfo.library;
 
-  JS.Program generateLibrary(
-      Iterable<CompilationUnit> units, CheckerReporter reporter) {
+  JS.Program generateLibrary(Iterable<CompilationUnit> units) {
     var body = <JS.Statement>[];
-    for (var unit in units) {
-      // TODO(jmesserly): this is needed because RestrictedTypeRules can send
-      // messages to CheckerReporter, for things like missing types.
-      // We should probably refactor so this can't happen.
-      var source = unit.element.source;
-      _constEvaluator = new ConstantEvaluator(source, rules.provider);
-      reporter.enterSource(source);
+
+    // Visit parts first, since the "part" declarations come before code
+    // in the main library's compilation unit.

[vsm, 2015/03/17 18:27:32]

Is there a way to assert that the first is a library and the rest are parts? 
Maybe a TODO.

[Jennifer Messerly, 2015/03/17 18:58:45]

Done. Introduced "LibraryUnit" type to assert the structure we expect. It turns
out dart_codegen was using a similar workaround in its generateLibrary, so that
got cleaned up a bit too.

+    for (var unit in units.skip(1)) {
       body.add(_visit(unit));
-      reporter.leaveSource();
     }
 
+    // Visit main library
+    body.add(_visit(units.first));
+
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       body.add(js.statement('$_EXPORTS.# = #;', [name, name]));
     }
 
     var name = jsLibraryName(libraryInfo.library);
     return new JS.Program([
       js.statement('var #;', name),
       js.statement("(function($_EXPORTS) { 'use strict'; #; })(# || (# = {}));",
           [body, name, name])
     ]);
   }
 
   JS.Statement _initPrivateSymbol(String name) =>
       js.statement('let # = Symbol(#);', [name, js.string(name, "'")]);
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
+    var source = node.element.source;
+
+    _constEvaluator = new ConstantEvaluator(source, rules.provider);
+    _checkerReporter.enterSource(source);
+
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
       var code = _visit(child);
 
       if (code != null) {
         if (_pendingPrivateNames.isNotEmpty) {
           body.addAll(_pendingPrivateNames.map(_initPrivateSymbol));
           _pendingPrivateNames.clear();
         }
         body.add(code);
       }
     }
 
     // Flush any unwritten fields/properties.
     _flushLazyFields(body);
     _flushLibraryProperties(body);
 
+    _checkerReporter.leaveSource();
+
     assert(_pendingPrivateNames.isEmpty);
     return _statement(body);
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
   /// Conversions that we don't handle end up here.
   @override
   visitConversion(Conversion node) {
     var from = node.baseType;
@@ skipping 85 matching lines @@
         'let # = dart.generic(function(#) { #; return #; });', [
       genericName,
       _visitList(node.typeParameters),
       clazz,
       name
     ]);
 
     // TODO(jmesserly): we may not want this to be `dynamic` if the generic
     // has a lower bound, e.g. `<T extends SomeType>`.
     // https://github.com/dart-lang/dart-dev-compiler/issues/38
-    var typeArgs = new List.filled(node.typeParameters.length, 'dynamic');
+    var typeArgs =
+        new List.filled(node.typeParameters.length, js.call('dart.dynamic'));
 
     var dynInst = js.statement('let # = #(#);', [name, genericName, typeArgs]);
 
     // TODO(jmesserly): is it worth exporting both names? Alternatively we could
     // put the generic type constructor on the <dynamic> instance.
     if (isPublic(name)) _exports.add('${name}\$');
     return new JS.Block([genericDef, dynInst]);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     currentClass = node;
 
+    // dart:core Object is a bit special.
+    var isObject = node.element.type.isObject;
+
     var body = <JS.Statement>[];
 
     var name = node.name.name;
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
     var jsMethods = <JS.Method>[];
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
-    if (ctors.isEmpty && !node.element.type.isObject) {
+    if (ctors.isEmpty && !isObject) {
       jsMethods.add(_emitImplicitConstructor(node, name, fields));
     }
 
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
-        jsMethods.add(_emitConstructor(member, name, fields));
+        jsMethods.add(_emitConstructor(member, name, fields, isObject));
       } else if (member is MethodDeclaration) {
         jsMethods.add(_visit(member));
       }
     }
 
     // Support for adapting dart:core Iterator/Iterable to ES6 versions.
     // This lets them use for-of loops transparently.
     // https://github.com/lukehoban/es6features#iterators--forof
     if (node.element.library.isDartCore && node.element.name == 'Iterable') {
       JS.Fun body = js.call('''function() {
         var iterator = this.iterator;
         return {
           next() {
             var done = iterator.moveNext();
             return { done: done, current: done ? void 0 : iterator.current };
           }
         };
       }''');
       jsMethods.add(new JS.Method(js.call('Symbol.iterator'), body));
     }
 
-    JS.Expression heritage;
+    JS.Expression heritage = null;
     if (node.extendsClause != null) {
       heritage = _visit(node.extendsClause.superclass);
-    } else {
-      heritage = js.call('dart.Object');
+    } else if (!isObject) {
+      heritage = _emitTypeName(rules.provider.objectType);
     }
     if (node.withClause != null) {
       var mixins = _visitList(node.withClause.mixinTypes);
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
     body.add(new JS.ClassDeclaration(new JS.ClassExpression(
         new JS.VariableDeclaration(name), heritage,
         jsMethods.where((m) => m != null).toList(growable: false))));
 
@@ skipping 38 matching lines @@
     if (fields.isEmpty) return null;
 
     dynamic body = _initializeFields(fields);
     var superCall = _superConstructorCall(node);
     if (superCall != null) body = [[body, superCall]];
     return new JS.Method(
         new JS.PropertyName(name), js.call('function() { #; }', body));
   }
 
   JS.Method _emitConstructor(ConstructorDeclaration node, String className,
-      List<FieldDeclaration> fields) {
+      List<FieldDeclaration> fields, bool isObject) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(className, node.name);
 
+    // Code generation for Object's constructor.
+    JS.Block body;
+    if (isObject &&
+        node.body is EmptyFunctionBody &&
+        node.constKeyword != null &&
+        node.name == null) {
+      // Implements Dart constructor behavior. Because of V8 `super`
+      // [constructor restrictions]
+      // (https://code.google.com/p/v8/issues/detail?id=3330#c65)
+      // we cannot currently emit actual ES6 constructors with super calls.
+      // Instead we use the same trick as named constructors, and do them as
+      // instance methods that perform initialization.
+      // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
+      // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
+      // Performance of this pattern is likely to be bad.
+      body = js.statement('''{
+        // Get the class name for this instance.
+        var name = this.constructor.name;
+        // Call the default constructor.
+        var init = this[name];
+        var result = void 0;
+        if (init) result = init.apply(this, arguments);
+        return result === void 0 ? this : result;
+      }''');
+    } else {
+      body = _emitConstructorBody(node, fields);
+    }
+
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
-    return new JS.Method(new JS.PropertyName(name),
-        new JS.Fun(_visit(node.parameters), _emitConstructorBody(node, fields)))
+    return new JS.Method(
+        new JS.PropertyName(name), new JS.Fun(_visit(node.parameters), body))
       ..sourceInformation = node;
   }
 
   String _constructorName(String className, SimpleIdentifier name) {
     if (name == null) return className;
     return '$className\$${name.name}';
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node, List<FieldDeclaration> fields) {
@@ skipping 283 matching lines @@
 
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.VariableUse(node.name));
     }
+
     var name = node.name;
+    var variable = e is PropertyAccessorElement ? e.variable : e;
+
     if (e.enclosingElement is CompilationUnitElement &&
-        (e.library != libraryInfo.library || _needsModuleGetter(e))) {
+        (e.library != libraryInfo.library ||
+            variable is TopLevelVariableElement && !variable.isConst)) {
       return js.call('#.#', [_libraryName(e.library), name]);
     } else if (currentClass != null && _needsImplicitThis(e)) {
       return js.call('this.#', _jsMemberName(name));
+    } else if (variable is ConstFieldElementImpl) {
+      var className = (variable.enclosingElement as ClassElement).name;
+      return js.call('#.#', [className, name]);
     } else if (e is ParameterElement && e.isInitializingFormal) {
       name = _fieldParameterName(name);
     }
     return new JS.VariableUse(name);
   }
 
   JS.Expression _emitTypeName(DartType type) {
     var name = type.name;
     var lib = type.element.library;
     if (name == '') {
@@ skipping 1038 matching lines @@
     // ConstantEvaluator will not compute constants for non-const fields
     // at least for cases like `int x = 0;`, so run ConstantVisitor for those.
     // TODO(jmesserly): ideally we'd only do this if we're sure it was skipped
     // by ConstantEvaluator.
     var initializer = field.initializer;
     if (initializer == null) return null;
 
     return _constEvaluator.evaluate(initializer);
   }
 
-  /// Returns true if [element] is a getter in JS, therefore needs
-  /// `lib.topLevel` syntax instead of just `topLevel`.
-  bool _needsModuleGetter(Element element) {
-    if (element is PropertyAccessorElement) {
-      element = (element as PropertyAccessorElement).variable;
-    }
-    return element is TopLevelVariableElement && !element.isConst;
-  }
-
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     if (result is JS.Node) result.sourceInformation = node;
     return result;
   }
 
   JS.Statement _visitOrEmpty(Statement node) {
     if (node == null) return new JS.EmptyStatement();
     return _visit(node);
@@ skipping 181 matching lines @@
 
 class JSGenerator extends CodeGenerator {
   final JSCodeOptions options;
 
   JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
       : super(outDir, root, rules);
 
   String generateLibrary(Iterable<CompilationUnit> units, LibraryInfo info,
       CheckerReporter reporter) {
     JS.Program jsTree =
-        new JSCodegenVisitor(info, rules).generateLibrary(units, reporter);
+        new JSCodegenVisitor(info, rules, reporter).generateLibrary(units);
 
     var outputPath = path.join(outDir, jsOutputPath(info, root));
     new Directory(path.dirname(outputPath)).createSync(recursive: true);
 
     if (options.emitSourceMaps) {
       var outFilename = path.basename(outputPath);
       var printer = new srcmaps.Printer(outFilename);
       _writeNode(
           new SourceMapPrintingContext(printer, path.dirname(outputPath)),
           jsTree);
@@ skipping 97 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }