Patch cleanup.

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 72 matching lines @@
   static const ElementKind GETTER =
     const ElementKind('getter', ElementCategory.NONE);
   static const ElementKind SETTER =
     const ElementKind('setter', ElementCategory.NONE);
   static const ElementKind TYPE_VARIABLE =
     const ElementKind('type_variable', ElementCategory.TYPE_VARIABLE);
   static const ElementKind ABSTRACT_FIELD =
     const ElementKind('abstract_field', ElementCategory.VARIABLE);
   static const ElementKind LIBRARY =
     const ElementKind('library', ElementCategory.NONE);
-  static const ElementKind COMPILATION_UNIT_OVERRIDE =
-    const ElementKind('compilation_unit_override', ElementCategory.NONE);
   static const ElementKind PREFIX =
     const ElementKind('prefix', ElementCategory.PREFIX);
   static const ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static const ElementKind STATEMENT =
     const ElementKind('statement', ElementCategory.NONE);
   static const ElementKind LABEL =
     const ElementKind('label', ElementCategory.NONE);
   static const ElementKind VOID =
@@ skipping 26 matching lines @@
     assert(annotation.annotatedElement === null);
     annotation.annotatedElement = this;
     metadata = metadata.prepend(annotation);
   }
 
   bool isFunction() => kind === ElementKind.FUNCTION;
   bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
   bool isClosure() => false;
   bool isMember() {
     // Check that this element is defined in the scope of a Class.
-    Element enclosing = enclosingElement;
-    if (enclosing !== null &&
-        enclosing.kind === ElementKind.COMPILATION_UNIT_OVERRIDE) {
-      enclosing = enclosing.enclosingElement;
-    }
-    return enclosing !== null && enclosing.isClass();
+    return enclosingElement !== null && enclosingElement.isClass();
   }
   bool isInstanceMember() => false;
   bool isFactoryConstructor() => modifiers.isFactory();
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isGenerativeConstructorBody() =>
       kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY;
   bool isCompilationUnit() => kind === ElementKind.COMPILATION_UNIT;
   bool isClass() => kind === ElementKind.CLASS;
   bool isPrefix() => kind === ElementKind.PREFIX;
   bool isVariable() => kind === ElementKind.VARIABLE;
@@ skipping 86 matching lines @@
   }
 
   // TODO(kasperl): This is a very bad hash code for the element and
   // there's no reason why two elements with the same name should have
   // the same hash code. Replace this with a simple id in the element?
   int hashCode() => name === null ? 0 : name.hashCode();
 
   CompilationUnitElement getCompilationUnit() {
     Element element = this;
     while (element !== null && !element.isCompilationUnit()) {
-      if (element is CompilationUnitOverrideElement) {
-        CompilationUnitOverrideElement override = element;
-        return override.compilationUnit;
-      }
       if (element.isLibrary()) {
         LibraryElement library = element;
         return library.entryCompilationUnit;
       }
       element = element.enclosingElement;
     }
     return element;
   }
 
   LibraryElement getLibrary() => enclosingElement.getLibrary();
@@ skipping 67 matching lines @@
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
 
   FunctionElement asFunctionElement() => null;
 
   static bool isInvalid(Element e) => e == null || e.isErroneous();
-  Element cloneTo(Element enclosing, DiagnosticListener listener) {
-    listener.cancel("Unimplemented cloneTo", element: this);
-  }
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [null] to provide additional
  * information about the error that caused the element to be unresolvable
  * or otherwise invalid.
  *
  * Accessing any field or calling any method defined on [ErroneousElement]
@@ skipping 164 matching lines @@
     super.addMember(element, listener);
     // Provide the member to the library to build scope.
     if (enclosingElement.isPatch) {
       getImplementationLibrary().addMember(element, listener);
     } else {
       getLibrary().addMember(element, listener);
     }
   }
 }
 
