Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/resolution/class_hierarchy.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.resolution.class_hierarchy;
 
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart';
 import '../diagnostics/invariant.dart' show
@@ skipping 50 matching lines @@
     // Resolve the bounds of type variables.
     Iterator<DartType> types = element.typeVariables.iterator;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       types.moveNext();
       TypeVariableType typeVariable = types.current;
       String typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       registry.useType(typeNode, typeVariable);
       if (nameSet.contains(typeName)) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             typeNode,
             MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
             {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElementX variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
             this, typeNode.bound);
         variableElement.boundCache = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
           DartType bound = boundType;
           while (bound.isTypeVariable) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
               if (identical(element, variableElement)) {
                 // Only report an error on the checked type variable to avoid
                 // generating multiple errors for the same cyclicity.
-                compiler.reportWarningMessage(
+                reporter.reportWarningMessage(
                     typeNode.name,
                     MessageKind.CYCLIC_TYPE_VARIABLE,
                     {'typeVariableName': variableElement.name});
               }
               break;
             }
             seenTypeVariables = seenTypeVariables.prepend(element);
             bound = element.bound;
           }
         }
@@ skipping 22 matching lines @@
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   BaseClassElementX get element => enclosingElement;
 
   ClassResolverVisitor(Compiler compiler,
                        ClassElement classElement,
                        ResolutionRegistry registry)
     : super(compiler, classElement, registry);
 
   DartType visitClassNode(ClassNode node) {
     if (element == null) {
-      throw compiler.internalError(node, 'element is null');
+      throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
+      throw reporter.internalError(element,
           'cyclic resolution of class $element');
     }
 
     element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
@@ skipping 16 matching lines @@
     }
     // If the super type isn't specified, we provide a default.  The language
     // specifies [Object] but the backend can pick a specific 'implementation'
     // of Object - the JavaScript backend chooses between Object and
     // Interceptor.
     if (element.supertype == null) {
       ClassElement superElement = registry.defaultSuperclass(element);
       // Avoid making the superclass (usually Object) extend itself.
       if (element != superElement) {
         if (superElement == null) {
-          compiler.internalError(node,
+          reporter.internalError(node,
               "Cannot resolve default superclass for $element.");
         } else {
           superElement.ensureResolved(resolution);
         }
         element.supertype = superElement.computeType(resolution);
       }
     }
 
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
       assert(invariant(element, element.hasIncompleteHierarchy));
     }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember = element.superclass.localLookup('');
       if (superMember == null || !superMember.isGenerativeConstructor) {
         MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
         Map arguments = {'constructorName': ''};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
-        compiler.reportErrorMessage(node, kind, arguments);
+        reporter.reportErrorMessage(node, kind, arguments);
         superMember = new ErroneousElementX(
             kind, arguments, '', element);
         registry.registerThrowNoSuchMethod();
       } else {
         ConstructorElement superConstructor = superMember;
         superConstructor.computeType(resolution);
         if (!CallStructure.NO_ARGS.signatureApplies(
                 superConstructor.functionSignature)) {
           MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
-          compiler.reportErrorMessage(node, kind);
+          reporter.reportErrorMessage(node, kind);
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       if (superMember.isErroneous) {
         compiler.elementsWithCompileTimeErrors.add(constructor);
       }
-      element.setDefaultConstructor(constructor, compiler);
+      element.setDefaultConstructor(constructor, reporter);
     }
     return element.computeType(resolution);
   }
 
   @override
   DartType visitEnum(Enum node) {
     if (element == null) {
-      throw compiler.internalError(node, 'element is null');
+      throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
+      throw reporter.internalError(element,
           'cyclic resolution of class $element');
     }
 
     InterfaceType enumType = element.computeType(resolution);
     element.supertype = compiler.coreTypes.objectType;
     element.interfaces = const Link<DartType>();
     calculateAllSupertypes(element);
 
     if (node.names.nodes.isEmpty) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node,
           MessageKind.EMPTY_ENUM_DECLARATION,
           {'enumName': element.name});
     }
 
-    EnumCreator creator = new EnumCreator(compiler, element);
+    EnumCreator creator =
+        new EnumCreator(reporter, compiler.coreTypes, element);
     creator.createMembers();
     return enumType;
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           mixinNode,
           MessageKind.CANNOT_MIXIN,
           {'type': mixinType});
     } else if (mixinType.isTypeVariable) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           mixinNode,
           MessageKind.CLASS_NAME_EXPECTED);
     } else if (mixinType.isMalformed) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           mixinNode,
           MessageKind.CANNOT_MIXIN_MALFORMED,
           {'className': element.name, 'malformedType': mixinType});
     } else if (mixinType.isEnumType) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           mixinNode,
           MessageKind.CANNOT_MIXIN_ENUM,
           {'className': element.name, 'enumType': mixinType});
     }
     return mixinType;
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     if (element == null) {
-      throw compiler.internalError(node, 'element is null');
+      throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
+      throw reporter.internalError(element,
           'cyclic resolution of class $element');
     }
 
     if (identical(node.classKeyword.stringValue, 'typedef')) {
       // TODO(aprelev@gmail.com): Remove this deprecation diagnostic
       // together with corresponding TODO in parser.dart.
-      compiler.reportWarningMessage(
+      reporter.reportWarningMessage(
           node.classKeyword,
           MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX);
     }
 
     element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
@@ skipping 134 matching lines @@
                                 DartType mixinType) {
     ClassElement mixin = mixinType.element;
     mixin.ensureResolved(resolution);
 
     // Check for cycles in the mixin chain.
     ClassElement previous = mixinApplication;  // For better error messages.
     ClassElement current = mixin;
     while (current != null && current.isMixinApplication) {
       MixinApplicationElement currentMixinApplication = current;
       if (currentMixinApplication == mixinApplication) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             mixinApplication,
             MessageKind.ILLEGAL_MIXIN_CYCLE,
             {'mixinName1': current.name, 'mixinName2': previous.name});
         // We have found a cycle in the mixin chain. Return null as
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     registry.registerMixinUse(mixinApplication, mixin);
     return mixinType;
   }
 
   DartType resolveType(TypeAnnotation node) {
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (supertype.isMalformed) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND_MALFORMED,
             {'className': element.name, 'malformedType': supertype});
         return objectType;
       } else if (supertype.isEnumType) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND_ENUM,
             {'className': element.name, 'enumType': supertype});
         return objectType;
       } else if (!supertype.isInterfaceType) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             superclass.typeName,
             MessageKind.CLASS_NAME_EXPECTED);
         return objectType;
       } else if (isBlackListed(supertype)) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND,
             {'type': supertype});
         return objectType;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
         if (interfaceType.isMalformed) {
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               superclass,
               MessageKind.CANNOT_IMPLEMENT_MALFORMED,
               {'className': element.name, 'malformedType': interfaceType});
         } else if (interfaceType.isEnumType) {
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               superclass,
               MessageKind.CANNOT_IMPLEMENT_ENUM,
               {'className': element.name, 'enumType': interfaceType});
         } else if (!interfaceType.isInterfaceType) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 link.head,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
           }
           if (result.contains(interfaceType)) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 link.head,
                 MessageKind.DUPLICATE_IMPLEMENTS,
                 {'type': interfaceType});
           }
           result = result.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 link.head,
                 MessageKind.CANNOT_IMPLEMENT,
                 {'type': interfaceType});
           }
         }
       }
     }
     return result;
   }
 
@@ skipping 123 matching lines @@
     node.superclass.accept(this);
     visitNodeList(node.mixins);
     visitNodeList(node.interfaces);
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
-    Element element = lookupInScope(compiler, node, context, node.source);
+    Element element = lookupInScope(reporter, node, context, node.source);
     if (element != null && element.isClass) {
       loadSupertype(element, node);
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
-    Element element = lookupInScope(compiler, prefix, context, prefix.source);
+    Element element = lookupInScope(reporter, prefix, context, prefix.source);
     if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE,
           {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }