Fix ElementVisitor

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 341 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);
+  accept(ElementVisitor visitor) => visitor.visitErroneousElement(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 41 matching lines @@
       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);
+  accept(ElementVisitor visitor) => visitor.visitWarnOnUseElement(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 48 matching lines @@
       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);
+  accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(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 494 matching lines @@
     } else {
       return 'library(${getLibraryOrScriptName()})';
     }
   }
 
   int compareTo(LibraryElement other) {
     if (this == other) return 0;
     return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
   }
 
-  accept(ElementVisitor visitor) => visitor.visitLibraryElementX(this);
+  accept(ElementVisitor visitor) => visitor.visitLibraryElement(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);
+  accept(ElementVisitor visitor) => visitor.visitPrefixElement(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 64 matching lines @@
     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);
+  accept(ElementVisitor visitor) => visitor.visitTypedefElement(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,
@@ skipping 29 matching lines @@
   DartType computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
   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);
+  accept(ElementVisitor visitor) => visitor.visitVariableElement(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);
+  accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(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 49 matching lines @@
     assert(type != null);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
-  accept(ElementVisitor visitor) => visitor.visitVariableListElementX(this);
+  accept(ElementVisitor visitor) => visitor.visitVariableListElement(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 32 matching lines @@
       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);
+  accept(ElementVisitor visitor) => visitor.visitAbstractFieldElement(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 248 matching lines @@
       return super.toString();
     }
   }
 
   bool get isAbstract {
     return !modifiers.isExternal() &&
            (isFunction() || isAccessor()) &&
            _hasNoBody;
   }
 
-  accept(ElementVisitor visitor) => visitor.visitFunctionElementX(this);
+  accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 }
 
 class ConstructorBodyElementX extends FunctionElementX
     implements ConstructorBodyElement {
   FunctionElement constructor;
 
   ConstructorBodyElementX(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
@@ skipping 10 matching lines @@
 
   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);
+  accept(ElementVisitor visitor) => visitor.visitConstructorBodyElement(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 30 matching lines @@
           .computeSignature(compiler);
     }
     return functionSignature = superMember.computeSignature(compiler);
   }
 
   get declaration => this;
   get implementation => this;
   get defaultImplementation => this;
 
   accept(ElementVisitor visitor) {
-    visitor.visitSynthesizedConstructorElementX(this);
+    return visitor.visitFunctionElement(this);
   }
 }
 
-class VoidElementX extends ElementX {
+class VoidElementX extends ElementX implements VoidElement {
   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);
+  accept(ElementVisitor visitor) => visitor.visitVoidElement(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 644 matching lines @@
     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);
+  accept(ElementVisitor visitor) => visitor.visitLabelElement(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);
+  accept(ElementVisitor visitor) => visitor.visitTargetElement(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);
+  accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(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)';
 }