-class CompilationUnitOverrideElement extends Element {
-  final CompilationUnitElement compilationUnit;
-
-  CompilationUnitOverrideElement(CompilationUnitElement compilationUnit,
-                                 Element enclosing)
-      : this.compilationUnit = compilationUnit,
-        super(compilationUnit.name,
-              ElementKind.COMPILATION_UNIT_OVERRIDE,
-              enclosing);
-}
-
 class LibraryElement extends ScopeContainerElement {
   final Uri uri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const EmptyLink<CompilationUnitElement>();
   Link<LibraryTag> tags = const EmptyLink<LibraryTag>();
   LibraryTag libraryTag;
   bool canUseNative = false;
 
   /**
@@ skipping 163 matching lines @@
 
   PrefixElement(SourceString prefix, Element enclosing, this.firstPosition)
       : imported = new Map<SourceString, Element>(),
         super(prefix, ElementKind.PREFIX, enclosing);
 
   lookupLocalMember(SourceString memberName) => imported[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
-
-  PrefixElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    return new PrefixElement(name, enclosing, firstPosition);
-  }
 }
 
 class TypedefElement extends Element implements TypeDeclarationElement {
   Typedef cachedNode;
   TypedefType cachedType;
   DartType alias;
 
   bool isResolved = false;
   bool isBeingResolved = false;
 
@@ skipping 20 matching lines @@
     return cachedType;
   }
 
   Link<DartType> get typeVariables => cachedType.typeArguments;
 
   // TODO(johnniwinther): Rewrite to avoid the optional argument.
   Scope buildScope({bool patchScope: false}) {
     return new TypeDeclarationScope(
       enclosingElement.buildScope(patchScope: patchScope), this);
   }
-
-  TypedefElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    TypedefElement result = new TypedefElement(name, enclosing);
-    return result;
-  }
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
@@ skipping 24 matching lines @@
     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());
-
-  VariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    VariableListElement clonedVariables =
-        variables.cloneTo(enclosing, listener);
-    VariableElement result = new VariableElement(
-        name, clonedVariables, kind, enclosing, cachedNode);
-    return result;
-  }
 }
 
 /**
  * Parameters in constructors that directly initialize fields. For example:
  * [:A(this.field):].
  */
 class FieldParameterElement extends VariableElement {
   VariableElement fieldElement;
 
   FieldParameterElement(SourceString name,
                         this.fieldElement,
                         VariableListElement variables,
                         Element enclosing,
                         Node node)
       : super(name, variables, ElementKind.FIELD_PARAMETER, enclosing, node);
-
-  FieldParameterElement cloneTo(Element enclosing,
-                                DiagnosticListener listener) {
-    FieldParameterElement result =
-      new FieldParameterElement(name, fieldElement,
-                                variables.cloneTo(enclosing, listener),
-                                enclosing, cachedNode);
-    return result;
-  }
 }
 
 // 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 VariableListElement extends Element {
   VariableDefinitions cachedNode;
   DartType type;
   final Modifiers modifiers;
@@ skipping 45 matching lines @@
           type = compiler.types.dynamicType;
         }
       }
     });
     assert(type != null);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 
-  VariableListElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    VariableListElement result;
-    if (cachedNode !== null) {
-      result = new VariableListElement.node(cachedNode, kind, enclosing);
-    } else {
-      result = new VariableListElement(kind, modifiers, enclosing);
-    }
-    return result;
-  }
-
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
   // TODO(johnniwinther): Rewrite to avoid the optional argument.
   Scope buildScope({bool patchScope: false}) {
     Scope result = new VariableScope(
         enclosingElement.buildScope(patchScope: patchScope), this);
     if (enclosingElement.isClass()) {
       Scope clsScope = result.parent;
       clsScope.inStaticContext = !isInstanceMember();
     }
     return result;
   }
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name, ContainerElement enclosingElement)
     : super(name, ElementKind.FOREIGN, enclosingElement);
 
   DartType computeType(Compiler compiler) {
     return compiler.types.dynamicType;
   }
 
   parseNode(DiagnosticListener listener) {
     throw "internal error: ForeignElement has no node";
   }
-
-  ForeignElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    ForeignElement result = new ForeignElement(name, enclosing);
-    return result;
-  }
 }
 
 class AbstractFieldElement extends Element {
   FunctionElement getter;
   FunctionElement setter;
 
   AbstractFieldElement(SourceString name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   DartType computeType(Compiler compiler) {
@@ skipping 27 matching lines @@
     if (getter !== null) {
       return new Modifiers.withFlags(
           getter.modifiers.nodes,
           getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     } else {
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
   }
-
-  AbstractFieldElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    listener.cancel("Cannot clone synthetic AbstractFieldElement",
-                    element: this);
-  }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 class FunctionSignature {
   final Link<Element> requiredParameters;
   final Link<Element> optionalParameters;
   final DartType returnType;
   final int requiredParameterCount;
   final int optionalParameterCount;
@@ skipping 206 matching lines @@
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode !== null);
     return cachedNode;
   }
 
   Token position() => constructor.position();
-
-  ConstructorBodyElement cloneTo(Element enclosing,
-                                 DiagnosticListener listener) {
-    ConstructorBodyElement result =
-      new ConstructorBodyElement(constructor.cloneTo(enclosing, listener));
-    return result;
-  }
 }
 
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
     : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
             Modifiers.EMPTY, enclosing);
 
   Token position() => enclosingElement.position();
-
-  SynthesizedConstructorElement cloneTo(Element enclosing,
-                                        DiagnosticListener listener) {
-    return new SynthesizedConstructorElement(enclosing);
-  }
 }
 
 class VoidElement extends Element {
   VoidElement(Element enclosing)
       : super(const SourceString('void'), ElementKind.VOID, enclosing);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
@@ skipping 381 matching lines @@
   }
 
   Scope buildLocalScope() {
     if (origin !== null) {
       return new LocalPatchClassScope(origin, this);
     } else {
       return new LocalClassScope(this);
     }
   }
 
-  ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    listener.internalErrorOnElement(this, 'unsupported operation');
-  }
-
   Link<DartType> get allSupertypesAndSelf {
     return allSupertypes.prepend(new InterfaceType(this));
   }
 
   String toString() {
     if (origin !== null) {
       return 'patch ${super.toString()}';
     } else if (patch !== null) {
       return 'origin ${super.toString()}';
     } else {
@@ skipping 240 matching lines @@
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   Token position() => cachedNode.getBeginToken();
-
-  TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    TypeVariableElement result =
-        new TypeVariableElement(name, enclosing, cachedNode, type, bound);
-    return result;
-  }
 }
 
 /**
  * A single metadata annotation.
  *
  * For example, consider:
  *
  * [:
  * class Data {
  *   const Data();
@@ skipping 28 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }