Dart2js option to dump info about compilation

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 13 matching lines @@
                                  Constant,
                                  Compiler,
                                  isPrivateName;
 
 import '../dart_types.dart';
 
 import '../scanner/scannerlib.dart' show Token, EOF_TOKEN;
 
 import '../ordered_typeset.dart' show OrderedTypeSet;
 
-class ElementX implements Element {
+import 'visitor.dart' show ElementVisitor;
+
+abstract class ElementX implements Element {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isErroneous() || getImplementationLibrary() != null);
@@ skipping 304 matching lines @@
 
   get redirectionTarget => this;
 
   getLibrary() => enclosingElement.getLibrary();
 
   computeTargetType(InterfaceType newType) => unsupported();
 
   String get message => '${messageKind.message(messageArguments)}';
 
   String toString() => '<$name: $message>';
+
+  accept(ElementVisitor visitor) => visitor.visitErroneousElementX(this);
 }
 
 /// A message attached to a [WarnOnUseElementX].
 class WrappedMessage {
   /// The message position. If [:null:] the position of the reference to the
   /// [WarnOnUseElementX] is used.
   final Spannable spannable;
 
   /**
    * The message to report on resolving a wrapped element.
@@ skipping 40 matching lines @@
       Spannable spannable = info.spannable;
       if (spannable == null) spannable = usageSpannable;
       listener.reportInfo(
           spannable, info.messageKind, info.messageArguments);
     }
     if (unwrapped.isWarnOnUse()) {
       unwrapped = unwrapped.unwrap(listener, usageSpannable);
     }
     return unwrapped;
   }
+
+  accept(ElementVisitor visitor) => visitor.visitWarnOnUseElementX(this);
 }
 
 /**
  * An ambiguous element represents multiple elements accessible by the same name.
  *
  * Ambiguous elements are created during handling of import/export scopes. If an
  * ambiguous element is encountered during resolution a warning/error should be
  * reported.
  */
 class AmbiguousElementX extends ElementX implements AmbiguousElement {
@@ skipping 47 matching lines @@
       listener.reportInfo(element, code, arguments);
       Link<Import> importers = importer.importers.getImports(element);
       listener.withCurrentElement(importer, () {
         for (; !importers.isEmpty; importers = importers.tail) {
           listener.reportInfo(
               importers.head, MessageKind.IMPORTED_HERE, arguments);
         }
       });
     }
   }
+
+  accept(ElementVisitor visitor) => visitor.visitAmbiguousElementX(this);
 }
 
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
@@ skipping 134 matching lines @@
       }
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   int compareTo(CompilationUnitElement other) {
     if (this == other) return 0;
     return '${script.uri}'.compareTo('${other.script.uri}');
   }
+
+  accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
 }
 
 class Importers {
   Map<Element, Link<Import>> importers = new Map<Element, Link<Import>>();
 
   Link<Import> getImports(Element element) {
     Link<Import> imports = importers[element];
     return imports != null ? imports : const Link<Import>();
   }
 
@@ skipping 337 matching lines @@
       return 'origin library(${getLibraryOrScriptName()})';
     } else {
       return 'library(${getLibraryOrScriptName()})';
     }
   }
 
   int compareTo(LibraryElement other) {
     if (this == other) return 0;
     return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
   }
+
+  accept(ElementVisitor visitor) => visitor.visitLibraryElementX(this);
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
   PrefixElementX(String prefix, Element enclosing, this.firstPosition)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
+
+  accept(ElementVisitor visitor) => visitor.visitPrefixElementX(this);
 }
 
 class TypedefElementX extends ElementX implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type of this typedef in which the type arguments are the type
    * variables.
    *
    * This resembles the [ClassElement.thisType] though a typedef has no notion
@@ skipping 63 matching lines @@
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Compiler compiler) {
     if (hasBeenCheckedForCycles) return;
     var visitor = new TypedefCyclicVisitor(compiler, this);
     computeType(compiler).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
+
+  accept(ElementVisitor visitor) => visitor.visitTypedefElementX(this);
 }
 
 class VariableElementX extends ElementX implements VariableElement {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElementX(String name,
                    VariableListElement variables,
                    ElementKind kind,
                    this.cachedNode)
     : this.variables = variables,
       super(name, kind, variables.enclosingElement);
 
+  VariableElementX.synthetic(String name,
+      ElementKind kind,
+      Element enclosing) :
+        variables = null,
+        super(name, kind, enclosing);
+
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     VariableDefinitions definitions = variables.parseNode(listener);
     for (Link<Node> link = definitions.definitions.nodes;
          !link.isEmpty; link = link.tail) {
       Expression initializedIdentifier = link.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier == null) {
         identifier = initializedIdentifier.asSendSet().selector.asIdentifier();
       }
       if (identical(name, identifier.source)) {
         cachedNode = initializedIdentifier;
         return cachedNode;
       }
     }
     listener.cancel('internal error: could not find $name', node: variables);
   }
 
   DartType computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
-  DartType get type => variables.type;
-
   bool isInstanceMember() => variables.isInstanceMember();
 
   // Note: cachedNode.getBeginToken() will not be correct in all
   // cases, for example, for function typed parameters.
   Token position() => findMyName(variables.position());
