Decouple WorkItem from Compiler

pkg/compiler/lib/src/js_backend/backend_helpers.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 dart2js.js_backend.helpers;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Uris;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../core_types.dart' show CoreClasses;
 import '../elements/elements.dart'
     show
         AbstractFieldElement,
         ClassElement,
         ConstructorElement,
         Element,
         EnumClassElement,
         FieldElement,
         FunctionElement,
         LibraryElement,
         MemberElement,
         MethodElement,
+        Name,
         PublicName;
 import '../library_loader.dart' show LoadedLibraries;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import 'js_backend.dart';
 
 /// Helper classes and functions for the JavaScript backend.
 class BackendHelpers {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
@@ skipping 79 matching lines @@
   MethodElement jsArrayAdd;
   MethodElement jsStringSplit;
   Element jsStringToString;
   Element jsStringOperatorAdd;
   Element objectEquals;
 
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
   ClassElement typeVariableClass;
-  ConstructorElement mapLiteralConstructor;
-  ConstructorElement mapLiteralConstructorEmpty;
-  Element mapLiteralUntypedMaker;
-  Element mapLiteralUntypedEmptyMaker;
 
   ClassElement noSideEffectsClass;
   ClassElement noThrowsClass;
   ClassElement noInlineClass;
   ClassElement forceInlineClass;
   ClassElement irRepresentationClass;
 
   ClassElement jsAnnotationClass;
   ClassElement jsAnonymousClass;
 
@@ skipping 252 matching lines @@
     jsArrayAdd = compiler.lookupElementIn(jsArrayClass, 'add');
 
     jsStringClass.ensureResolved(resolution);
     jsStringSplit = compiler.lookupElementIn(jsStringClass, 'split');
     jsStringOperatorAdd = compiler.lookupElementIn(jsStringClass, '+');
     jsStringToString = compiler.lookupElementIn(jsStringClass, 'toString');
 
     objectEquals = compiler.lookupElementIn(coreClasses.objectClass, '==');
   }
 
+  ConstructorElement _mapLiteralConstructor;
+  ConstructorElement _mapLiteralConstructorEmpty;
+  Element _mapLiteralUntypedMaker;
+  Element _mapLiteralUntypedEmptyMaker;
+
+  ConstructorElement get mapLiteralConstructor {
+    _ensureMapLiteralHelpers();
+    return _mapLiteralConstructor;
+  }
+
+  ConstructorElement get mapLiteralConstructorEmpty {
+    _ensureMapLiteralHelpers();
+    return _mapLiteralConstructorEmpty;
+  }
+
+  Element get mapLiteralUntypedMaker {
+    _ensureMapLiteralHelpers();
+    return _mapLiteralUntypedMaker;
+  }
+
+  Element get mapLiteralUntypedEmptyMaker {
+    _ensureMapLiteralHelpers();
+    return _mapLiteralUntypedEmptyMaker;
+  }
+
+  void _ensureMapLiteralHelpers() {
+    if (_mapLiteralConstructor != null) return;
+
+    // For map literals, the dependency between the implementation class
+    // and [Map] is not visible, so we have to add it manually.
+    Element getFactory(String name, int arity) {
+      // The constructor is on the patch class, but dart2js unit tests don't
+      // have a patch class.
+      ClassElement implementation = mapLiteralClass.implementation;
+      ConstructorElement ctor = implementation.lookupConstructor(name);
+      if (ctor == null ||
+          (Name.isPrivateName(name) &&
+              ctor.library != mapLiteralClass.library)) {
+        reporter.internalError(
+            mapLiteralClass,
+            "Map literal class ${mapLiteralClass} missing "
+            "'$name' constructor"
+            "  ${mapLiteralClass.constructors}");
+      }
+      return ctor;
+    }
+
+    Element getMember(String name) {
+      // The constructor is on the patch class, but dart2js unit tests don't
+      // have a patch class.
+      ClassElement implementation = mapLiteralClass.implementation;
+      Element element = implementation.lookupLocalMember(name);
+      if (element == null || !element.isFunction || !element.isStatic) {
+        reporter.internalError(
+            mapLiteralClass,
+            "Map literal class ${mapLiteralClass} missing "
+            "'$name' static member function");
+      }
+      return element;
+    }
+
+    _mapLiteralConstructor = getFactory('_literal', 1);
+    _mapLiteralConstructorEmpty = getFactory('_empty', 0);
+    _mapLiteralUntypedMaker = getMember('_makeLiteral');
+    _mapLiteralUntypedEmptyMaker = getMember('_makeEmpty');
+  }
+
   Element get badMain {
     return findHelper('badMain');
   }
 
   Element get missingMain {
     return findHelper('missingMain');
   }
 
   Element get mainHasTooManyParameters {
     return findHelper('mainHasTooManyParameters');
   }
 
   MethodElement get loadLibraryWrapper {
     return findHelper("_loadLibraryWrapper");
   }
 
   Element get boolConversionCheck {
     return findHelper('boolConversionCheck');
   }
 
-  Element get consoleTraceHelper {
+  MethodElement _traceHelper;
+
+  MethodElement get traceHelper {
+    return _traceHelper ??= JavaScriptBackend.TRACE_METHOD == 'console'
+        ? _consoleTraceHelper
+        : _postTraceHelper;
+  }
+
+  MethodElement get _consoleTraceHelper {
     return findHelper('consoleTraceHelper');
   }
 
-  Element get postTraceHelper {
+  MethodElement get _postTraceHelper {
     return findHelper('postTraceHelper');
   }
 
   FunctionElement get closureFromTearOff {
     return findHelper('closureFromTearOff');
   }
 
   Element get isJsIndexable {
     return findHelper('isJsIndexable');
   }
@@ skipping 289 matching lines @@
   MethodElement _objectNoSuchMethod;
 
   MethodElement get objectNoSuchMethod {
     if (_objectNoSuchMethod == null) {
       _objectNoSuchMethod =
           coreClasses.objectClass.lookupLocalMember(Identifiers.noSuchMethod_);
     }
     return _objectNoSuchMethod;
   }
 }