Refactor DartTypeVisitor and ElementVisitor.

pkg/compiler/lib/src/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 '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 308 matching lines @@
   computeEffectiveTargetType(InterfaceType newType) => unsupported();
 
   get definingConstructor => null;
 
   FunctionElement asFunctionElement() => this;
 
   String get message => '${messageKind.message(messageArguments)}';
 
   String toString() => '<$name: $message>';
 
-  accept(ElementVisitor visitor) => visitor.visitErroneousElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitErroneousElement(this, arg);
+  }
 }
 
 /// A constructor that was synthesized to recover from a compile-time error.
 class ErroneousConstructorElementX extends ErroneousElementX
     with PatchMixin<FunctionElement>, AnalyzableElementX
     implements ConstructorElementX {
   // TODO(ahe): Instead of subclassing [ErroneousElementX], this class should
   // be more like [ErroneousFieldElementX]. In particular, its kind should be
   // [ElementKind.GENERATIVE_CONSTRUCTOR], and it shouldn't throw as much.
 
@@ skipping 128 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.visitWarnOnUseElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitWarnOnUseElement(this, arg);
+  }
 }
 
 abstract class AmbiguousElementX extends ElementX implements AmbiguousElement {
   /**
    * The message to report on resolving this element.
    */
   final MessageKind messageKind;
 
   /**
    * The message arguments to report on resolving this element.
@@ skipping 21 matching lines @@
     var set = new Setlet();
     while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
   }
 
-  accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitAmbiguousElement(this, arg);
+  }
 
   bool get isTopLevel => false;
 
   DynamicType get type => const DynamicType();
 }
 
 /// Element synthesized to diagnose an ambiguous import.
 class AmbiguousImportX extends AmbiguousElementX {
   AmbiguousImportX(
       MessageKind messageKind,
@@ skipping 187 matching lines @@
 
   bool get hasMembers => !localMembers.isEmpty;
 
   int compareTo(CompilationUnitElement other) {
     if (this == other) return 0;
     return '${script.readableUri}'.compareTo('${other.script.readableUri}');
   }
 
   Element get analyzableElement => library;
 
-  accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitCompilationUnitElement(this, arg);
+  }
 }
 
 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 358 matching lines @@
     } else {
       return 'library(${canonicalUri})';
     }
   }
 
   int compareTo(LibraryElement other) {
     if (this == other) return 0;
     return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
   }
 
-  accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitLibraryElement(this, arg);
+  }
 
   // TODO(johnniwinther): Remove these when issue 18630 is fixed.
   LibraryElementX get patch => super.patch;
   LibraryElementX get origin => super.origin;
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
@@ skipping 12 matching lines @@
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => const DynamicType();
 
   Token get position => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
-  accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitPrefixElement(this, arg);
+  }
 
   void markAsDeferred(Import deferredImport) {
     _deferredImport = deferredImport;
   }
 }
 
 class TypedefElementX extends ElementX
     with AstElementMixin,
          AnalyzableElementX,
          TypeDeclarationElementX<TypedefType>
@@ skipping 53 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.visitTypedefElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitTypedefElement(this, arg);
+  }
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
 
 // This class holds common information for a list of variable or field
 // declarations. It contains the node, and the type. A [VariableElementX]
 // forwards its [computeType] and [parseNode] methods to this class.
 class VariableList implements DeclarationSite {
   VariableDefinitions definitions;
@@ skipping 116 matching lines @@
         message: "Type has not been computed for $this."));
     return variables.type;
   }
 
   bool get isInstanceMember => isClassMember && !isStatic;
 
   // Note: cachedNode.beginToken will not be correct in all
   // cases, for example, for function typed parameters.
   Token get position => token;
 
-  accept(ElementVisitor visitor) => visitor.visitVariableElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitVariableElement(this, arg);
+  }
 
   DeclarationSite get declarationSite => variables;
 }
 
 class LocalVariableElementX extends VariableElementX
     implements LocalVariableElement {
   LocalVariableElementX(String name,
                         ExecutableElement enclosingElement,
                         VariableList variables,
                         Token token)
@@ skipping 11 matching lines @@
 class FieldElementX extends VariableElementX
     with AnalyzableElementX implements FieldElement {
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FieldElementX(Identifier name,
                 Element enclosingElement,
                 VariableList variables)
     : super(name.source, ElementKind.FIELD, enclosingElement,
             variables, name.token);
 
-  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFieldElement(this, arg);
+  }
 
   MemberElement get memberContext => this;
 
   void reuseElement() {
     super.reuseElement();
     nestedClosures.clear();
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     return new FieldElementX(
@@ skipping 50 matching lines @@
 
   get nestedClosures {
     throw new UnsupportedError("nestedClosures");
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
   // TODO(ahe): Should this throw or do nothing?
-  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFieldElement(this, arg);
+  }
 
   // TODO(ahe): Should return the context of the error site?
   MemberElement get memberContext => this;
 
   // TODO(ahe): Should return the definingElement of the error site?
   AstElement get definingElement => this;
 
   void reuseElement() {
     throw new UnsupportedError("reuseElement");
   }
@@ skipping 52 matching lines @@
             message: "Parameter signature has not been set for $this."));
     return functionSignatureCache;
   }
 
   bool get hasNode => true;
 
   VariableDefinitions get node => definitions;
 
   FunctionType get functionType => type;
 
-  accept(ElementVisitor visitor) => visitor.visitFormalElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFormalElement(this, arg);
+  }
 
   // A parameter is defined by the declaration element.
   AstElement get definingElement => declaration;
 }
 
 /// [Element] for a formal parameter.
 ///
 /// A [ParameterElementX] can be patched. A parameter of an external method is
 /// patched with the corresponding parameter of the patch method. This is done
 /// to ensure that default values on parameters are computed once (on the
@@ skipping 12 matching lines @@
                     {this.isOptional: false,
                      this.isNamed: false})
       : super(elementKind, functionDeclaration, definitions, identifier);
 
   FunctionElement get functionDeclaration => enclosingElement;
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
-  accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitParameterElement(this, arg);
+  }
 
   bool get isLocal => true;
 }
 
 class LocalParameterElementX extends ParameterElementX
     implements LocalParameterElement {
 
 
   LocalParameterElementX(FunctionElement functionDeclaration,
                          VariableDefinitions definitions,
@@ skipping 16 matching lines @@
                              VariableDefinitions variables,
                              Identifier identifier,
                              Expression initializer,
                              this.fieldElement,
                              {bool isOptional: false,
                               bool isNamed: false})
       : super(ElementKind.INITIALIZING_FORMAL, constructorDeclaration,
               variables, identifier, initializer,
               isOptional: isOptional, isNamed: isNamed);
 
-  accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFieldParameterElement(this, arg);
+  }
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 }
 
 class ErroneousInitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElementX {
   final ErroneousFieldElementX fieldElement;
 
@@ skipping 60 matching lines @@
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
   }
 
   bool get isInstanceMember {
     return isClassMember && !isStatic;
   }
 
-  accept(ElementVisitor visitor) => visitor.visitAbstractFieldElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitAbstractFieldElement(this, arg);
+  }
 
   bool get isAbstract {
     return getter != null && getter.isAbstract
         || setter != null && setter.isAbstract;
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 // TODO(karlklose): all these lists should have element type [FormalElement].
@@ skipping 167 matching lines @@
       return super.toString();
     }
   }
 
   bool get isAbstract {
     return !modifiers.isExternal &&
            (isFunction || isAccessor) &&
            _hasNoBody;
   }
 
-  accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFunctionElement(this, arg);
+  }
 
   // A function is defined by the implementation element.
   AstElement get definingElement => implementation;
 }
 
 abstract class FunctionElementX extends BaseFunctionElementX
     with AnalyzableElementX implements MethodElement {
   FunctionElementX(String name,
                    ElementKind kind,
                    Modifiers modifiers,
@@ skipping 154 matching lines @@
     compiler.internalError(this, '$this.computeType.');
     return null;
   }
 
   Token get position => constructor.position;
 
   Element get outermostEnclosingMemberOrTopLevel => constructor;
 
   Element get analyzableElement => constructor.analyzableElement;
 
-  accept(ElementVisitor visitor) => visitor.visitConstructorBodyElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitConstructorBodyElement(this, arg);
+  }
 
   MemberElement get memberContext => constructor;
 }
 
 /**
  * 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.
@@ skipping 33 matching lines @@
     if (definingConstructor.isErroneous) {
       return functionSignatureCache =
           compiler.objectClass.localLookup('').computeSignature(compiler);
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     return functionSignatureCache =
         definingConstructor.computeSignature(compiler);
   }
 
-  accept(ElementVisitor visitor) {
-    return visitor.visitFunctionElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitFunctionElement(this, arg);
   }
 }
 
 abstract class TypeDeclarationElementX<T extends GenericType>
     implements TypeDeclarationElement {
   /**
    * The `this type` for this type declaration.
    *
    * The type of [:this:] is the generic type based on this element in which
    * the type arguments are the declared type variables. For instance,
@@ skipping 583 matching lines @@
   @override
   Token get position => node.name.token;
 
   @override
   bool get isEnumClass => true;
 
   @override
   Node parseNode(Compiler compiler) => node;
 
   @override
-  accept(ElementVisitor visitor) => visitor.visitEnumClassElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitEnumClassElement(this, arg);
+  }
 
   List<DartType> computeTypeParameters(Compiler compiler) => const <DartType>[];
 
   List<FieldElement> get enumValues {
     assert(invariant(this, _enumValues != null,
         message: "enumValues has not been computed for $this."));
     return _enumValues;
   }
 
   void set enumValues(List<FieldElement> values) {
@@ skipping 139 matching lines @@
   List<DartType> computeTypeParameters(Compiler compiler) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) {
       throw new SpannableAssertionFailure(node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
     }
     return createTypeVariables(named.typeParameters);
   }
 
-  accept(ElementVisitor visitor) => visitor.visitMixinApplicationElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitMixinApplicationElement(this, arg);
+  }
 }
 
 class LabelDefinitionX implements LabelDefinition {
   final Label label;
   final String labelName;
   final JumpTarget target;
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   LabelDefinitionX(Label label, String labelName, this.target)
@@ skipping 68 matching lines @@
         message: "Bound has not been set on $this."));
     return boundCache;
   }
 
   bool get hasNode => true;
 
   Node parseNode(compiler) => node;
 
   Token get position => node.getBeginToken();
 
-  accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitTypeVariableElement(this, arg);
+  }
 
   // A type variable cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
 
 /**
  * A single metadata annotation.
  *
  * For example, consider:
  *
@@ skipping 110 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }