Clean patch implementation.

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 '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 import '../resolution/class_members.dart' show ClassMemberMixin;
 
 import '../dart2jslib.dart' show invariant,
                                  InterfaceType,
                                  DartType,
                                  TypeVariableType,
                                  TypedefType,
@@ skipping 85 matching lines @@
 
   /** See [ErroneousElement] for documentation. */
   bool isErroneous() => false;
 
   /** See [AmbiguousElement] for documentation. */
   bool isAmbiguous() => false;
 
   /** See [WarnOnUseElement] for documentation. */
   bool isWarnOnUse() => 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 => !isPatched;
+  bool get isImplementation => true;
 
-  /**
-   * Is [:true:] if this element introduces the entity of this element.
-   *
-   * See [:patch_parser.dart:] for a description of the terminology.
-   */
-  bool get isDeclaration => !isPatch;
+  bool get isDeclaration => true;
 
-  bool get isSynthesized => false;
+  Element get implementation => this;
 
-  bool get isForwardingConstructor => false;
-
-  bool get isMixinApplication => false;
-
-  /**
-   * 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 => isPatched ? patch : this;
-
-  /**
-   * Returns the element which introduces the entity of this element.
-   *
-   * See [:patch_parser.dart:] for a description of the terminology.
-   */
-  Element get declaration => isPatch ? origin : this;
+  Element get declaration => this;
 
   Element get patch {
     throw new UnsupportedError('patch is not supported on $this');
   }
 
   Element get origin {
     throw new UnsupportedError('origin is not supported on $this');
   }
 
+  bool get isSynthesized => false;
+
+  bool get isForwardingConstructor => false;
+
+  bool get isMixinApplication => false;
+
   // 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.isFinalOrConst()) return false;
@@ skipping 158 matching lines @@
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => null;
   get origin => this;
   get defaultImplementation => unsupported();
   get nestedClosures => unsupported();
 
   bool get isRedirectingFactory => unsupported();
 
-  setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
-  requiredParameterCount(compiler) => unsupported();
-  optionalParameterCount(compiler) => unsupported();
-  parameterCount(compiler) => unsupported();
 
   // TODO(kasperl): These seem unnecessary.
-  set patch(value) => unsupported();
-  set origin(value) => unsupported();
   set defaultImplementation(value) => unsupported();
 
   get redirectionTarget => this;
 
   getLibrary() => enclosingElement.getLibrary();
 
   computeTargetType(InterfaceType newType) => unsupported();
 
   String get message => '${messageKind.message(messageArguments)}';
 
@@ skipping 390 matching lines @@
         importScope[name] = ambiguousElement;
         importers.registerImport(ambiguousElement, import);
         importers.registerImport(ambiguousElement, existingImport);
       }
     }
   }
 
   Element operator [](String name) => importScope[name];
 }
 
-class LibraryElementX extends ElementX with AnalyzableElement
+class LibraryElementX
+    extends ElementX

[karlklose, 2014/05/06 09:27:07]

Does the 'extends ... with' clause fit in one line? I would prefer to format it
that way.

[Johnni Winther, 2014/05/06 12:05:29]

Done.

+    with AnalyzableElement,
+         PatchMixin<LibraryElementX>
     implements LibraryElement {
   final Uri canonicalUri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const Link<CompilationUnitElement>();
   Link<LibraryTag> tags = const Link<LibraryTag>();
   LibraryName libraryTag;
   bool canUseNative = false;
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
   final ImportScope importScope = new ImportScope();
 
-  /**
-   * If this library is patched, [patch] points to the patch library.
-   *
-   * See [:patch_parser.dart:] for a description of the terminology.
-   */
-  LibraryElementX patch = null;
-
-  /**
-   * If this is a patch library, [origin] points to the origin library.
-   *
-   * See [:patch_parser.dart:] for a description of the terminology.
-   */
-  final LibraryElementX origin;
-
   /// A mapping from an imported element to the "import" tag.
   final Importers importers = new Importers();
 
   /**
    * Link for elements exported either through export declarations or through
    * declaration. This field should not be accessed directly but instead through
    * the [exports] getter.
    *
    * [LibraryDependencyHandler] sets this field through [setExports] when the
    * library is loaded.
    */
   Link<Element> slotForExports;
 
   final Map<LibraryDependency, LibraryElement> tagMapping =
       new Map<LibraryDependency, LibraryElement>();
 
-  LibraryElementX(Script script, [Uri canonicalUri, LibraryElement this.origin])
+  LibraryElementX(Script script,
+                  [Uri canonicalUri, LibraryElementX origin])
     : this.canonicalUri =
           ((canonicalUri == null) ? script.readableUri : canonicalUri),
       super(script.name, ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElementX(script, this);
-    if (isPatch) {
-      origin.patch = this;
+    if (origin != null) {
+      origin.applyPatch(this);
     }
   }
 
-  bool get isPatched => patch != null;
-  bool get isPatch => origin != null;
-
-  LibraryElement get declaration => super.declaration;
-  LibraryElement get implementation => super.implementation;
-
   Link<MetadataAnnotation> get metadata {
     return (libraryTag == null) ? super.metadata : libraryTag.metadata;
   }
 
   set metadata(value) {
     // The metadata is stored on [libraryTag].
     throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
   }
 
   CompilationUnitElement getCompilationUnit() => entryCompilationUnit;
@@ skipping 10 matching lines @@
     assert(tagMapping[tag] == null);
     tagMapping[tag] = library;
   }
 
   LibraryElement getLibraryFromTag(LibraryDependency tag) => tagMapping[tag];
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
-   * [ErroneousElement] will be put in the imported scope, allowing for detection of ambiguous uses of imported names.
+   * [ErroneousElement] will be put in the imported scope, allowing for
+   * detection of ambiguous uses of imported names.
    */
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
@@ skipping 405 matching lines @@
 
   accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
 }
 
 /// [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
 /// origin parameter) but can be found through both the origin and the patch.
