Introduce "CommonElements"

pkg/compiler/lib/src/compiler.dart

 // Copyright (c) 2012, 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.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
 import 'closure.dart' as closureMapping show ClosureTask;
 import 'common/backend_api.dart' show Backend;
 import 'common/codegen.dart' show CodegenWorkItem;
 import 'common/names.dart' show Selectors;
 import 'common/names.dart' show Identifiers, Uris;
 import 'common/registry.dart' show EagerRegistry, Registry;
 import 'common/resolution.dart'
     show
         ParsingContext,
         Resolution,
         ResolutionWorkItem,
         ResolutionImpact,
         Target;
 import 'common/tasks.dart' show CompilerTask, GenericTask, Measurer;
 import 'common/work.dart' show ItemCompilationContext, WorkItem;
 import 'common.dart';
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
-import 'core_types.dart' show CoreClasses, CoreTypes;
+import 'core_types.dart' show CoreClasses, CommonElements, CoreTypes;
 import 'dart_types.dart' show DartType, DynamicType, InterfaceType, Types;
 import 'deferred_load.dart' show DeferredLoadTask;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
 import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
 import 'diagnostics/messages.dart' show Message, MessageTemplate;
 import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show ErroneousElementX;
 import 'enqueue.dart'
@@ skipping 98 matching lines @@
 
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   ResolvedUriTranslator get resolvedUriTranslator;
 
   Tracer tracer;
 
-  LibraryElement coreLibrary;
-  LibraryElement asyncLibrary;
-
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
-  /// Initialized when dart:mirrors is loaded.
-  LibraryElement mirrorsLibrary;
-
-  /// Initialized when dart:typed_data is loaded.
-  LibraryElement typedDataLibrary;
-
   DiagnosticReporter get reporter => _reporter;
+  CommonElements get commonElements => _coreTypes;
   CoreClasses get coreClasses => _coreTypes;
   CoreTypes get coreTypes => _coreTypes;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
-  ClassElement typedDataClass;
-
-  // TODO(johnniwinther): Move this to the JavaScriptBackend.
-  /// The class for patch annotation defined in dart:_js_helper.
-  ClassElement patchAnnotationClass;
-
-  // TODO(johnniwinther): Move this to the JavaScriptBackend.
-  ClassElement nativeAnnotationClass;
-
-  ConstructorElement _symbolConstructor;
-  ConstructorElement get symbolConstructor {
-    if (_symbolConstructor == null) {
-      ClassElement symbolClass = coreClasses.symbolClass;
-      symbolClass.ensureResolved(resolution);
-      _symbolConstructor = symbolClass.lookupConstructor('');
-      assert(invariant(symbolClass, _symbolConstructor != null,
-          message: "Default constructor not found ${symbolClass}."));
-    }
-    return _symbolConstructor;
-  }
-
-  // Initialized when dart:mirrors is loaded.
-  ClassElement mirrorSystemClass;
-
-  // Initialized when dart:mirrors is loaded.
-  ClassElement mirrorsUsedClass;
-
-  // Initialized after mirrorSystemClass has been resolved.
-  FunctionElement mirrorSystemGetNameFunction;
-
-  // Initialized when mirrorsUsedClass has been resolved.
-  FunctionElement mirrorsUsedConstructor;
-
-  // Initialized when dart:mirrors is loaded.
-  ClassElement deferredLibraryClass;
-
-  Element identicalFunction;
-  Element loadLibraryFunction;
-  Element functionApplyMethod;
-
   // TODO(zarah): Remove this map and incorporate compile-time errors
   // in the model.
   /// Tracks elements with compile-time errors.
   final Map<Element, List<DiagnosticMessage>> elementsWithCompileTimeErrors =
       new Map<Element, List<DiagnosticMessage>>();
 
   final Environment environment;
   // TODO(sigmund): delete once we migrate the rest of the compiler to use
   // `environment` directly.
   @deprecated