+
+  accept(ElementVisitor visitor) => visitor.visitVariableElementX(this);
 }
 
 /**
  * Parameters in constructors that directly initialize fields. For example:
  * [:A(this.field):].
  */
 class FieldParameterElementX extends VariableElementX
     implements FieldParameterElement {
   VariableElement fieldElement;
 
   FieldParameterElementX(String name,
                          this.fieldElement,
                          VariableListElement variables,
                          Node node)
       : super(name, variables, ElementKind.FIELD_PARAMETER, node);
 
   DartType computeType(Compiler compiler) {
     VariableDefinitions definitions = variables.parseNode(compiler);
     if (definitions.type == null) {
       return fieldElement.computeType(compiler);
     }
     return super.computeType(compiler);
   }
+
+  accept(ElementVisitor visitor) => visitor.visitFieldParameterElementX(this);
 }
 
 // This element represents a list of variable or field declaration.
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElementX extends ElementX implements VariableListElement {
   VariableDefinitions cachedNode;
   DartType type;
   final Modifiers modifiers;
@@ skipping 48 matching lines @@
     });
     assert(type != null);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
+
+  accept(ElementVisitor visitor) => visitor.visitVariableListElementX(this);
 }
 
 class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
   FunctionElement getter;
   FunctionElement setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   DartType computeType(Compiler compiler) {
@@ skipping 31 matching lines @@
     } else {
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
   }
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
+
+  accept(ElementVisitor visitor) => visitor.visitAbstractFieldElementX(this);
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 class FunctionSignatureX implements FunctionSignature {
   final Link<Element> requiredParameters;
   final Link<Element> optionalParameters;
   final DartType returnType;
   final int requiredParameterCount;
   final int optionalParameterCount;
@@ skipping 247 matching lines @@
     } else {
       return super.toString();
     }
   }
 
   bool get isAbstract {
     return !modifiers.isExternal() &&
            (isFunction() || isAccessor()) &&
            _hasNoBody;
   }
+
+  accept(ElementVisitor visitor) => visitor.visitFunctionElementX(this);
 }
 
 class ConstructorBodyElementX extends FunctionElementX
     implements ConstructorBodyElement {
   FunctionElement constructor;
 
   ConstructorBodyElementX(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement, false) {
     functionSignature = constructor.functionSignature;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) {
     compiler.internalErrorOnElement(this, '$this.computeType.');
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode != null);
     return cachedNode;
   }
 
   Token position() => constructor.position();
+
+  accept(ElementVisitor visitor) => visitor.visitConstructorBodyElementX(this);
 }
 
 /**
  * A constructor that is not defined in the source code but rather implied by
  * the language semantics.
  *
  * This class is used to represent default constructors and forwarding
  * constructors for mixin applications.
  */
 class SynthesizedConstructorElementX extends FunctionElementX {
@@ skipping 28 matching lines @@
     if (superMember.isErroneous()) {
       return functionSignature = compiler.objectClass.localLookup('')
           .computeSignature(compiler);
     }
     return functionSignature = superMember.computeSignature(compiler);
   }
 
   get declaration => this;
   get implementation => this;
   get defaultImplementation => this;
+
+  accept(ElementVisitor visitor) {
+    visitor.visitSynthesizedConstructorElementX(this);
+  }
 }
 
 class VoidElementX extends ElementX {
   VoidElementX(Element enclosing) : super('void', ElementKind.VOID, enclosing);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
+
+  accept(ElementVisitor visitor) => visitor.visitVoidElementX(this);
 }
 
 class TypeDeclarationElementX {
   /**
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
   static Link<DartType> createTypeVariables(TypeDeclarationElement element,
                                             NodeList parameters) {
@@ skipping 605 matching lines @@
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
   Link<DartType> computeTypeParameters(Compiler compiler) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) return const Link<DartType>();
     return TypeDeclarationElementX.createTypeVariables(
         this, named.typeParameters);
   }
+
+  accept(ElementVisitor visitor) => visitor.visitMixinApplicationElement(this);
 }
 
 class LabelElementX extends ElementX implements LabelElement {
 
   // We store the original label here so it can be returned by [parseNode].
   final Label label;
   final String labelName;
   final TargetElement target;
   bool isBreakTarget = false;
   bool isContinueTarget = false;
@@ skipping 16 matching lines @@
   void setContinueTarget() {
     isContinueTarget = true;
     target.isContinueTarget = true;
   }
 
   bool get isTarget => isBreakTarget || isContinueTarget;
   Node parseNode(DiagnosticListener l) => label;
 
   Token position() => label.getBeginToken();
   String toString() => "${labelName}:";
+
+  accept(ElementVisitor visitor) => visitor.visitLabelElementX(this);
 }
 
 // Represents a reference to a statement or switch-case, either by label or the
 // default target of a break or continue.
 class TargetElementX extends ElementX implements TargetElement {
   final Node statement;
   final int nestingLevel;
   Link<LabelElement> labels = const Link<LabelElement>();
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   TargetElementX(this.statement, this.nestingLevel, Element enclosingElement)
       : super("target", ElementKind.STATEMENT, enclosingElement);
   bool get isTarget => isBreakTarget || isContinueTarget;
 
   LabelElement addLabel(Label label, String labelName) {
     LabelElement result = new LabelElementX(label, labelName, this,
                                             enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 
   bool get isSwitch => statement is SwitchStatement;
 
   Token position() => statement.getBeginToken();
   String toString() => statement.toString();
+
+  accept(ElementVisitor visitor) => visitor.visitTargetElementX(this);
 }
 
 class TypeVariableElementX extends ElementX implements TypeVariableElement {
   final Node cachedNode;
   TypeVariableType type;
   DartType bound;
 
   TypeVariableElementX(name, Element enclosing, this.cachedNode,
                        [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name}";
 
   Token position() => cachedNode.getBeginToken();
+
+  accept(ElementVisitor visitor) => visitor.visitTypeVariableElementX(this);
 }
 
 /**
  * A single metadata annotation.
  *
  * For example, consider:
  *
  *     class Data {
  *       const Data();
  *     }
@@ skipping 31 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }