Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 634 matching lines @@
             generateSourceMap
                 ? (useNewSourceInfo
                      ? const PositionSourceInformationStrategy()
                      : const StartEndSourceInformationStrategy())
                 : const JavaScriptSourceInformationStrategy(),
         super(compiler) {
     emitter = new CodeEmitterTask(
         compiler, namer, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
-    lookupMapAnalysis = new LookupMapAnalysis(this);
+    lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.useCpsIr
          ? new CpsFunctionCompiler(
              compiler, this, sourceInformationStrategy)
          : new SsaFunctionCompiler(this, sourceInformationStrategy);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Resolution get resolution => compiler.resolution;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   FunctionElement resolveExternalFunction(FunctionElement element) {
     if (isForeign(element)) return element;
@@ skipping 219 matching lines @@
       assert(interceptorMember.enclosingClass == interceptorClass);
     });
   }
 
   void addInterceptorsForNativeClassMembers(
       ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               member,
               MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS);
           return;
         }
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == compiler.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
@@ skipping 164 matching lines @@
         // 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 = cls.patch != null ? cls.patch : cls;
           ConstructorElement ctor = implementation.lookupConstructor(name);
           if (ctor == null
               || (Name.isPrivateName(name)
                   && ctor.library != mapLiteralClass.library)) {
-            compiler.internalError(mapLiteralClass,
+            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 = cls.patch != null ? cls.patch : cls;
           Element element = implementation.lookupLocalMember(name);
           if (element == null || !element.isFunction || !element.isStatic) {
-            compiler.internalError(mapLiteralClass,
+            reporter.internalError(mapLiteralClass,
                 "Map literal class $mapLiteralClass missing "
                 "'$name' static member function");
           }
           return element;
         }
         mapLiteralConstructor = getFactory('_literal', 1);
         mapLiteralConstructorEmpty = getFactory('_empty', 0);
         enqueueInResolution(mapLiteralConstructor, registry);
         enqueueInResolution(mapLiteralConstructorEmpty, registry);
 
@@ skipping 256 matching lines @@
         Node argument = node.argumentsNode.nodes.head;
         ConstantExpression constant = resolver.getConstant(argument);
         if (constant != null && constant.kind == ConstantExpressionKind.TYPE) {
           TypeConstantExpression typeConstant = constant;
           if (typeConstant.type is InterfaceType) {
             resolver.registerInstantiatedType(typeConstant.type);
             return;
           }
         }
       }
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node,
           MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
   }
 
   void enableNoSuchMethod(Enqueuer world) {
     enqueue(world, getCreateInvocationMirror(), compiler.globalDependencies);
     world.registerInvocation(
         new UniverseSelector(Selectors.noSuchMethod_, null));
   }
@@ skipping 171 matching lines @@
     return jsAst.prettyPrint(generatedCode[element], compiler).getText();
   }
 
   int assembleProgram() {
     int programSize = emitter.assembleProgram();
     noSuchMethodRegistry.emitDiagnostic();
     int totalMethodCount = generatedCode.length;
     if (totalMethodCount != preMirrorsMethodCount) {
       int mirrorCount = totalMethodCount - preMirrorsMethodCount;
       double percentage = (mirrorCount / totalMethodCount) * 100;
-      DiagnosticMessage hint = compiler.createMessage(
+      DiagnosticMessage hint = reporter.createMessage(
           compiler.mainApp, MessageKind.MIRROR_BLOAT,
           {'count': mirrorCount,
            'total': totalMethodCount,
            'percentage': percentage.round()});
 
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       for (LibraryElement library in compiler.libraryLoader.libraries) {
         if (library.isInternalLibrary) continue;
         for (ImportElement import in library.imports) {
           LibraryElement importedLibrary = import.importedLibrary;
           if (importedLibrary != compiler.mirrorsLibrary) continue;
           MessageKind kind =
               compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(library)
               ? MessageKind.MIRROR_IMPORT
               : MessageKind.MIRROR_IMPORT_NO_USAGE;
-          compiler.withCurrentElement(library, () {
-            infos.add(compiler.createMessage(import, kind));
+          reporter.withCurrentElement(library, () {
+            infos.add(reporter.createMessage(import, kind));
           });
         }
       }
-      compiler.reportHint(hint, infos);
+      reporter.reportHint(hint, infos);
     }
     return programSize;
   }
 
   Element getDartClass(Element element) {
     for (ClassElement dartClass in implementationClasses.keys) {
       if (element == implementationClasses[dartClass]) {
         return dartClass;
       }
     }
@@ skipping 515 matching lines @@
       ClassElement result = findHelper(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
-      compiler.internalError(jsHelperLibrary,
+      reporter.internalError(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
   }
 
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     return super.onLibraryScanned(library, loader).then((_) {
       if (library.isPlatformLibrary &&
           // Don't patch library currently disallowed.
           !library.isSynthesized &&
@@ skipping 495 matching lines @@
 
     if (isTreeShakingDisabled) {
       enqueuer.enqueueReflectiveElements(recentClasses);
     } else if (!targetsUsed.isEmpty && enqueuer.isResolutionQueue) {
       // Add all static elements (not classes) that have been requested for
       // reflection. If there is no mirror-usage these are probably not
       // necessary, but the backend relies on them being resolved.
       enqueuer.enqueueReflectiveStaticFields(_findStaticFieldTargets());
     }
 
-    if (mustPreserveNames) compiler.log('Preserving names.');
+    if (mustPreserveNames) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
-      compiler.log('Retaining metadata.');
+      reporter.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
       if (!enqueuer.isResolutionQueue) {
         for (Dependency dependency in metadataConstants) {
           registerCompileTimeConstant(
               dependency.constant,
               new CodegenRegistry(compiler,
                   dependency.annotatedElement.analyzableElement.treeElements),
               addForEmission: false);
         }
@@ skipping 26 matching lines @@
     for (MetadataAnnotation metadata in element.implementation.metadata) {
       metadata.ensureResolved(resolution);
       ConstantValue constantValue =
           compiler.constants.getConstantValue(metadata.constant);
       if (!constantValue.isConstructedObject) continue;
       ObjectConstantValue value = constantValue;
       ClassElement cls = value.type.element;
       if (cls == forceInlineClass) {
         hasForceInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               element,
               MessageKind.GENERIC,
               {'text': "Must inline"});
         }
         inlineCache.markAsMustInline(element);
       } else if (cls == noInlineClass) {
         hasNoInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               element,
               MessageKind.GENERIC,
               {'text': "Cannot inline"});
         }
         inlineCache.markAsNonInlinable(element);
       } else if (cls == noThrowsClass) {
         hasNoThrows = true;
         if (!Elements.isStaticOrTopLevelFunction(element)) {
-          compiler.internalError(element,
+          reporter.internalError(element,
               "@NoThrows() is currently limited to top-level"
               " or static functions");
         }
         if (VERBOSE_OPTIMIZER_HINTS) {
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               element,
               MessageKind.GENERIC,
               {'text': "Cannot throw"});
         }
         compiler.world.registerCannotThrow(element);
       } else if (cls == noSideEffectsClass) {
         hasNoSideEffects = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               element,
               MessageKind.GENERIC,
               {'text': "Has no side effects"});
         }
         compiler.world.registerSideEffectsFree(element);
       }
     }
     if (hasForceInline && hasNoInline) {
-      compiler.internalError(element,
+      reporter.internalError(element,
           "@ForceInline() must not be used with @NoInline.");
     }
     if (hasNoThrows && !hasNoInline) {
-      compiler.internalError(element,
+      reporter.internalError(element,
           "@NoThrows() should always be combined with @NoInline.");
     }
     if (hasNoSideEffects && !hasNoInline) {
-      compiler.internalError(element,
+      reporter.internalError(element,
           "@NoSideEffects() should always be combined with @NoInline.");
     }
     if (element == invokeOnMethod) {
       compiler.enabledInvokeOn = true;
     }
   }
 
   CodeBuffer codeOf(Element element) {
     return generatedCode.containsKey(element)
         ? jsAst.prettyPrint(generatedCode[element], compiler)
@@ skipping 69 matching lines @@
 
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     registerCheckDeferredIsLoaded(registry);
     return true;
   }
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) {
     if (compiler.useCpsIr) {
-      compiler.reportHintMessage(
+      reporter.reportHintMessage(
           node,
           MessageKind.GENERIC,
           {'text': "Generation of code with compile time errors is currently "
                    "not supported with the CPS IR."});
       return false;
     }
     return true;
   }
 
   jsAst.Expression rewriteAsync(FunctionElement element,
                                 jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
     switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
         rewriter = new AsyncRewriter(
-            compiler,
-            compiler.currentElement,
+            reporter,
+            element,
             asyncHelper:
                 emitter.staticFunctionAccess(getAsyncHelper()),
             wrapBody:
                 emitter.staticFunctionAccess(getWrapBody()),
             newCompleter: emitter.staticFunctionAccess(
                 getSyncCompleterConstructor()),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       case AsyncMarker.SYNC_STAR:
         rewriter = new SyncStarRewriter(
-            compiler,
-            compiler.currentElement,
+            reporter,
+            element,
             endOfIteration: emitter.staticFunctionAccess(
                 getEndOfIteration()),
             newIterable: emitter.staticFunctionAccess(
                 getSyncStarIterableConstructor()),
             yieldStarExpression: emitter.staticFunctionAccess(
                 getYieldStar()),
             uncaughtErrorExpression: emitter.staticFunctionAccess(
                 getSyncStarUncaughtError()),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
          break;
       case AsyncMarker.ASYNC_STAR:
         rewriter = new AsyncStarRewriter(
-            compiler,
-            compiler.currentElement,
+            reporter,
+            element,
             asyncStarHelper: emitter.staticFunctionAccess(
                 getAsyncStarHelper()),
             streamOfController: emitter.staticFunctionAccess(
                 getStreamOfController()),
             wrapBody:
                 emitter.staticFunctionAccess(getWrapBody()),
             newController: emitter.staticFunctionAccess(
                 getASyncStarControllerConstructor()),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             yieldExpression: emitter.staticFunctionAccess(
@@ skipping 16 matching lines @@
       new Uri(scheme: 'package', path: 'expect/expect.dart');
 
   final Compiler compiler;
 
   ClassElement expectNoInlineClass;
   ClassElement expectTrustTypeAnnotationsClass;
   ClassElement expectAssumeDynamicClass;
 
   JavaScriptBackend get backend => compiler.backend;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Annotations(this.compiler);
 
   void onLibraryScanned(LibraryElement library) {
     if (library.canonicalUri == PACKAGE_EXPECT) {
       expectNoInlineClass = library.find('NoInline');
       expectTrustTypeAnnotationsClass = library.find('TrustTypeAnnotations');
       expectAssumeDynamicClass = library.find('AssumeDynamic');
       if (expectNoInlineClass == null ||
           expectTrustTypeAnnotationsClass == null ||
           expectAssumeDynamicClass == null) {
@@ skipping 21 matching lines @@
   }
 
   /// Returns `true` if inference of parameter types is disabled for [element].
   bool assumeDynamic(Element element) {
     return _hasAnnotation(element, expectAssumeDynamicClass);
   }
 
   /// Returns `true` if [element] is annotated with [annotationClass].
   bool _hasAnnotation(Element element, ClassElement annotationClass) {
     if (annotationClass == null) return false;
-    return compiler.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element, () {
       for (MetadataAnnotation metadata in element.metadata) {
         assert(invariant(metadata, metadata.constant != null,
             message: "Unevaluated metadata constant."));
         ConstantValue value =
             compiler.constants.getConstantValue(metadata.constant);
         if (value.isConstructedObject) {
           ConstructedConstantValue constructedConstant = value;
           if (constructedConstant.type.element == annotationClass) {
             return true;
           }
@@ skipping 266 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }