Special-case top-level final JS 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, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1303 matching lines @@
     if (needsTagging) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
     if (isPublic(name)) _addExport(name);
     return _statement(body);
   }
 
   bool _isInlineJSFunction(FunctionExpression functionExpression) {
-    bool isJsInvocation(Expression expr) =>
-        expr is MethodInvocation && isInlineJS(expr.methodName.staticElement);
-
     var body = functionExpression.body;
     if (body is ExpressionFunctionBody) {
-      return isJsInvocation(body.expression);
+      return _isJSInvocation(body.expression);
     } else if (body is BlockFunctionBody) {
       if (body.block.statements.length == 1) {
         var stat = body.block.statements.single;
         if (stat is ReturnStatement) {
-          return isJsInvocation(stat.expression);
+          return _isJSInvocation(stat.expression);
         }
       }
     }
     return false;
   }
 
+  bool _isJSInvocation(Expression expr) =>
+      expr is MethodInvocation && isInlineJS(expr.methodName.staticElement);
+
   // Simplify `(args) => ((x, y) => { ... })(x, y)` to `(args) => { ... }`.
   // Note: we don't check if the top-level args match the ones passed through
   // the arrow function, which allows silently passing args through to the
   // body (which only works if we don't do weird renamings of Dart params).
   JS.Fun _simplifyPassThroughArrowFunCallBody(JS.Fun fn) {
     String getIdent(JS.Node node) => node is JS.Identifier ? node.name : null;
     List<String> getIdents(List params) =>
         params.map(getIdent).toList(growable: false);
 
     if (fn.body is JS.Block && fn.body.statements.length == 1) {
@@ skipping 386 matching lines @@
     return _maybeQualifiedName(element);
   }
 
   JS.Expression _maybeQualifiedName(Element e, [String name]) {
     var libName = _libraryName(e.library);
     var nameExpr = _propertyName(name ?? e.name);
 
     // Always qualify:
     // * mutable top-level fields
     // * elements from other libraries
-    bool mutableTopLevel = e is TopLevelVariableElement && !e.isConst;
+    bool mutableTopLevel = e is TopLevelVariableElement &&
+        !e.isConst &&
+        !_isFinalJSDecl(e.computeNode());
     bool fromAnotherLibrary = e.library != currentLibrary;
     if (mutableTopLevel || fromAnotherLibrary) {
       return new JS.PropertyAccess(libName, nameExpr);
     }
 
     var id = new JS.MaybeQualifiedId(libName, nameExpr);
     _qualifiedIds.add(new Tuple2(e, id));
     return id;
   }
 
@@ skipping 325 matching lines @@
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) return _emitStaticField(node);
 
     var name = new JS.Identifier(node.name.name);
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
+  bool _isFinalJSDecl(AstNode field) => field is VariableDeclaration &&
+      field.isFinal &&
+      _isJSInvocation(field.initializer);
+
   /// Emits a static or top-level field.
   JS.Statement _emitStaticField(VariableDeclaration field) {
     PropertyInducingElement 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 {
       jsInit = _visitInitializer(field);
       eagerInit = false;
     }
 
+    // Treat `final x = JS('', '...')` as a const (non-lazy) to help compile
+    // runtime helpers.
+    var isJSTopLevel = field.isFinal && _isFinalJSDecl(field);
+    if (isJSTopLevel) eagerInit = true;
+
     var fieldName = field.name.name;
-    if (field.isConst && eagerInit && element is TopLevelVariableElement) {
+    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);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       return annotateVariable(
           js.statement(
               '$declKeyword # = #;', [new JS.Identifier(fieldName), jsInit]),
           field.element);
@@ skipping 1294 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);
 }