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

pkg/dev_compiler/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';
@@ skipping 56 matching lines @@
   /// name scoping requirements.
   final _libraries = new Map<LibraryElement, JS.Identifier>();
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
 
   /// The list of output module items, in the order they need to be emitted in.
   final _moduleItems = <JS.ModuleItem>[];
 
   /// Table of named and possibly hoisted types.
-  final _typeTable = new TypeTable();
+  TypeTable _typeTable;
 
   /// The global extension type table.
   final ExtensionTypeSet _extensionTypes;
 
   /// The variable for the target of the current `..` cascade expression.
   ///
   /// Usually a [SimpleIdentifier], but it can also be other expressions
   /// that are safe to evaluate multiple times, such as `this`.
   Expression _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   /// In an async* function, this represents the stream controller parameter.
   JS.TemporaryId _asyncStarController;
 
   // TODO(jmesserly): fuse this with notNull check.
   final _privateNames =
       new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _initializingFormalTemps =
       new HashMap<ParameterElement, JS.TemporaryId>();
 
-  final _dartxVar = new JS.Identifier('dartx');
-  final _runtimeLibVar = new JS.Identifier('dart');
+  JS.Identifier _extensionSymbolsModule;
+  JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   final _eagerTopLevelFields = new HashSet<Element>.identity();
 
   /// The  type provider from the current Analysis [context].
   final TypeProvider types;
 
   final LibraryElement dartCoreLibrary;
@@ skipping 112 matching lines @@
   }
 
   JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
     if (_moduleItems.isNotEmpty) {
       throw new StateError('Can only call emitModule once.');
     }
 
     // Transform the AST to make coercions explicit.
     compilationUnits = CoercionReifier.reify(compilationUnits);
 
+    if (compilationUnits.any((u) => _isDartRuntime(u.element.library))) {
+      // Don't allow these to be renamed when we're building the SDK.
+      // There is JS code in dart:* that depends on their names.
+      _runtimeModule = new JS.Identifier('dart');
+      _extensionSymbolsModule = new JS.Identifier('dartx');
+    } else {
+      // Otherwise allow these to be renamed so users can write them.
+      _runtimeModule = new JS.TemporaryId('dart');
+      _extensionSymbolsModule = new JS.TemporaryId('dartx');
+    }
+    _typeTable = new TypeTable(_runtimeModule);
+
     // Initialize our library variables.
     var items = <JS.ModuleItem>[];
     for (var unit in compilationUnits) {
       var library = unit.element.library;
       if (unit.element != library.definingCompilationUnit) continue;
 
       var libraryTemp = _isDartRuntime(library)
-          ? _runtimeLibVar
+          ? _runtimeModule
           : new JS.TemporaryId(jsLibraryName(_libraryRoot, library));
       _libraries[library] = libraryTemp;
       items.add(new JS.ExportDeclaration(
           js.call('const # = Object.create(null)', [libraryTemp])));
 
       // dart:_runtime has a magic module that holds extension method symbols.
       // TODO(jmesserly): find a cleaner design for this.
       if (_isDartRuntime(library)) {
-        items.add(new JS.ExportDeclaration(
-            js.call('const # = Object.create(null)', [_dartxVar])));
+        items.add(new JS.ExportDeclaration(js
+            .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
     // Collect all Element -> Node mappings, in case we need to forward declare
     // any nodes.
     var nodes = new HashMap<Element, AstNode>.identity();
     var sdkBootstrappingFns = new List<FunctionElement>();
     for (var unit in compilationUnits) {
       if (_isDartRuntime(unit.element.library)) {
         sdkBootstrappingFns.addAll(unit.element.functions);
@@ skipping 63 matching lines @@
       elementJSParts.add(e.name);
     }
 
     return libraryPrefix..addAll(elementJSParts);
   }
 
   JS.Expression _emitJSInterop(Element e) {
     var jsName = _getJSName(e);
     if (jsName == null) return null;
     var fullName = ['global']..addAll(jsName);
-    JS.Expression access = _runtimeLibVar;
+    JS.Expression access = _runtimeModule;
     for (var part in fullName) {
       access = new JS.PropertyAccess(access, js.string(part));
     }
     return access;
   }
 
   /// Flattens blocks in [items] to a single list.
   ///
   /// This will not flatten blocks that are marked as being scopes.
   void _copyAndFlattenBlocks(
@@ skipping 38 matching lines @@
       // Our import variables are temps and can get renamed. Since our renaming
       // is integrated into js_ast, it is aware of this possibility and will
       // generate an "as" if needed. For example:
       //
       //     import {foo} from 'foo';         // if no rename needed
       //     import {foo as foo$} from 'foo'; // if rename was needed
       //
       var imports =
           libraries.map((l) => new JS.NameSpecifier(_imports[l])).toList();
       if (module == coreModuleName) {
-        imports.add(new JS.NameSpecifier(_runtimeLibVar));
-        imports.add(new JS.NameSpecifier(_dartxVar));
+        imports.add(new JS.NameSpecifier(_runtimeModule));
+        imports.add(new JS.NameSpecifier(_extensionSymbolsModule));
       }
       items.add(new JS.ImportDeclaration(
           namedImports: imports, from: js.string(module, "'")));
     });
   }
 
   /// Collect toplevel elements and nodes we need to emit, and returns
   /// an ordered map of these.
   static void _collectElements(
       CompilationUnit unit, Map<Element, AstNode> map) {
@@ skipping 95 matching lines @@
           _eagerTopLevelFields.contains(export)) {
         // classes, typedefs, functions, and eager init fields can be assigned
         // directly.
         // TODO(jmesserly): we don't know about eager init fields from other
         // modules we import, so we will never go down this code path for them.
         _moduleItems
             .add(js.statement('#.# = #;', [libraryName, name.selector, name]));
       } else {
         // top-level fields, getters, setters need to copy the property
         // descriptor.
-        _moduleItems.add(js.statement('dart.export(#, #, #);',
-            [libraryName, name.receiver, name.selector]));
+        _moduleItems.add(_callHelperStatement(
+            'export(#, #, #);', [libraryName, name.receiver, name.selector]));
       }
     }
 
     for (var export in exportedNames.definedNames.values) {
       if (export is PropertyAccessorElement) {
         export = (export as PropertyAccessorElement).variable;
       }
 
       // Don't allow redefining names from this library.
       if (currentNames.containsKey(export.name)) continue;
@@ skipping 23 matching lines @@
     if (_inWhitelistCode(node)) return jsFrom;
 
     // Skip the cast if it's not needed.
     if (rules.isSubtypeOf(from, to)) return jsFrom;
 
     // All Dart number types map to a JS double.
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
       if (from != types.intType && to == types.intType) {
         // TODO(jmesserly): fuse this with notNull check.
-        return js.call('dart.asInt(#)', jsFrom);
+        return _callHelper('asInt(#)', jsFrom);
       }
 
       // A no-op in JavaScript.
       return jsFrom;
     }
 
     var type = _emitType(to,
         nameType: options.nameTypeTests || options.hoistTypeTests,
         hoistType: options.hoistTypeTests);
     if (CoercionReifier.isImplicitCast(node)) {
@@ skipping 33 matching lines @@
     if (t == types.stringType) return 'string';
     if (t == types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
 
     JS.Expression body = annotate(
-        js.call('dart.typedef(#, () => #)', [
+        _callHelper('typedef(#, () => #)', [
           js.string(element.name, "'"),
           _emitType(element.type, nameType: false, lowerTypedef: true)
         ]),
         node,
         element);
 
     var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(element, typeFormals,
           js.statement('const # = #;', [element.name, body]));
     } else {
       return js.statement('# = #;', [_emitTopLevelName(element), body]);
     }
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) {
     if (node.type == null) {
       // TODO(jmesserly): if the type fails to resolve, should we generate code
       // that throws instead?
       assert(options.unsafeForceCompile || options.replCompile);
-      return js.call('dart.dynamic');
+      return _callHelper('dynamic');
     }
     return _emitType(node.type);
   }
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
 
     // Forward all generative constructors from the base class.
     var methods = <JS.Method>[];
@@ skipping 144 matching lines @@
   /// constructor.
   ///
   /// This ensures instances created by the unnamed constructor are functions.
   /// Named constructors are handled elsewhere, see [_defineNamedConstructors].
   JS.Expression _emitCallableClass(
       JS.ClassExpression classExpr, ConstructorElement unnamedCtor) {
     var ctor = new JS.NamedFunction(
         classExpr.name, _emitCallableClassConstructor(unnamedCtor));
 
     // Name the constructor function the same as the class.
-    return js.call('dart.callableClass(#, #)', [ctor, classExpr]);
+    return _callHelper('callableClass(#, #)', [ctor, classExpr]);
   }
 
   /// Emits a constructor that ensures instances of this class are callable as
   /// functions in JavaScript.
   JS.Fun _emitCallableClassConstructor(ConstructorElement ctor) {
     return js.call(
         r'''function (...args) {
           function call(...args) {
             return call.call.apply(call, args);
           }
@@ skipping 10 matching lines @@
       // We rely on ES6 static inheritance.  All types that are represented by
       // class constructor functions will see these definitions, with [this]
       // being bound to the class constructor.
 
       // The 'instanceof' checks don't work for primitive types (which have fast
       // definitions below) and don't work for native types. In those cases we
       // fall through to the general purpose checking code.
       body.add(js.statement(
           '#.is = function is_Object(o) {'
           '  if (o instanceof this) return true;'
-          '  return dart.is(o, this);'
+          '  return #.is(o, this);'
           '}',
-          className));
+          [className, _runtimeModule]));
       body.add(js.statement(
           '#.as = function as_Object(o) {'
           '  if (o == null || o instanceof this) return o;'
-          '  return dart.as(o, this);'
+          '  return #.as(o, this);'
           '}',
-          className));
+          [className, _runtimeModule]));
       body.add(js.statement(
           '#._check = function check_Object(o) {'
           '  if (o == null || o instanceof this) return o;'
-          '  return dart.check(o, this);'
+          '  return #.check(o, this);'
           '}',
-          className));
+          [className, _runtimeModule]));
       return;
     }
     if (classElem == stringClass) {
       body.add(js.statement(
           '#.is = function is_String(o) { return typeof o == "string"; }',
           className));
       body.add(js.statement(
           '#.as = function as_String(o) {'
           '  if (typeof o == "string" || o == null) return o;'
-          '  return dart.as(o, #);'
+          '  return #.as(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       body.add(js.statement(
           '#._check = function check_String(o) {'
           '  if (typeof o == "string" || o == null) return o;'
-          '  return dart.check(o, #);'
+          '  return #.check(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       return;
     }
     if (classElem == intClass) {
       body.add(js.statement(
           '#.is = function is_int(o) {'
           '  return typeof o == "number" && Math.floor(o) == o;'
           '}',
           className));
       body.add(js.statement(
           '#.as = function as_int(o) {'
           '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
           '    return o;'
-          '  return dart.as(o, #);'
+          '  return #.as(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       body.add(js.statement(
           '#._check = function check_int(o) {'
           '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
           '    return o;'
-          '  return dart.check(o, #);'
+          '  return #.check(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       return;
     }
     if (classElem == nullClass) {
       body.add(js.statement(
           '#.is = function is_Null(o) { return o == null; }', className));
       body.add(js.statement(
           '#.as = function as_Null(o) {'
           '  if (o == null) return o;'
-          '  return dart.as(o, #);'
+          '  return #.as(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       body.add(js.statement(
           '#._check = function check_Null(o) {'
           '  if (o == null) return o;'
-          '  return dart.check(o, #);'
+          '  return #.check(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       return;
     }
     if (classElem == numClass) {
       body.add(js.statement(
           '#.is = function is_num(o) { return typeof o == "number"; }',
           className));
       body.add(js.statement(
           '#.as = function as_num(o) {'
           '  if (typeof o == "number" || o == null) return o;'
-          '  return dart.as(o, #);'
+          '  return #.as(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       body.add(js.statement(
           '#._check = function check_num(o) {'
           '  if (typeof o == "number" || o == null) return o;'
-          '  return dart.check(o, #);'
+          '  return #.check(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       return;
     }
     if (classElem == boolClass) {
       body.add(js.statement(
           '#.is = function is_bool(o) { return o === true || o === false; }',
           className));
       body.add(js.statement(
           '#.as = function as_bool(o) {'
           '  if (o === true || o === false || o == null) return o;'
-          '  return dart.as(o, #);'
+          '  return #.as(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       body.add(js.statement(
           '#._check = function check_bool(o) {'
           '  if (o === true || o === false || o == null) return o;'
-          '  return dart.check(o, #);'
+          '  return #.check(o, #);'
           '}',
-          [className, className]));
+          [className, _runtimeModule, className]));
       return;
     }
     // TODO(sra): Add special cases for hot tests like `x is html.Element`.
 
     // `instanceof` check is futile for classes that are Interceptor classes.
     ClassElement parent = classElem;
     while (parent != objectClass) {
       if (parent == interceptorClass) {
         if (classElem == interceptorClass) {
           // Place non-instanceof version of checks on Interceptor. All
           // interceptor classes will inherit the methods via ES6 class static
           // inheritance.
-          body.add(js.statement('dart.addTypeTests(#);', className));
+          body.add(_callHelperStatement('addTypeTests(#);', className));
 
           // TODO(sra): We could place on the extension type a pointer to the
           // peer constructor and use that for the `instanceof` check, e.g.
           //
           //    if (o instanceof this[_peerConstructor]) return o;
           //
         }
         return;
       }
       parent = parent.type.superclass.element;
@@ skipping 17 matching lines @@
       return true;
     }
 
     assert(classElem != objectClass);
     bool thisIsSimple = isSimple(classElem);
     bool superIsSimple = isSimple(classElem.type.superclass.element);
 
     if (thisIsSimple == superIsSimple) return;
 
     if (thisIsSimple) {
-      body.add(js.statement('dart.addSimpleTypeTests(#);', className));
+      body.add(_callHelperStatement('addSimpleTypeTests(#);', className));
     } else {
-      body.add(js.statement('dart.addTypeTests(#);', className));
+      body.add(_callHelperStatement('addTypeTests(#);', className));
     }
   }
 
   void _emitSuperHelperSymbols(
       List<JS.TemporaryId> superHelperSymbols, List<JS.Statement> body) {
     for (var id in superHelperSymbols) {
       body.add(js.statement('const # = Symbol(#)', [id, js.string(id.name)]));
     }
     superHelperSymbols.clear();
   }
@@ skipping 97 matching lines @@
     // Create enum class
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _emitClassHeritage(element), [constructor, toStringF]);
     var id = _emitTopLevelName(element);
     var result = [
       js.statement('# = #', [id, classExpr])
     ];
 
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
-      result.add(js.statement('#.# = dart.const(new #(#));',
-          [id, fields[i].name, id, js.number(i)]));
+      result.add(js.statement('#.# = #.const(new #(#));',
+          [id, fields[i].name, _runtimeModule, id, js.number(i)]));
     }
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
         fields.map((f) => js.call('#.#', [id, f.name]))));
 
     // dart.constList helper internally depends on _interceptors.JSArray.
     _declareBeforeUse(_jsArray);
 
-    result.add(js.statement(
-        '#.values = dart.constList(#, #);', [id, values, _emitType(type)]));
+    result.add(js.statement('#.values = #.constList(#, #);',
+        [id, _runtimeModule, values, _emitType(type)]));
 
     return _statement(result);
   }
 
   /// Wraps a possibly generic class in its type arguments.
   JS.Statement _defineClassTypeArguments(TypeDefiningElement element,
       List<TypeParameterElement> formals, JS.Statement body) {
     assert(formals.isNotEmpty);
-    var genericCall = js.call('dart.generic((#) => { #; #; return #; })', [
+    var genericCall = _callHelper('generic((#) => { #; #; return #; })', [
       _emitTypeFormals(formals),
       _typeTable.discharge(formals),
       body,
       element.name
     ]);
     if (element.library.isDartAsync &&
         (element.name == "Future" || element.name == "_Future")) {
-      genericCall = js.call('dart.flattenFutures(#)', [genericCall]);
+      genericCall = _callHelper('flattenFutures(#)', [genericCall]);
     }
     var genericDef = js.statement(
         '# = #;', [_emitTopLevelName(element, suffix: r'$'), genericCall]);
     var dynType = fillDynamicTypeArgs(element.type);
     var genericInst = _emitType(dynType, lowerGeneric: true);
     return js.statement(
         '{ #; # = #; }', [genericDef, _emitTopLevelName(element), genericInst]);
   }
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
@@ skipping 37 matching lines @@
       _hasDeferredSupertype.add(element);
     }
     // We could choose to name the superclasses, but it's
     // not clear that there's much benefit
     heritage = _emitType(supertype, nameType: false);
 
     if (type.mixins.isNotEmpty) {
       var mixins =
           type.mixins.map((t) => _emitType(t, nameType: false)).toList();
       mixins.insert(0, heritage);
-      heritage = js.call('dart.mixin(#)', [mixins]);
+      heritage = _callHelper('mixin(#)', [mixins]);
     }
 
     _loader.finishTopLevel(element);
 
     return heritage;
   }
 
   /// Provide Dart getters and setters that forward to the underlying native
   /// field.  Note that the Dart names are always symbolized to avoid
   /// conflicts.  They will be installed as extension methods on the underlying
@@ skipping 199 matching lines @@
     var invocationProps = <JS.Property>[];
     addProperty(String name, JS.Expression value) {
       invocationProps.add(new JS.Property(js.string(name), value));
     }
 
     var args = new JS.TemporaryId('args');
     var fnArgs = <JS.Parameter>[];
     JS.Expression positionalArgs;
 
     if (method.type.namedParameterTypes.isNotEmpty) {
-      addProperty(
-          'namedArguments', js.call('dart.extractNamedArgs(#)', [args]));
+      addProperty('namedArguments', _callHelper('extractNamedArgs(#)', [args]));
     }
 
     if (method is MethodElement) {
       addProperty('isMethod', js.boolean(true));
 
       fnArgs.add(new JS.RestParameter(args));
       positionalArgs = args;
     } else {
       var property = method as PropertyAccessorElement;
       if (property.isGetter) {
         addProperty('isGetter', js.boolean(true));
 
         positionalArgs = new JS.ArrayInitializer([]);
       } else if (property.isSetter) {
         addProperty('isSetter', js.boolean(true));
 
         fnArgs.add(args);
         positionalArgs = new JS.ArrayInitializer([args]);
       }
     }
 
-    var fnBody =
-        js.call('this.noSuchMethod(new dart.InvocationImpl(#, #, #))', [
+    var fnBody = js.call('this.noSuchMethod(new #.InvocationImpl(#, #, #))', [
+      _runtimeModule,
       _declareMemberName(method),
       positionalArgs,
       new JS.ObjectInitializer(invocationProps)
     ]);
 
     if (!method.returnType.isDynamic) {
       fnBody = js.call('#._check(#)', [_emitType(method.returnType), fnBody]);
     }
 
     var fn = new JS.Fun(fnArgs, js.statement('{ return #; }', [fnBody]),
@@ skipping 97 matching lines @@
     // simple code size optimization.
     var parent = t.lookUpGetterInSuperclass('iterator', t.element.library);
     if (parent != null) return null;
     var parentType = findSupertype(t, _implementsIterable);
     if (parentType != null) return null;
 
     // Otherwise, emit the adapter method, which wraps the Dart iterator in
     // an ES6 iterator.
     return new JS.Method(
         js.call('Symbol.iterator'),
-        js.call('function() { return new dart.JsIterator(this.#); }',
-            [_emitMemberName('iterator', type: t)]) as JS.Fun);
+        js.call('function() { return new #.JsIterator(this.#); }',
+            [_runtimeModule, _emitMemberName('iterator', type: t)]) as JS.Fun);
   }
 
   JS.Expression _instantiateAnnotation(Annotation node) {
     var element = node.element;
     if (element is ConstructorElement) {
       return _emitInstanceCreationExpression(element, element.returnType,
           node.constructorName, node.arguments, true);
     } else {
       return _visit(node.name);
     }
@@ skipping 16 matching lines @@
           .where((peer) => !peer.startsWith("!"))
           .toList();
     } else {
       return [];
     }
   }
 
   void _registerExtensionType(
       ClassElement classElem, String jsPeerName, List<JS.Statement> body) {
     if (jsPeerName != null) {
-      body.add(js.statement('dart.registerExtension(dart.global.#, #);',
-          [_propertyName(jsPeerName), _emitTopLevelName(classElem)]));
+      body.add(_callHelperStatement('registerExtension(#.global.#, #);', [
+        _runtimeModule,
+        _propertyName(jsPeerName),
+        _emitTopLevelName(classElem)
+      ]));
     }
   }
 
   void _setBaseClass(ClassElement classElem, JS.Expression className,
       List<String> jsPeerNames, List<JS.Statement> body) {
     if (jsPeerNames.isNotEmpty && classElem.typeParameters.isNotEmpty) {
       for (var peer in jsPeerNames) {
         // TODO(jmesserly): we should just extend Array in the first place
-        var newBaseClass = js.call('dart.global.#', [peer]);
-        body.add(js.statement(
-            'dart.setExtensionBaseClass(#, #);', [className, newBaseClass]));
+        var newBaseClass = _callHelper('global.#', [peer]);
+        body.add(_callHelperStatement(
+            'setExtensionBaseClass(#, #);', [className, newBaseClass]));
       }
     } else if (_hasDeferredSupertype.contains(classElem)) {
       var newBaseClass = _emitType(classElem.type.superclass,
           nameType: false, subClass: classElem, className: className);
-      body.add(
-          js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
+      body.add(_callHelperStatement(
+          'setBaseClass(#, #);', [className, newBaseClass]));
     }
   }
 
   void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
       List<JS.Statement> body, JS.Expression className, bool isCallable) {
     var code = isCallable
-        ? 'dart.defineNamedConstructorCallable(#, #, #);'
-        : 'dart.defineNamedConstructor(#, #)';
+        ? 'defineNamedConstructorCallable(#, #, #);'
+        : 'defineNamedConstructor(#, #)';
 
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
         var args = [className, _constructorName(member.element)];
         if (isCallable) {
           args.add(_emitCallableClassConstructor(member.element));
         }
 
-        body.add(js.statement(code, args));
+        body.add(_callHelperStatement(code, args));
       }
     }
   }
 
   /// Emits static fields for a class, and initialize them eagerly if possible,
   /// otherwise define them as lazy properties.
   void _emitStaticFields(
       List<FieldDeclaration> staticFields,
       Set<FieldElement> staticFieldOverrides,
       ClassElement classElem,
@@ skipping 12 matching lines @@
     }
     if (lazyStatics.isNotEmpty) {
       body.add(_emitLazyFields(classElem, lazyStatics));
     }
   }
 
   void _emitClassMetadata(List<Annotation> metadata, JS.Expression className,
       List<JS.Statement> body) {
     // Metadata
     if (options.emitMetadata && metadata.isNotEmpty) {
-      body.add(js.statement('#[dart.metadata] = () => #;', [
+      body.add(js.statement('#[#.metadata] = () => #;', [
         className,
+        _runtimeModule,
         new JS.ArrayInitializer(
             new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
       ]));
     }
   }
 
   /// If a concrete class implements one of our extensions, we might need to
   /// add forwarders.
   void _defineExtensionMembers(List<ExecutableElement> extensions,
       JS.Expression className, List<JS.Statement> body) {
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     if (extensions.isNotEmpty) {
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
         methodNames.add(_declareMemberName(e, useExtension: false));
       }
-      body.add(js.statement('dart.defineExtensionMembers(#, #);', [
+      body.add(_callHelperStatement('defineExtensionMembers(#, #);', [
         className,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
   }
 
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       ClassElement classElem,
       List<ConstructorDeclaration> ctors,
       List<ExecutableElement> extensions,
       JS.Expression className,
       List<JS.Statement> body) {
     if (classElem.interfaces.isNotEmpty) {
-      body.add(js.statement('#[dart.implements] = () => #;', [
+      body.add(js.statement('#[#.implements] = () => #;', [
         className,
+        _runtimeModule,
         new JS.ArrayInitializer(
             new List<JS.Expression>.from(classElem.interfaces.map(_emitType)))
       ]));
     }
 
     var tStaticMethods = <JS.Property>[];
     var tInstanceMethods = <JS.Property>[];
     var tStaticGetters = <JS.Property>[];
     var tInstanceGetters = <JS.Property>[];
     var tStaticSetters = <JS.Property>[];
@@ skipping 102 matching lines @@
     if (!tStaticMethods.isEmpty) {
       assert(!sNames.isEmpty);
       // TODO(vsm): Why do we need this names field?
       var aNames = new JS.Property(
           _propertyName('names'), new JS.ArrayInitializer(sNames));
       sigFields.add(build('statics', tStaticMethods));
       sigFields.add(aNames);
     }
     if (!sigFields.isEmpty || extensions.isNotEmpty) {
       var sig = new JS.ObjectInitializer(sigFields);
-      body.add(js.statement('dart.setSignature(#, #);', [className, sig]));
+      body.add(_callHelperStatement('setSignature(#, #);', [className, sig]));
     }
     // Add static property dart._runtimeType to Object.
     // All other Dart classes will (statically) inherit this property.
     if (classElem == objectClass) {
-      body.add(js.statement('dart.tagComputed(#, () => #.#);',
+      body.add(_callHelperStatement('tagComputed(#, () => #.#);',
           [className, emitLibraryName(dartCoreLibrary), 'Type']));
     }
   }
 
   /// Ensure `dartx.` symbols we will use are present.
   void _initExtensionSymbols(
       ClassElement classElem,
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       List<JS.Statement> body) {
     if (_extensionTypes.hasNativeSubtype(classElem.type)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_declareMemberName(m.element, useExtension: false));
         }
       }
       for (var fieldDecl in fields) {
         if (!fieldDecl.isStatic) {
           for (var field in fieldDecl.fields.variables) {
             var e = field.element as FieldElement;
             if (e.isPublic) {
               dartxNames.add(_declareMemberName(e.getter, useExtension: false));
             }
           }
         }
       }
       if (dartxNames.isNotEmpty) {
-        body.add(js.statement('dart.defineExtensionNames(#)',
+        body.add(_callHelperStatement('defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.isNativeClass(element)) return members;
 
     // Collect all extension types we implement.
@@ skipping 459 matching lines @@
 
     // If we have a getter/setter pair, they need to be defined together.
     if (node.isGetter) {
       PropertyAccessorElement element = node.element;
       var props = <JS.Method>[_emitTopLevelProperty(node)];
       var setter = element.correspondingSetter;
       if (setter != null) {
         props.add(_loader.emitDeclaration(
             setter, (node) => _emitTopLevelProperty(node)));
       }
-      return js.statement('dart.copyProperties(#, { # });',
+      return _callHelperStatement('copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
     }
     if (node.isSetter) {
       PropertyAccessorElement element = node.element;
       var props = <JS.Method>[_emitTopLevelProperty(node)];
       var getter = element.correspondingGetter;
       if (getter != null) {
         props.add(_loader.emitDeclaration(
             getter, (node) => _emitTopLevelProperty(node)));
       }
-      return js.statement('dart.copyProperties(#, { # });',
+      return _callHelperStatement('copyProperties(#, { # });',
           [emitLibraryName(currentLibrary), props]);
     }
 
     var body = <JS.Statement>[];
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
@@ skipping 78 matching lines @@
       return false;
     }
     return _loader.isLoaded(type.element);
   }
 
   JS.Expression _emitFunctionTagged(JS.Expression fn, DartType type,
       {topLevel: false}) {
     var lazy = topLevel && !_typeIsLoaded(type);
     var typeRep = _emitFunctionType(type, definite: true);
     if (lazy) {
-      return js.call('dart.lazyFn(#, () => #)', [fn, typeRep]);
+      return _callHelper('lazyFn(#, () => #)', [fn, typeRep]);
     } else {
-      return js.call('dart.fn(#, #)', [fn, typeRep]);
+      return _callHelper('fn(#, #)', [fn, typeRep]);
     }
   }
 
   /// Emits an arrow FunctionExpression node.
   ///
   /// This should be used for all places in Dart's AST where FunctionExpression
   /// appears and the function is actually in an Expression context. These
   /// correspond to arrow functions in Dart.
   ///
   /// Contrast with [_emitFunction].
@@ skipping 131 matching lines @@
     _asyncStarController = savedController;
 
     DartType returnType = _getExpectedReturnType(element);
     JS.Expression gen = new JS.Fun(jsParams, jsBody,
         isGenerator: true, returnType: emitTypeRef(returnType));
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
 
     var T = _emitType(returnType);
-    return js.call('dart.#(#)', [
+    return _callHelper('#(#)', [
       kind,
       [gen, T]..addAll(visitFormalParameterList(parameters, destructure: false))
     ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
@@ skipping 19 matching lines @@
 
   /// Emits a simple identifier, including handling an inferred generic
   /// function instantiation.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var typeArgs = _getTypeArgs(node.staticElement, node.staticType);
     var simpleId = _emitSimpleIdentifier(node);
     if (typeArgs == null) {
       return simpleId;
     }
-    return js.call('dart.gbind(#, #)', [simpleId, typeArgs]);
+    return _callHelper('gbind(#, #)', [simpleId, typeArgs]);
   }
 
   /// Emits a simple identifier, handling implicit `this` as well as
   /// going through the qualified library name if necessary, but *not* handling
   /// inferred generic function instantiation.
   JS.Expression _emitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
       var typeName = _emitType(fillDynamicTypeArgs(element.type));
 
       // If the type is a type literal expression in Dart code, wrap the raw
       // runtime type in a "Type" instance.
       if (!_isInForeignJS && _isTypeLiteral(node)) {
-        typeName = js.call('dart.wrapType(#)', typeName);
+        typeName = _callHelper('wrapType(#)', typeName);
       }
 
       return typeName;
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _emitTopLevelName(element);
     }
 
@@ skipping 10 matching lines @@
       // library prefix. We don't need those because static calls can't use
       // the generic type.
       if (isStatic) {
         var dynType = _emitType(fillDynamicTypeArgs(type));
         return new JS.PropertyAccess(dynType, member);
       }
 
       // For instance members, we add implicit-this.
       // For method tear-offs, we ensure it's a bound method.
       var tearOff = element is MethodElement && !inInvocationContext(node);
-      var code = (tearOff) ? 'dart.bind(this, #)' : 'this.#';
-      return js.call(code, member);
+      if (tearOff) return _callHelper('bind(this, #)', member);
+      return js.call('this.#', member);
     }
 
     if (element is ParameterElement) {
       return _emitParameter(element);
     }
 
     // If this is one of our compiler's temporary variables, return its JS form.
     if (element is TemporaryVariableElement) {
       return element.jsVariable;
     }
@@ skipping 96 matching lines @@
       bool lowerTypedef: false,
       bool nameType: true,
       bool hoistType: true,
       definite: false}) {
     var parts = _emitFunctionTypeParts(type,
         parameters: parameters,
         lowerTypedef: lowerTypedef,
         nameType: nameType,
         hoistType: hoistType);
     var helper = (definite) ? 'definiteFunctionType' : 'functionType';
-    var fullType = js.call('dart.${helper}(#)', [parts]);
+    var fullType = _callHelper('${helper}(#)', [parts]);
     if (!nameType) return fullType;
     return _typeTable.nameType(type, fullType,
         hoistType: hoistType, definite: definite);
   }
 
   JS.Expression _emitAnnotatedFunctionType(
       FunctionType type, List<Annotation> metadata,
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
       bool nameType: true,
@@ skipping 75 matching lines @@
   /// if [hoistType] is true, then the named type will be hoisted.
   JS.Expression _emitType(DartType type,
       {bool lowerTypedef: false,
       bool lowerGeneric: false,
       bool nameType: true,
       bool hoistType: true,
       ClassElement subClass,
       JS.Expression className}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
-      return js.call('dart.void');
+      return _callHelper('void');
     } else if (type.isDynamic) {
-      return js.call('dart.dynamic');
+      return _callHelper('dynamic');
     } else if (type.isBottom) {
-      return js.call('dart.bottom');
+      return _callHelper('bottom');
     }
 
     _declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
@@ skipping 126 matching lines @@
     if (target is SuperExpression) {
       return _emitSetSuper(lhs, target, id, rhs);
     }
 
     if (target != null && isDynamicInvoke(target)) {
       if (_inWhitelistCode(lhs)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         var name = _emitMemberName(id.name);
         return new JS.MetaLet(vars, [
-          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #] = #)',
-              [l, l, name, name, _visit(rhs)])
+          js.call('(#[(#[#._extensionType]) ? #[#] : #] = #)', [
+            l,
+            l,
+            _runtimeModule,
+            name,
+            _extensionSymbolsModule,
+            name,
+            _visit(rhs)
+          ])
         ]);
       }
-      return js.call('dart.#(#, #, #)', [
+      return _callHelper('#(#, #, #)', [
         _emitDynamicOperationName('dput'),
         _visit(target),
         _emitMemberName(id.name),
         _visit(rhs)
       ]);
     }
 
     var accessor = id.staticElement;
     var element =
         accessor is PropertyAccessorElement ? accessor.variable : accessor;
@@ skipping 12 matching lines @@
       }
     }
 
     return _badAssignment('Unhandled assignment', lhs, rhs);
   }
 
   JS.Expression _badAssignment(String problem, Expression lhs, Expression rhs) {
     // TODO(sra): We should get here only for compiler bugs or weirdness due to
     // --unsafe-force-compile. Once those paths have been addressed, throw at
     // compile time.
-    return js.call('dart.throwUnimplementedError((#, #, #))',
+    return _callHelper('throwUnimplementedError((#, #, #))',
         [js.string('$lhs ='), _visit(rhs), js.string(problem)]);
   }
 
   /// Emits assignment to a simple identifier. Handles all legal simple
   /// identifier assignment targets (local, top level library member, implicit
   /// `this` or class, etc.)
   JS.Expression _emitSetSimpleIdentifier(
       SimpleIdentifier node, Expression rhs) {
     JS.Expression unimplemented() {
       return _badAssignment("Unimplemented: unknown name '$node'", node, rhs);
@@ skipping 229 matching lines @@
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     JS.Expression jsTarget = _visit(target);
     if (isDynamicInvoke(target) || isDynamicInvoke(node.methodName)) {
       if (_inWhitelistCode(target)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         jsTarget = new JS.MetaLet(vars, [
-          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #]).bind(#)',
-              [l, l, memberName, memberName, l])
+          js.call('(#[(#[#._extensionType]) ? #[#] : #]).bind(#)', [
+            l,
+            l,
+            _runtimeModule,
+            memberName,
+            _extensionSymbolsModule,
+            memberName,
+            l
+          ])
         ]);
         if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
         return new JS.Call(jsTarget, args);
       }
       if (typeArgs != null) {
-        return js.call('dart.#(#, #, #, #)', [
+        return _callHelper('#(#, #, #, #)', [
           _emitDynamicOperationName('dgsend'),
           jsTarget,
           new JS.ArrayInitializer(typeArgs),
           memberName,
           args
         ]);
       } else {
-        return js.call('dart.#(#, #, #)',
+        return _callHelper('#(#, #, #)',
             [_emitDynamicOperationName('dsend'), jsTarget, memberName, args]);
       }
     }
     if (_isObjectMemberCall(target, name)) {
       assert(typeArgs == null); // Object methods don't take type args.
-      return js.call('dart.#(#, #)', [name, jsTarget, args]);
+      return _callHelper('#(#, #)', [name, jsTarget, args]);
     }
 
     jsTarget = new JS.PropertyAccess(jsTarget, memberName);
     if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
 
     return new JS.Call(jsTarget, args);
   }
 
   JS.Expression _emitDynamicInvoke(
       InvocationExpression node, JS.Expression fn, List<JS.Expression> args) {
     var typeArgs = _emitInvokeTypeArguments(node);
     if (typeArgs != null) {
-      return js.call('dart.dgcall(#, #, #)',
-          [fn, new JS.ArrayInitializer(typeArgs), args]);
+      return _callHelper(
+          'dgcall(#, #, #)', [fn, new JS.ArrayInitializer(typeArgs), args]);
     } else {
       if (_inWhitelistCode(node, isCall: true)) {
         return new JS.Call(fn, args);
       }
-      return js.call('dart.dcall(#, #)', [fn, args]);
+      return _callHelper('dcall(#, #)', [fn, args]);
     }
   }
 
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node) {
     var fn = _visit(node.function);
     var args = _visit(node.argumentList) as List<JS.Expression>;
     if (isDynamicInvoke(node.function)) {
       return _emitDynamicInvoke(node, fn, args);
@@ skipping 222 matching lines @@
   JS.Statement visitExpressionStatement(ExpressionStatement node) =>
       _visit(node.expression).toStatement();
 
   @override
   JS.EmptyStatement visitEmptyStatement(EmptyStatement node) =>
       new JS.EmptyStatement();
 
   @override
   JS.Statement visitAssertStatement(AssertStatement node) =>
       // TODO(jmesserly): only emit in checked mode.
-      js.statement('dart.assert(#);', _visit(node.condition));
+      _callHelperStatement('assert(#);', _visit(node.condition));
 
   @override
   JS.Statement visitReturnStatement(ReturnStatement node) {
     var e = node.expression;
     if (e == null) return new JS.Return();
     return (_visit(e) as JS.Expression).toReturn();
   }
 
   @override
   JS.Statement visitYieldStatement(YieldStatement node) {
@@ skipping 189 matching lines @@
       }
     }
 
     JS.Expression objExpr;
     if (target is ClassElement) {
       objExpr = _emitTopLevelName(target);
     } else {
       objExpr = emitLibraryName(target);
     }
 
-    return js.statement('dart.defineLazy(#, { # });', [objExpr, methods]);
+    return _callHelperStatement('defineLazy(#, { # });', [objExpr, methods]);
   }
 
   PropertyAccessorElement _findAccessor(VariableElement element,
       {bool getter}) {
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       return getter
           ? parent.getGetter(element.name)
           : parent.getSetter(element.name);
     }
@@ skipping 96 matching lines @@
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
     var jsExpr = _visit(expr);
     if (!isNullable(expr)) return jsExpr;
-    return js.call('dart.notNull(#)', jsExpr);
+    return _callHelper('notNull(#)', jsExpr);
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
 
     // The operands of logical boolean operators are subject to boolean
     // conversion.
     if (op.type == TokenType.BAR_BAR ||
         op.type == TokenType.AMPERSAND_AMPERSAND) {
       return _visitTest(node);
     }
 
     var left = node.leftOperand;
     var right = node.rightOperand;
 
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
       if (_canUsePrimitiveEquality(left, right)) {
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else if (left is SuperExpression) {
         return _emitSend(left, op.lexeme, [right]);
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
-        code = '${bang}dart.equals(#, #)';
+        code = '${bang}#.equals(#, #)';
+        return js.call(code, [_runtimeModule, _visit(left), _visit(right)]);
       }
       return js.call(code, [_visit(left), _visit(right)]);
     }
 
     if (op.type.lexeme == '??') {
       // TODO(jmesserly): leave RHS for debugging?
       // This should be a hint or warning for dead code.
       if (!isNullable(left)) return _visit(left);
 
       var vars = <JS.MetaLetVariable, JS.Expression>{};
@@ skipping 292 matching lines @@
     // 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]);
   }
 
   JS.Expression _emitConst(JS.Expression expr()) =>
-      _cacheConst(() => js.call('dart.const(#)', expr()));
+      _cacheConst(() => _callHelper('const(#)', expr()));
 
   /// 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)`.
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
@@ skipping 241 matching lines @@
             _createTemporary('_', nodeTarget.staticType, nullable: false);
         var baseNode = _stripNullAwareOp(node, param);
         tail.add(
             new JS.ArrowFun(<JS.Parameter>[_visit(param)], _visit(baseNode)));
         node = nodeTarget;
       } else {
         break;
       }
     }
     if (tail.isEmpty) return _visit(node);
-    return js.call(
-        'dart.nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
+    return _callHelper(
+        'nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
   }
 
   static Token _getOperator(Expression node) {
     if (node is PropertyAccess) return node.operator;
     if (node is MethodInvocation) return node.operator;
     return null;
   }
 
   // TODO(jmesserly): this is dropping source location.
   Expression _stripNullAwareOp(Expression node, Expression newTarget) {
@@ skipping 76 matching lines @@
   JS.Expression _emitAccessInternal(Expression target, Element member,
       String memberName, List<JS.Expression> typeArgs) {
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberName,
         type: getStaticType(target), isStatic: isStatic);
     if (isDynamicInvoke(target)) {
       if (_inWhitelistCode(target)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         return new JS.MetaLet(vars, [
-          js.call('(#[dart._extensionType]) ? #[dartx[#]] : #.#',
-              [l, l, name, l, name])
+          js.call('(#[#._extensionType]) ? #[#[#]] : #.#',
+              [l, _runtimeModule, l, _extensionSymbolsModule, name, l, name])
         ]);
       }
-      return js.call('dart.#(#, #)',
+      return _callHelper('#(#, #)',
           [_emitDynamicOperationName('dload'), _visit(target), name]);
     }
 
     var jsTarget = _visit(target);
     bool isSuper = jsTarget is JS.Super;
 
     if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
       jsTarget = new JS.This();
     }
 
     JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       if (isSuper) {
-        result = js.call('dart.bind(this, #, #.#)', [name, jsTarget, name]);
+        result = _callHelper('bind(this, #, #.#)', [name, jsTarget, name]);
       } else if (_isObjectMemberCall(target, memberName)) {
-        result = js.call('dart.bind(#, #, dart.#)',
-            [jsTarget, _propertyName(memberName), memberName]);
+        result = _callHelper('bind(#, #, #.#)',
+            [jsTarget, _propertyName(memberName), _runtimeModule, memberName]);
       } else {
-        result = js.call('dart.bind(#, #)', [jsTarget, name]);
+        result = _callHelper('bind(#, #)', [jsTarget, name]);
       }
     } else if (_isObjectMemberCall(target, memberName)) {
-      result = js.call('dart.#(#)', [memberName, jsTarget]);
+      result = _callHelper('#(#)', [memberName, jsTarget]);
     } else {
       result = js.call('#.#', [jsTarget, name]);
     }
     if (typeArgs == null) {
       return result;
     }
-    return js.call('dart.gbind(#, #)', [result, typeArgs]);
+    return _callHelper('gbind(#, #)', [result, typeArgs]);
   }
 
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, type: type);
     if (isDynamicInvoke(target)) {
       if (_inWhitelistCode(target)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         return new JS.MetaLet(vars, [
-          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #]).call(#, #)',
-              [l, l, memberName, memberName, l, _visitList(args)])
+          js.call('(#[(#[#._extensionType]) ? #[#] : #]).call(#, #)', [
+            l,
+            l,
+            _runtimeModule,
+            memberName,
+            _extensionSymbolsModule,
+            memberName,
+            l,
+            _visitList(args)
+          ])
         ]);
       }
       // dynamic dispatch
       var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
       if (dynamicHelper != null) {
-        return js.call('dart.$dynamicHelper(#, #)',
+        return _callHelper('$dynamicHelper(#, #)',
             [_visit(target) as JS.Expression, _visitList(args)]);
       } else {
-        return js.call('dart.dsend(#, #, #)',
-            [_visit(target), memberName, _visitList(args)]);
+        return _callHelper(
+            'dsend(#, #, #)', [_visit(target), memberName, _visitList(args)]);
       }
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
@@ skipping 23 matching lines @@
       _visitTest(node.condition),
       _visit(node.thenExpression),
       _visit(node.elseExpression)
     ]);
   }
 
   @override
   visitThrowExpression(ThrowExpression node) {
     var expr = _visit(node.expression);
     if (node.parent is ExpressionStatement) {
-      return js.statement('dart.throw(#);', expr);
+      return _callHelperStatement('throw(#);', expr);
     } else {
-      return js.call('dart.throw(#)', expr);
+      return _callHelper('throw(#)', expr);
     }
   }
 
   @override
   visitRethrowExpression(RethrowExpression node) {
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', _visit(_catchParameter));
     } else {
       return js.call('throw #', _visit(_catchParameter));
     }
@@ skipping 182 matching lines @@
     var savedCatch = _catchParameter;
     if (node.catchKeyword != null) {
       var name = node.exceptionParameter;
       if (name != null && name != _catchParameter) {
         body.add(js
             .statement('let # = #;', [_visit(name), _visit(_catchParameter)]));
         _catchParameter = name;
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
-        body.add(js.statement(
-            'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
+        body.add(js.statement('let # = #.stackTrace(#);',
+            [stackVar, _runtimeModule, _visit(name)]));
       }
     }
 
     body.add(
         new JS.Block(_visitList(node.body.statements) as List<JS.Statement>));
     _catchParameter = savedCatch;
     return _statement(body);
   }
 
   @override
@@ skipping 61 matching lines @@
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       // TODO(jmesserly): analyzer will usually infer `List<Object>` because
       // that is the least upper bound of the element types. So we rarely
       // generate a plain `List<dynamic>` anymore.
       if (!elementType.isDynamic || isConst) {
         // dart.list helper internally depends on _interceptors.JSArray.
         _declareBeforeUse(_jsArray);
         if (isConst) {
           var typeRep = _emitType(elementType);
-          list = js.call('dart.constList(#, #)', [list, typeRep]);
+          list = _callHelper('constList(#, #)', [list, typeRep]);
         } else {
           // Call `new JSArray<E>.of(list)`
           var jsArrayType = _jsArray.type.instantiate(type.typeArguments);
           list = js.call('#.of(#)', [_emitType(jsArrayType), list]);
         }
       }
       return list;
     }
 
     if (isConst) return _cacheConst(emitList);
@@ skipping 25 matching lines @@
         for (var e in entries) {
           values.add(_visit(e.key));
           values.add(_visit(e.value));
         }
         mapArguments = new JS.ArrayInitializer(values);
       }
       var types = <JS.Expression>[];
       if (reifyTypeArgs) {
         types.addAll(typeArgs.map((e) => _emitType(e)));
       }
-      return js.call('dart.map(#, #)', [mapArguments, types]);
+      return _callHelper('map(#, #)', [mapArguments, types]);
     }
 
     if (node.constKeyword != null) return _emitConst(emitMap);
     return emitMap();
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
   @override
   JS.Expression visitAdjacentStrings(AdjacentStrings node) =>
       _visitListToBinary(node.strings, '+');
 
   @override
   JS.Expression visitStringInterpolation(StringInterpolation node) {
     return new JS.TaggedTemplate(
-        js.call('dart.str'), new JS.TemplateString(_visitList(node.elements)));
+        _callHelper('str'), new JS.TemplateString(_visitList(node.elements)));
   }
 
   @override
   String visitInterpolationString(InterpolationString node) {
     // TODO(jmesserly): this call adds quotes, and then we strip them off.
     var str = js.escapedString(node.value, '`').value;
     return str.substring(1, str.length - 1);
   }
 
   @override
   visitInterpolationExpression(InterpolationExpression node) =>
       _visit(node.expression);
 
   @override
   visitBooleanLiteral(BooleanLiteral node) => js.boolean(node.value);
 
   @override
   JS.Expression visitExpression(Expression node) =>
       _unimplementedCall('Unimplemented ${node.runtimeType}: $node');
 
   JS.Expression _unimplementedCall(String comment) {
-    return js.call('dart.throw(#)', [js.escapedString(comment)]);
+    return _callHelper('throw(#)', [js.escapedString(comment)]);
   }
 
   @override
   visitNode(AstNode node) {
     // TODO(jmesserly): verify this is unreachable.
     throw 'Unimplemented ${node.runtimeType}: $node';
   }
 
   _visit(AstNode node) {
     if (node == null) return null;
@@ skipping 36 matching lines @@
         return finish(js.call(code,
             [_visitTest(node.leftOperand), _visitTest(node.rightOperand)]));
       }
 
       var op = node.operator.type.lexeme;
       if (op == '&&') return shortCircuit('# && #');
       if (op == '||') return shortCircuit('# || #');
     }
     if (node is AsExpression && CoercionReifier.isImplicitCast(node)) {
       assert(node.staticType == types.boolType);
-      return js.call('dart.test(#)', _visit(node.expression));
+      return _callHelper('test(#)', _visit(node.expression));
     }
     JS.Expression result = _visit(node);
-    if (isNullable(node)) result = js.call('dart.test(#)', result);
+    if (isNullable(node)) result = _callHelper('test(#)', result);
     return result;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
   JS.Expression _declareMemberName(ExecutableElement e, {bool useExtension}) {
     String name;
     if (e is PropertyAccessorElement) {
@@ skipping 80 matching lines @@
       // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
       var baseType = type;
       while (baseType is TypeParameterType) {
         baseType = (baseType.element as TypeParameterElement).bound;
       }
       useExtension = baseType != null &&
           _extensionTypes.hasNativeSubtype(baseType) &&
           !isObjectMember(name);
     }
 
-    return useExtension ? js.call('dartx.#', result) : result;
+    return useExtension
+        ? js.call('#.#', [_extensionSymbolsModule, result])
+        : result;
   }
 
   JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
     return _privateNames
         .putIfAbsent(library, () => new HashMap())
         .putIfAbsent(name, () {
       var id = new JS.TemporaryId(name);
       _moduleItems.add(
           js.statement('const # = Symbol(#);', [id, js.string(id.name, "'")]));
       return id;
@@ skipping 82 matching lines @@
       return type;
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // TODO(leafp): The above only handles the case where the return type
       // is exactly Future/Stream/Iterable.  Handle the subtype case.
       return DynamicTypeImpl.instance;
     }
   }
 
+  JS.Expression _callHelper(String code, [args]) {
+    if (args is List) {
+      args.insert(0, _runtimeModule);
+    } else if (args != null) {
+      args = [_runtimeModule, args];
+    } else {
+      args = _runtimeModule;
+    }
+    return js.call('#.$code', args);
+  }
+
+  JS.Statement _callHelperStatement(String code, args) {
+    if (args is List) {
+      args.insert(0, _runtimeModule);
+    } else {
+      args = [_runtimeModule, args];
+    }
+    return js.statement('#.$code', args);
+  }
+
   /// Maps whitelisted files to a list of whitelisted methods
   /// within the file.
   ///
   /// If the value is null, the entire file is whitelisted.
   ///
   // TODO(jmesserly): why is this here, and what can we do to remove it?
   //
   // Hard coded lists are completely unnecessary -- if a feature is needed,
   // metadata, type system features, or command line options are the right way
   // to express it.
@@ skipping 94 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';