-class ParameterElementX extends ElementX implements ParameterElement {
+class ParameterElementX
+    extends ElementX
+    with PatchMixin<ParameterElement>

[karlklose, 2014/05/06 09:27:07]

Ditto.

[Johnni Winther, 2014/05/06 12:05:29]

Done.

+    implements ParameterElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
   final Expression initializer;
   DartType typeCache;
 
   /**
    * Function signature for a variable with a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    */
@@ skipping 29 matching lines @@
     assert(invariant(this, typeCache != null,
             message: "Parameter signature has not been set for $this."));
     return functionSignatureCache;
   }
 
   VariableDefinitions get node => definitions;
 
   FunctionType get functionType => type;
 
   accept(ElementVisitor visitor) => visitor.visitVariableElement(this);
-
-  ParameterElementX patch = null;
-  ParameterElementX origin = null;
-
-  bool get isPatch => origin != null;
-  bool get isPatched => patch != null;
 }
 
 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 126 matching lines @@
       // optional parameters is not a problem, they simply are never provided
       // by call sites of a call to a method with the other signature.
       int otherTotalCount = signature.parameterCount;
       return requiredParameterCount <= otherTotalCount
           && parameterCount >= otherTotalCount;
     }
     return true;
   }
 }
 
-class FunctionElementX extends ElementX with AnalyzableElement
+class FunctionElementX
+    extends ElementX

[karlklose, 2014/05/06 09:27:07]

Ditto.

[Johnni Winther, 2014/05/06 12:05:29]

Done.

+    with AnalyzableElement,
+         PatchMixin<FunctionElement>
     implements FunctionElement {
   FunctionExpression cachedNode;
   DartType typeCache;
   final Modifiers modifiers;
 
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FunctionSignature functionSignatureCache;
 
-  /**
-   * A function declaration that should be parsed instead of the current one.
-   * The patch should be parsed as if it was in the current scope. Its
-   * signature must match this function's signature.
-   */
-  FunctionElement patch = null;
-  FunctionElement origin = null;
-
   final bool _hasNoBody;
 
   AbstractFieldElement abstractField;
 
   /**
    * If this is a redirecting factory, [defaultImplementation] will be
    * changed by the resolver to point to the redirection target.
    * Otherwise, [:identical(defaultImplementation, this):].
    */
   // TODO(ahe): Rename this field to redirectionTarget.
@@ skipping 21 matching lines @@
                                       this.modifiers,
                                       Element enclosing,
                                       this.functionSignatureCache,
                                       bool hasNoBody)
       : super(name, kind, enclosing),
         _hasNoBody = hasNoBody {
     assert(modifiers != null);
     defaultImplementation = this;
   }
 
-  bool get isPatched => patch != null;
-  bool get isPatch => origin != null;
-
   bool get isRedirectingFactory => defaultImplementation != this;
 
   /// This field is set by the post process queue when checking for cycles.
   FunctionElement internalRedirectionTarget;
   DartType redirectionTargetType;
 
   set redirectionTarget(FunctionElement constructor) {
     assert(constructor != null && internalRedirectionTarget == null);
     internalRedirectionTarget = constructor;
   }
 
   FunctionElement get redirectionTarget {
     if (Elements.isErroneousElement(defaultImplementation)) {
       return defaultImplementation;
     }
     assert(!isRedirectingFactory || internalRedirectionTarget != null);
     return isRedirectingFactory ? internalRedirectionTarget : this;
   }
 
   InterfaceType computeTargetType(InterfaceType newType) {
     if (!isRedirectingFactory) return newType;
     assert(invariant(this, redirectionTargetType != null,
         message: 'Redirection target type has not yet been computed for '
                  '$this.'));
     return redirectionTargetType.substByContext(newType);
   }
 
-  /**
-   * Applies a patch function to this function. The patch function's body
-   * is used as replacement when parsing this function's body.
-   * This method must not be called after the function has been parsed,
-   * and it must be called at most once.
-   */
-  void setPatch(FunctionElement patchElement) {
-    // Sanity checks. The caller must check these things before calling.
-    assert(patch == null);
-    this.patch = patchElement;
-  }
-
   bool isInstanceMember() {
     return isMember()
            && !isConstructor()
            && !modifiers.isStatic();
   }
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
     compiler.withCurrentElement(this, () {
       functionSignatureCache = compiler.resolveSignature(this);
@@ skipping 304 matching lines @@
       variableElement.typeCache = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 abstract class BaseClassElementX extends ElementX
     with AnalyzableElement,
          TypeDeclarationElementX<InterfaceType>,
+         PatchMixin<ClassElement>,
          ClassMemberMixin
     implements ClassElement {
   final int id;
 
   DartType supertype;
   Link<DartType> interfaces;
   String nativeTagInfo;
   int supertypeLoadState;
   int resolutionState;
   bool get isResolved => resolutionState == STATE_DONE;
@@ skipping 12 matching lines @@
 
   BaseClassElementX(String name,
                     Element enclosing,
                     this.id,
                     int initialState)
       : supertypeLoadState = initialState,
         resolutionState = initialState,
         super(name, ElementKind.CLASS, enclosing);
 
   int get hashCode => id;
-  ClassElement get patch => super.patch;
-  ClassElement get origin => super.origin;
-  ClassElement get declaration => super.declaration;
-  ClassElement get implementation => super.implementation;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   bool get isUnnamedMixinApplication => false;
 
   InterfaceType computeType(Compiler compiler) {
     if (thisTypeCache == null) {
       computeThisAndRawType(compiler, computeTypeParameters(compiler));
     }
     return thisTypeCache;
@@ skipping 333 matching lines @@
   }
 
   FunctionType get callType {
     MemberSignature member =
         lookupInterfaceMember(const PublicName(Compiler.CALL_OPERATOR_NAME));
     return member != null && member.isMethod ? member.type : null;
   }
 }
 
 abstract class ClassElementX extends BaseClassElementX {
-  // Lazily applied patch of class members.
-  ClassElement patch = null;
-  ClassElement origin = null;
-
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
 
   ClassElementX(String name, Element enclosing, int id, int initialState)
       : super(name, enclosing, id, initialState);
 
   ClassNode parseNode(Compiler compiler);
 
   bool get isMixinApplication => false;
-  bool get isPatched => patch != null;
-  bool get isPatch => origin != null;
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     if (element.isField() && element.name == name) {
       listener.reportError(element, MessageKind.MEMBER_USES_CLASS_NAME);
@@ skipping 58 matching lines @@
                            this.node, this.modifiers)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   ClassElement get mixin => mixinType != null ? mixinType.element : null;
 
   bool get isMixinApplication => true;
   bool get isUnnamedMixinApplication => node is! NamedMixinApplication;
   bool get hasConstructor => !constructors.isEmpty;
   bool get hasLocalScopeMembers => !constructors.isEmpty;
 
-  unsupported(message) {
-    throw new UnsupportedError('$message is not supported on $this');
-  }
-
   get patch => null;
   get origin => null;
 
-  set patch(value) => unsupported('set patch');
-  set origin(value) => unsupported('set origin');
-
   Token position() => node.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => node;
 
   FunctionElement lookupLocalConstructor(String name) {
     for (Link<Element> link = constructors;
          !link.isEmpty;
          link = link.tail) {
       if (link.head.name == name) return link.head;
     }
@@ skipping 203 matching lines @@
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }
 
+/// Mixin for the implementation of patched elements.
+///
+/// See [:patch_parser.dart:] for a description of the terminology.
+abstract class PatchMixin<E extends Element> implements Element {
+  // TODO(johnniwinther): Use type variables when issue 18630 is fixed.
+  var/*E*/ patch = null;

[karlklose, 2014/05/06 09:27:07]

Use the bound (Element) instead of var.

[Johnni Winther, 2014/05/06 12:05:29]

Done. Added temporary explicit getters to BaseClassElementX and LibraryElementX
to preserve the current typing.

+  var/*E*/ origin = null;
+
+  bool get isPatch => origin != null;
+  bool get isPatched => patch != null;
+
+  bool get isImplementation => !isPatched;
+  bool get isDeclaration => !isPatch;
+
+  /*E*/ get implementation => isPatched ? patch : this;

[karlklose, 2014/05/06 09:27:07]

Use Element.

[Johnni Winther, 2014/05/06 12:05:29]

Done.

+  /*E*/ get declaration => isPatch ? origin : this;
+
+  /// Applies a patch to this element. This method must be called at most once.
+  void applyPatch(PatchMixin<E> patch) {
+    assert(invariant(this, this.patch == null,
+                     message: "Element is patched twice."));
+    assert(invariant(this, this.origin == null,
+                     message: "Origin element is a patch."));
+    assert(invariant(patch, patch.origin == null,
+                     message: "Element is patched twice."));
+    assert(invariant(patch, patch.patch == null,
+                     message: "Patch element is patched."));
+    this.patch = patch;
+    patch.origin = this;
+  }
+}