@@ skipping 62 matching lines @@
             : outputProvider {
     world = new World(this);
     if (makeReporter != null) {
       _reporter = makeReporter(this, options);
     } else {
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
     _resolution = new _CompilerResolution(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
-    _coreTypes = new _CompilerCoreTypes(_resolution);
+    _coreTypes = new _CompilerCoreTypes(_resolution, reporter);
     types = new Types(_resolution);
     tracer = new Tracer(this, this.outputProvider);
 
     if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies = new GlobalDependencyRegistry(this);
@@ skipping 15 matching lines @@
     }
 
     tasks = [
       dietParser =
           new DietParserTask(options, idGenerator, backend, reporter, measurer),
       scanner = createScannerTask(),
       serialization = new SerializationTask(this),
       libraryLoader = new LibraryLoaderTask(
           resolvedUriTranslator,
           options.compileOnly
-              ? new _NoScriptLoader(this) : new _ScriptLoader(this),
+              ? new _NoScriptLoader(this)
+              : new _ScriptLoader(this),
           new _ElementScanner(scanner),
           serialization,
           this,
           environment,
           reporter,
           measurer),
       parser = new ParserTask(this, options),
       patchParser = new PatchParserTask(this, options),
       resolver = createResolverTask(),
       closureToClassMapper = new closureMapping.ClosureTask(this),
@@ skipping 64 matching lines @@
         });
       });
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   ///
   /// Use this callback method to store references to specific libraries.
   /// Note that [library] has not been scanned yet, nor has its imports/exports
   /// been resolved.
   void onLibraryCreated(LibraryElement library) {
-    Uri uri = library.canonicalUri;
-    if (uri == Uris.dart_core) {
-      coreLibrary = library;
-    } else if (uri == Uris.dart__native_typed_data) {
-      typedDataLibrary = library;
-    } else if (uri == Uris.dart_mirrors) {
-      mirrorsLibrary = library;
-    }
+    _coreTypes.onLibraryCreated(library);
     backend.onLibraryCreated(library);
   }
 
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   ///
   /// Use this callback method to store references to specific member declared
   /// in certain libraries. Note that [library] has not been patched yet, nor
   /// has its imports/exports been resolved.
   ///
   /// Use [loader] to register the creation and scanning of a patch library
   /// for [library].
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
-    Uri uri = library.canonicalUri;
-    // If the script of the library is synthesized, the library does not exist
-    // and we do not try to load the helpers.
-    //
-    // This could for example happen if dart:async is disabled, then loading it
-    // should not try to find the given element.
-    if (!library.isSynthesized) {
-      if (uri == Uris.dart_core) {
-        initializeCoreClasses();
-        identicalFunction = coreLibrary.find('identical');
-      } else if (uri == Uris.dart_mirrors) {
-        mirrorSystemClass = findRequiredElement(library, 'MirrorSystem');
-        mirrorsUsedClass = findRequiredElement(library, 'MirrorsUsed');
-      } else if (uri == Uris.dart_async) {
-        asyncLibrary = library;
-        deferredLibraryClass = findRequiredElement(library, 'DeferredLibrary');
-        _coreTypes.futureClass = findRequiredElement(library, 'Future');
-        _coreTypes.streamClass = findRequiredElement(library, 'Stream');
-      } else if (uri == Uris.dart__native_typed_data) {
-        typedDataClass = findRequiredElement(library, 'NativeTypedData');
-      } else if (uri == js_backend.BackendHelpers.DART_JS_HELPER) {
-        patchAnnotationClass = findRequiredElement(library, '_Patch');
-        nativeAnnotationClass = findRequiredElement(library, 'Native');
-      }
-    }
     return backend.onLibraryScanned(library, loader);
   }
 
   /// Compute the set of distinct import chains to the library at [uri] within
   /// [loadedLibraries].
   ///
   /// The chains are strings of the form
   ///
   ///       <main-uri> => <intermediate-uri1> => <intermediate-uri2> => <uri>
   ///
@@ skipping 86 matching lines @@
         });
       } else if (importsMirrorsLibrary && !options.enableExperimentalMirrors) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
         reporter.reportWarningMessage(
             NO_LOCATION_SPANNABLE, MessageKind.IMPORT_EXPERIMENTAL_MIRRORS, {
           'importChain': importChains
               .join(MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)
         });
       }
-
-      coreClasses.functionClass.ensureResolved(resolution);
-      functionApplyMethod =
-          coreClasses.functionClass.lookupLocalMember('apply');
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
-  Element findRequiredElement(LibraryElement library, String name) {
-    var element = library.find(name);
-    if (element == null) {
-      reporter.internalError(
-          library,
-          "The library '${library.canonicalUri}' does not contain required "
-          "element: '$name'.");
-    }
-    return element;
-  }
-
   // TODO(johnniwinther): Move this to [PatchParser] when it is moved to the
   // [JavaScriptBackend]. Currently needed for testing.
   String get patchVersion => backend.patchVersion;
 
-  // TODO(johnniwinther): Remove this. All elements should be looked up on
-  // demand.
-  void onClassResolved(ClassElement cls) {
-    if (mirrorSystemClass == cls) {
-      mirrorSystemGetNameFunction = cls.lookupLocalMember('getName');
-    } else if (mirrorsUsedClass == cls) {
-      mirrorsUsedConstructor = cls.constructors.head;
-    }
-  }
-
-  void initializeCoreClasses() {
-    final List missingCoreClasses = [];
-    ClassElement lookupCoreClass(String name) {
-      ClassElement result = coreLibrary.find(name);
-      if (result == null) {
-        missingCoreClasses.add(name);
-      }
-      return result;
-    }
-
-    _coreTypes.objectClass = lookupCoreClass('Object');
-    _coreTypes.boolClass = lookupCoreClass('bool');
-    _coreTypes.numClass = lookupCoreClass('num');
-    _coreTypes.intClass = lookupCoreClass('int');
-    _coreTypes.doubleClass = lookupCoreClass('double');
-    _coreTypes.resourceClass = lookupCoreClass('Resource');
-    _coreTypes.stringClass = lookupCoreClass('String');
-    _coreTypes.functionClass = lookupCoreClass('Function');
-    _coreTypes.listClass = lookupCoreClass('List');
-    _coreTypes.typeClass = lookupCoreClass('Type');
-    _coreTypes.mapClass = lookupCoreClass('Map');
-    _coreTypes.nullClass = lookupCoreClass('Null');
-    _coreTypes.stackTraceClass = lookupCoreClass('StackTrace');
-    _coreTypes.iterableClass = lookupCoreClass('Iterable');
-    _coreTypes.symbolClass = lookupCoreClass('Symbol');
-    if (!missingCoreClasses.isEmpty) {
-      reporter.internalError(
-          coreLibrary,
-          'dart:core library does not contain required classes: '
-          '$missingCoreClasses');
-    }
-  }
-
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     return _unnamedListConstructor =
         coreClasses.listClass.lookupDefaultConstructor();
   }
 
   Element _filledListConstructor;
   Element get filledListConstructor {
     if (_filledListConstructor != null) return _filledListConstructor;
@@ skipping 656 matching lines @@
     return userOutputProvider.createEventSink(name, extension);
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }
 
-class _CompilerCoreTypes implements CoreTypes, CoreClasses {
+class _CompilerCoreTypes implements CoreTypes, CoreClasses, CommonElements {
   final Resolution resolution;
+  final DiagnosticReporter reporter;
 
-  ClassElement objectClass;
-  ClassElement boolClass;
-  ClassElement numClass;
-  ClassElement intClass;
-  ClassElement doubleClass;
-  ClassElement stringClass;
-  ClassElement functionClass;
-  ClassElement nullClass;
-  ClassElement listClass;
-  ClassElement typeClass;
-  ClassElement mapClass;
-  ClassElement symbolClass;
-  ClassElement stackTraceClass;
-  ClassElement futureClass;
-  ClassElement iterableClass;
-  ClassElement streamClass;
-  ClassElement resourceClass;
+  LibraryElement coreLibrary;
+  LibraryElement asyncLibrary;
+  LibraryElement mirrorsLibrary;
+  LibraryElement typedDataLibrary;
 
-  _CompilerCoreTypes(this.resolution);
+  // TODO(sigmund): possibly move this to target-specific collection of
+  // elements, or refactor the library so that the helpers we need are in a
+  // target-agnostic place.  Currently we are using @patch and @Native from
+  // here. We hope we can make those independent of the backend and generic
+  // enough so the patching algorithm can work without being configured for a
+  // specific backend.
+  LibraryElement jsHelperLibrary;
+
+  _CompilerCoreTypes(this.resolution, this.reporter);
+
+  // From dart:core
+
+  ClassElement _objectClass;
+  ClassElement get objectClass =>
+      _objectClass ??= _findRequired(coreLibrary, 'Object');
+
+  ClassElement _boolClass;
+  ClassElement get boolClass =>
+      _boolClass ??= _findRequired(coreLibrary, 'bool');
+
+  ClassElement _numClass;
+  ClassElement get numClass => _numClass ??= _findRequired(coreLibrary, 'num');
+
+  ClassElement _intClass;
+  ClassElement get intClass => _intClass ??= _findRequired(coreLibrary, 'int');
+
+  ClassElement _doubleClass;
+  ClassElement get doubleClass =>
+      _doubleClass ??= _findRequired(coreLibrary, 'double');
+
+  ClassElement _stringClass;
+  ClassElement get stringClass =>
+      _stringClass ??= _findRequired(coreLibrary, 'String');
+
+  ClassElement _functionClass;
+  ClassElement get functionClass =>
+      _functionClass ??= _findRequired(coreLibrary, 'Function');
+
+  Element _functionApplyMethod;
+  Element get functionApplyMethod {
+    if (_functionApplyMethod == null) {
+      functionClass.ensureResolved(resolution);
+      _functionApplyMethod = functionClass.lookupLocalMember('apply');
+      assert(invariant(functionClass, _functionApplyMethod != null,
+          message: "Member `apply` not found in ${functionClass}."));
+    }
+    return _functionApplyMethod;
+  }
+
+  bool isFunctionApplyMethod(Element element) =>
+    element.name == 'apply' && element.enclosingClass == functionClass;
+
+  ClassElement _nullClass;
+  ClassElement get nullClass =>
+      _nullClass ??= _findRequired(coreLibrary, 'Null');
+
+  ClassElement _listClass;
+  ClassElement get listClass =>
+      _listClass ??= _findRequired(coreLibrary, 'List');
+
+  ClassElement _typeClass;
+  ClassElement get typeClass =>
+      _typeClass ??= _findRequired(coreLibrary, 'Type');
+
+  ClassElement _mapClass;
+  ClassElement get mapClass => _mapClass ??= _findRequired(coreLibrary, 'Map');
+
+  ClassElement _symbolClass;
+  ClassElement get symbolClass =>
+      _symbolClass ??= _findRequired(coreLibrary, 'Symbol');
+
+  ConstructorElement _symbolConstructor;
+  ConstructorElement get symbolConstructor {
+    if (_symbolConstructor == null) {
+      symbolClass.ensureResolved(resolution);
+      _symbolConstructor = symbolClass.lookupConstructor('');
+      assert(invariant(symbolClass, _symbolConstructor != null,
+          message: "Default constructor not found ${symbolClass}."));
+    }
+    return _symbolConstructor;
+  }
+
+  bool isSymbolConstructor(Element e) =>
+      e.enclosingClass == symbolClass && e == symbolConstructor;
+
+  ClassElement _stackTraceClass;
+  ClassElement get stackTraceClass =>
+      _stackTraceClass ??= _findRequired(coreLibrary, 'StackTrace');
+
+  ClassElement _iterableClass;
+  ClassElement get iterableClass =>
+      _iterableClass ??= _findRequired(coreLibrary, 'Iterable');
+
+  ClassElement _resourceClass;
+  ClassElement get resourceClass =>
+      _resourceClass ??= _findRequired(coreLibrary, 'Resource');
+
+  Element _identicalFunction;
+  Element get identicalFunction =>
+      _identicalFunction ??= coreLibrary.find('identical');
+
+  // From dart:async
+
+  ClassElement _futureClass;
+  ClassElement get futureClass =>
+      _futureClass ??= _findRequired(asyncLibrary, 'Future');
+
+  ClassElement _streamClass;
+  ClassElement get streamClass =>
+      _streamClass ??= _findRequired(asyncLibrary, 'Stream');
+
+  ClassElement _deferredLibraryClass;
+  ClassElement get deferredLibraryClass =>
+      _deferredLibraryClass ??= _findRequired(asyncLibrary, "DeferredLibrary");
+
+  // From dart:mirrors
+
+  ClassElement _mirrorSystemClass;
+  ClassElement get mirrorSystemClass =>
+      _mirrorSystemClass ??= _findRequired(mirrorsLibrary, 'MirrorSystem');
+
+  FunctionElement _mirrorSystemGetNameFunction;
+  bool isMirrorSystemGetNameFunction(Element element) {
+    if (_mirrorSystemGetNameFunction == null) {
+      if (!element.isFunction || mirrorsLibrary == null) return false;
+      ClassElement cls = mirrorSystemClass;
+      if (element.enclosingClass != cls) return false;
+      if (cls != null) {
+        cls.ensureResolved(resolution);
+        _mirrorSystemGetNameFunction = cls.lookupLocalMember('getName');
+      }
+    }
+    return element == _mirrorSystemGetNameFunction;
+  }
+
+  ClassElement _mirrorsUsedClass;
+  ClassElement get mirrorsUsedClass =>
+      _mirrorsUsedClass ??= _findRequired(mirrorsLibrary, 'MirrorsUsed');
+
+  bool isMirrorsUsedConstructor(ConstructorElement element) =>
+      mirrorsLibrary != null && mirrorsUsedClass == element.enclosingClass;
+
+  ConstructorElement _mirrorsUsedConstructor;
+  @override
+  ConstructorElement get mirrorsUsedConstructor {
+    if (_mirrorsUsedConstructor == null) {
+      ClassElement cls = mirrorsUsedClass;
+      if (cls != null) {
+        cls.ensureResolved(resolution);
+        _mirrorsUsedConstructor = cls.constructors.head;
+      }
+    }
+    return _mirrorsUsedConstructor;
+  }
+
+  // From dart:typed_data
+
+  ClassElement _typedDataClass;
+  ClassElement get typedDataClass =>
+      _typedDataClass ??= _findRequired(typedDataLibrary, 'NativeTypedData');
+
+  // From dart:_js_helper
+  // TODO(sigmund,johnniwinther): refactor needed: either these move to a
+  // backend-specific collection of helpers, or the helper code moves to a
+  // backend agnostic library (see commend above on [jsHelperLibrary].
+
+  ClassElement _patchAnnotationClass;
+  ClassElement get patchAnnotationClass =>
+      _patchAnnotationClass ??= _findRequired(jsHelperLibrary, '_Patch');
+
+  ClassElement _nativeAnnotationClass;
+  ClassElement get nativeAnnotationClass =>
+      _nativeAnnotationClass ??= _findRequired(jsHelperLibrary, 'Native');
 
   @override
   InterfaceType get objectType {
     objectClass.ensureResolved(resolution);
     return objectClass.rawType;
   }
 
   @override
   InterfaceType get boolType {
     boolClass.ensureResolved(resolution);
@@ skipping 106 matching lines @@
 
   @override
   InterfaceType streamType([DartType elementType]) {
     streamClass.ensureResolved(resolution);
     InterfaceType type = streamClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
+
+  void onLibraryCreated(LibraryElement library) {
+    Uri uri = library.canonicalUri;
+    if (uri == Uris.dart_core) {
+      coreLibrary = library;
+    } else if (uri == Uris.dart_async) {
+      asyncLibrary = library;
+    } else if (uri == Uris.dart__native_typed_data) {
+      typedDataLibrary = library;
+    } else if (uri == Uris.dart_mirrors) {
+      mirrorsLibrary = library;
+    } else if (uri == js_backend.BackendHelpers.DART_JS_HELPER) {
+      jsHelperLibrary = library;
+    }
+  }
+
+  Element _findRequired(LibraryElement library, String name) {
+    // If the script of the library is synthesized, the library does not exist
+    // and we do not try to load the helpers.
+    //
+    // This could for example happen if dart:async is disabled, then loading it
+    // should not try to find the given element.
+    if (library == null || library.isSynthesized) return null;
+
+    var element = library.find(name);
+    if (element == null) {
+      reporter.internalError(
+          library,
+          "The library '${library.canonicalUri}' does not contain required "
+          "element: '$name'.");
+    }
+    return element;
+  }
 }
 
 class CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
   Element _currentElement;
   bool hasCrashed = false;
 
   /// `true` if the last diagnostic was filtered, in which case the
@@ skipping 426 matching lines @@
   @override
   ParsingContext get parsingContext => compiler.parsingContext;
 
   @override
   CoreClasses get coreClasses => compiler.coreClasses;
 
   @override
   CoreTypes get coreTypes => compiler.coreTypes;
 
   @override
+  CommonElements get commonElements => compiler.commonElements;
+
+  @override
   Types get types => compiler.types;
 
   @override
   Target get target => compiler.backend;
 
   @override
   ResolverTask get resolver => compiler.resolver;
 
   @override
   ResolutionEnqueuer get enqueuer => compiler.enqueuer.resolution;
 
   @override
   CompilerOptions get options => compiler.options;
 
   @override
   IdGenerator get idGenerator => compiler.idGenerator;
 
   @override
   ConstantEnvironment get constants => compiler.constants;
 
   @override
   MirrorUsageAnalyzerTask get mirrorUsageAnalyzerTask =>
       compiler.mirrorUsageAnalyzerTask;
 
   @override
-  LibraryElement get coreLibrary => compiler.coreLibrary;
+  LibraryElement get coreLibrary => compiler._coreTypes.coreLibrary;
 
   @override
-  FunctionElement get identicalFunction => compiler.identicalFunction;
-
-  @override
-  ClassElement get mirrorSystemClass => compiler.mirrorSystemClass;
-
-  @override
-  FunctionElement get mirrorSystemGetNameFunction =>
-      compiler.mirrorSystemGetNameFunction;
-
-  @override
-  ConstructorElement get mirrorsUsedConstructor =>
-      compiler.mirrorsUsedConstructor;
-
-  @override
-  ConstructorElement get symbolConstructor => compiler.symbolConstructor;
-
-  @override
-  ConstantValue proxyConstant;
+  bool get wasProxyConstantComputedTestingOnly => _proxyConstant != null;
 
   @override
   void registerClass(ClassElement cls) {
     compiler.world.registerClass(cls);
   }
 
   @override
   void resolveClass(ClassElement cls) {
     compiler.resolver.resolveClass(cls);
   }
@@ skipping 20 matching lines @@
 
   @override
   void ensureResolved(Element element) {
     if (compiler.serialization.isDeserialized(element)) {
       return;
     }
     computeWorldImpact(element);
   }
 
   @override
-  void onClassResolved(ClassElement element) =>
-      compiler.onClassResolved(element);
-
-  @override
   void registerCompileTimeError(Element element, DiagnosticMessage message) =>
       compiler.registerCompileTimeError(element, message);
 
   @override
   bool hasResolvedAst(ExecutableElement element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (compiler.serialization.isDeserialized(element)) {
       return compiler.serialization.hasResolvedAst(element);
     }
@@ skipping 128 matching lines @@
       return new ResolutionWorkItem(element, compilationContext);
     }
   }
 
   @override
   void forgetElement(Element element) {
     _worldImpactCache.remove(element);
     _resolutionImpactCache.remove(element);
   }
 
+  ConstantValue _proxyConstant;
+
   @override
   bool isProxyConstant(ConstantValue value) {
     FieldElement field = coreLibrary.find('proxy');
     if (field == null) return false;
     if (!hasBeenResolved(field)) return false;
-    if (proxyConstant == null) {
-      proxyConstant = constants
+    if (_proxyConstant == null) {
+      _proxyConstant = constants
           .getConstantValue(resolver.constantCompiler.compileConstant(field));
     }
-    return proxyConstant == value;
+    return _proxyConstant == value;
   }
 }
 
 class GlobalDependencyRegistry extends EagerRegistry {
   final Compiler compiler;
   Setlet<Element> _otherDependencies;
 
   GlobalDependencyRegistry(this.compiler) : super('GlobalDependencies', null);
 
   // TODO(johnniwinther): Rename world/universe/enqueuer through out the
@@ skipping 22 matching lines @@
       compiler.readScript(uri, spannable);
 }
 
 /// [ScriptLoader] used to ensure that scripts are not loaded accidentally
 /// through the [LibraryLoader] when `CompilerOptions.compileOnly` is `true`.
 class _NoScriptLoader implements ScriptLoader {
   Compiler compiler;
   _NoScriptLoader(this.compiler);
 
   Future<Script> readScript(Uri uri, [Spannable spannable]) {
-    compiler.reporter.internalError(spannable,
-        "Script loading of '$uri' is not enabled.");
+    compiler.reporter
+        .internalError(spannable, "Script loading of '$uri' is not enabled.");
   }
 }
 
 class _ElementScanner implements ElementScanner {
   ScannerTask scanner;
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }