Stub implementation of patch invariants for the patch refactoring.

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 89 matching lines @@
   static const ElementKind STATEMENT =
     const ElementKind('statement', ElementCategory.NONE);
   static const ElementKind LABEL =
     const ElementKind('label', ElementCategory.NONE);
   static const ElementKind VOID =
     const ElementKind('void', ElementCategory.NONE);
 
   toString() => id;
 }
 
-class Element implements Hashable {
+class Element implements Hashable, Spannable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
   Modifiers get modifiers => null;
@@ skipping 43 matching lines @@
   bool isSetter() => kind === ElementKind.SETTER;
   bool isAccessor() => isGetter() || isSetter();
   bool isForeign() => kind === ElementKind.FOREIGN;
   bool isLibrary() => kind === ElementKind.LIBRARY;
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
   bool isExtendable() => (kind.category & ElementCategory.IS_EXTENDABLE) != 0;
 
   /** See [ErroneousElement] for documentation. */
   bool isErroneous() => false;
 
+  /**
+   * Is [:true:] if this element has a corresponding patch.
+   *
+   * If [:true:] this element has a non-null [patch] field.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  bool get isPatched => false;
+
+  /**
+   * Is [:true:] if this element is a patch.
+   *
+   * If [:true:] this element has a non-null [origin] field.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  bool get isPatch => false;
+
+
+  /**
+   * Is [:true:] if this element defines the implementation for the entity of
+   * this element.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  bool get isImplementation => implementation === this;
+
+  /**
+   * Is [:true:] if this element introduces the entity of this element.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  bool get isDeclaration => declaration === this;
+
+  /**
+   * Returns the element which defines the implementation for the entity of this
+   * element.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  Element get implementation => this;
+
+  /**
+   * Returns the element which introduces the entity of this element.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  Element get declaration => this;
+
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
   bool isTopLevel() {
     return enclosingElement !== null && enclosingElement.isCompilationUnit();
   }
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinalOrConst()) return false;
@@ skipping 38 matching lines @@
   }
 
   LibraryElement getLibrary() {
     Element element = this;
     while (element.kind !== ElementKind.LIBRARY) {
       element = element.enclosingElement;
     }
     return element;
   }
 
+  LibraryElement getImplementationLibrary() => getLibrary();
+
   ClassElement getEnclosingClass() {
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isClass()) return e;
     }
     return null;
   }
 
   Element getEnclosingClassOrCompilationUnit() {
    for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isClass() || e.isCompilationUnit()) return e;
@@ skipping 45 matching lines @@
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
 
   FunctionElement asFunctionElement() => null;
 
   Element cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.cancel("Unimplemented cloneTo", element: this);
   }
-
-  bool get isPatched => false;
 }
 
 /**
  * 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 29 matching lines @@
 class ErroneousFunctionElement extends ErroneousElement
                                implements FunctionElement {
   ErroneousFunctionElement(Message errorMessage, SourceString targetName,
                            Element enclosing)
       : super(errorMessage, targetName, enclosing);
 
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => unsupported();
+  get origin => unsupported();
   get defaultImplementation => unsupported();
   bool get isPatched => unsupported();
+  bool get isPatch => unsupported();
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(copmiler) => unsupported();
 }
 
 class ContainerElement extends Element {
   Link<Element> localMembers = const EmptyLink<Element>();
 
@@ skipping 613 matching lines @@
   int optionalParameterCount(Compiler compiler) {
     return computeSignature(compiler).optionalParameterCount;
   }
 
   int parameterCount(Compiler compiler) {
     return computeSignature(compiler).parameterCount;
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
-    type = compiler.computeFunctionType(this, computeSignature(compiler));
+    type = compiler.computeFunctionType(declaration,
+                                        computeSignature(compiler));
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     if (patch === null) {
-      if (modifiers.isExternal()) {
+      if (modifiers != null && modifiers.isExternal()) {
         listener.cancel("Compiling external function with no implementation.",
                         element: this);
       }
       return null;
     }
     cachedNode = patch.parseNode(listener);
     return cachedNode;
   }
 
   Token position() => cachedNode.getBeginToken();
 
   FunctionElement asFunctionElement() => this;
 
-  FunctionElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    FunctionElement result = new FunctionElement.tooMuchOverloading(
-        name, cachedNode, kind, modifiers, enclosing, functionSignature);
-    result.defaultImplementation = defaultImplementation;
-    result.type = type;
-    return result;
+  String toString() {
+    if (isPatch) {
+      return 'patch ${super.toString()}';
+    } else if (isPatched) {
+      return 'origin ${super.toString()}';
+    } else {
+      return super.toString();
+    }
   }
 
   Scope buildScope() {
-    Scope result = new MethodScope(enclosingElement.buildScope(), this);
+    Scope result =
+        new MethodScope(enclosingElement.buildScope(), this);
     if (enclosingElement.isClass()) {
-      ClassScope clsScope = result.parent;
+      Scope clsScope = result.parent;
       clsScope.inStaticContext = !isInstanceMember() && !isConstructor();
     }
     return result;
   }
 }
 
-
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               null,
               constructor.enclosingElement) {
     functionSignature = constructor.functionSignature;
@@ skipping 115 matching lines @@
       ClassNode node = parseNode(compiler);
       Link<DartType> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
     return type;
   }
 
   bool get isPatched => patch != null;
 
+  /**
+   * Return [:true:] if this element is the [:Object:] class for the [compiler].
+   */
+  bool isObject(Compiler compiler) =>
+      declaration === compiler.objectClass;
+
   Link<DartType> get typeVariables => type.arguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
   /**
@@ skipping 523 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }