fix #569, cache constants defined in methods

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 23 matching lines @@
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleFormat;
 import 'element_helpers.dart';
 import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_field_storage.dart' show checkForPropertyOverride, getSuperclasses;
 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 LegacyModuleBuilder, NodeModuleBuilder, pathToJSIdentifier;
+    show
+        LegacyModuleBuilder,
+        NodeModuleBuilder,
+        pathToJSIdentifier,
+        toJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'source_map_printer.dart' show SourceMapPrintingContext;
 
 class CodeGenerator extends GeneralizingAstVisitor
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
   final AnalysisContext context;
   final CompilerOptions options;
   final rules = new StrongTypeSystemImpl();
@@ skipping 62 matching lines @@
 
   BuildUnit _buildUnit;
 
   String _buildRoot;
 
   bool _superAllowed = true;
 
   List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
   List<JS.Method> _superHelpers = <JS.Method>[];
 
+  List<TypeParameterType> _typeParamInConst = null;
+
   /// Whether we are currently generating code for the body of a `JS()` call.
   bool _isInForeignJS = false;
 
   CodeGenerator(AnalysisContext c, this.options, this._extensionTypes)
       : context = c,
         types = c.typeProvider,
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
@@ skipping 2155 matching lines @@
     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.
       var ft = type as FunctionType;
       var parts = _emitFunctionTypeParts(ft, lowerTypedef: lowerTypedef);
       return js.call('dart.functionType(#)', [parts]);
     }
 
     if (type is TypeParameterType) {
+      _typeParamInConst?.add(type);
       return new JS.Identifier(name);
     }
 
     if (type == subClass?.type) {
       return className;
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       Iterable jsArgs = null;
@@ skipping 1066 matching lines @@
     variable ??= new JS.TemporaryId(name);
 
     id.staticElement = new TemporaryVariableElement.forNode(id, variable);
     id.staticType = type;
     DynamicInvoke.set(id, type.isDynamic);
     addTemporaryVariable(id.staticElement, nullable: nullable);
     return id;
   }
 
   JS.Expression _emitConst(JS.Expression expr()) {
-    // TODO(jmesserly): emit the constants at top level if possible.
-    // This wasn't quite working, so disabled for now.
-    return js.call('dart.const(#)', expr());
+    var savedTypeParams = _typeParamInConst;
+    _typeParamInConst = [];
+
+    var jsExpr = js.call('dart.const(#)', expr());
+
+    bool usesTypeParams = _typeParamInConst.isNotEmpty;
+    _typeParamInConst = savedTypeParams;
+
+    // TODO(jmesserly): if it uses type params we can still hoist it up as far
+    // as it will go, e.g. at the level the generic class is defined where type
+    // params are available.
+    if (_currentFunction == null || usesTypeParams) return jsExpr;
+
+    var temp = new JS.TemporaryId('const');
+    _moduleItems.add(js.statement('let #;', [temp]));
+    return js.call('# || (# = #)', [temp, temp, jsExpr]);
   }
 
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
   /// The temporary scope will ensure `expr1` and `expr2` are only evaluated
   /// once: `((x1, x2) => x1[x2] = x1[x2] + y)(expr1, expr2)`.
   ///
@@ skipping 1063 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';