fix #27644, allow "dart" and "dartx" to be renamed if needed

pkg/dev_compiler/lib/src/compiler/type_utilities.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, LinkedHashMap;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
 import '../js_ast/js_ast.dart' as JS;
@@ skipping 104 matching lines @@
   JS.Identifier chooseTypeName(DartType type) {
     return new JS.TemporaryId(_typeString(type));
   }
 }
 
 /// _GeneratorTable tracks types which have been
 /// named and hoisted.
 class _GeneratorTable extends _CacheTable {
   final _defs = new HashMap<DartType, JS.Expression>();
 
+  final JS.Identifier _runtimeModule;
+
+  _GeneratorTable(this._runtimeModule);
+
   JS.Statement _dischargeType(DartType t) {
     var name = _names.remove(t);
     if (name != null) {
       JS.Expression init = _defs.remove(t);
       assert(init != null);
       return js.statement(
-          'let # = () => ((# = dart.constFn(#))());', [name, name, init]);
+          'let # = () => ((# = #.constFn(#))());', [name, name, _runtimeModule, init]);
     }
     return null;
   }
 
   /// If [type] does not already have a generator name chosen for it,
   /// assign it one, using [typeRep] as the initializer for it.
   /// Emit an expression which calls the generator name.
   JS.Expression nameType(DartType type, JS.Expression typeRep) {
     var temp = _names[type];
     if (temp == null) {
       _names[type] = temp = chooseTypeName(type);
       _defs[type] = typeRep;
     }
     return js.call('#()', [temp]);
   }
 }
 
 class TypeTable {
   /// Cache variable names for types emitted in place.
   final _cacheNames = new _CacheTable();
 
   /// Cache variable names for definite function types emitted in place.
   final _definiteCacheNames = new _CacheTable();
 
   /// Generator variable names for hoisted types.
-  final _generators = new _GeneratorTable();
+  final _GeneratorTable _generators;
 
   /// Generator variable names for hoisted definite function types.
-  final _definiteGenerators = new _GeneratorTable();
+  final _GeneratorTable _definiteGenerators;
 
   /// Mapping from type parameters to the types which must have their
   /// cache/generator variables discharged at the binding site for the
   /// type variable since the type definition depends on the type
   /// parameter.
   final _scopeDependencies =
       new HashMap<TypeParameterElement, List<DartType>>();
 
+  TypeTable(JS.Identifier runtime)
+      : _generators = new _GeneratorTable(runtime),
+        _definiteGenerators = new _GeneratorTable(runtime);
+
   /// Emit a list of statements declaring the cache variables and generator
   /// definitions tracked by the table.  If [formals] is present, only
   /// emit the definitions which depend on the formals.
   List<JS.Statement> discharge([List<TypeParameterElement> formals]) {
     var filter = formals?.expand((p) => _scopeDependencies[p] ?? <DartType>[]);
     var stmts = [
       _cacheNames,
       _definiteCacheNames,
       _generators,
       _definiteGenerators
@@ skipping 50 matching lines @@
     assert(hoistType != null);
     var table = hoistType
         ? (definite ? _definiteGenerators : _generators)
         : (definite ? _definiteCacheNames : _cacheNames);
     if (!table.isNamed(type)) {
       if (recordScopeDependencies(type)) return typeRep;
     }
     return table.nameType(type, typeRep);
   }
 }