Clean-up of getCompilationUnit.

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 90 matching lines @@
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<Node> metadata = const EmptyLink<Node>();
 
-
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
   Modifiers get modifiers() => null;
 
   Node parseNode(DiagnosticListener listener) {
     listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
   Type computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
   void addMetadata(Node node) {
     metadata = metadata.prepend(node);
   }
 
   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;
     }
-    // TODO(lrn): Skip any synthetic elements inserted, e.g.,
-    // a compilation unit override.
     return enclosing !== null && enclosing.isClass();
   }
   bool isInstanceMember() => false;
   bool isFactoryConstructor() => modifiers !== null && modifiers.isFactory();
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isGenerativeConstructorBody() =>
       kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY;
-  bool isCompilationUnit() {
-    return kind === ElementKind.COMPILATION_UNIT ||
-           kind === ElementKind.LIBRARY ||
-           kind === ElementKind.COMPILATION_UNIT_OVERRIDE;
-  }
-  /**
-   * Provides the compilation unit corresponding to this element.
-   * Returns non-null for elements where [isCompilationUnit] returns true,
-   * but may not return the current [Element].
-   */
-  CompilationUnitElement asCompilationUnit() => null;
+  bool isCompilationUnit() => kind === ElementKind.COMPILATION_UNIT;
   bool isClass() => kind === ElementKind.CLASS;
   bool isPrefix() => kind === ElementKind.PREFIX;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
   bool isTypedef() => kind === ElementKind.TYPEDEF;
   bool isTypeVariable() => kind === ElementKind.TYPE_VARIABLE;
   bool isField() => kind === ElementKind.FIELD;
   bool isGetter() => kind === ElementKind.GETTER;
   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;
 
   // 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() => enclosingElement.isCompilationUnit();
+  bool isTopLevel() {
+    return enclosingElement !== null && enclosingElement.isCompilationUnit();
+  }
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
 
   Token findMyName(Token token) {
     for (Token t = token; t.kind !== EOF_TOKEN; t = t.next) {
       if (t.value == name) return t;
     }
     return token;
   }
 
   // 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();
 
-  Script getScript() {
-    return getCompilationUnit().script;
-  }
-
   CompilationUnitElement getCompilationUnit() {
-    if (isCompilationUnit()) return this;
-    return enclosingElement.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;
+      if (element is FunctionElement) {
+        FunctionElement function = element;
+        if (function.isPatched) {
+          element = function.patch;
+        }
+      }
+    }
+    return element;
   }
 
   LibraryElement getLibrary() {
     Element element = this;
     while (element.kind !== ElementKind.LIBRARY) {
       element = element.enclosingElement;
     }
     return element;
   }
 
   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;
+    }
+    return null;
+  }
+
   Element getEnclosingMember() {
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isMember()) return e;
     }
     return null;
   }
 
   Element getOutermostEnclosingMemberOrTopLevel() {
     // TODO(lrn): Why is this called "Outermost"?
     for (Element e = this; e !== null; e = e.enclosingElement) {
@@ skipping 77 matching lines @@
         listener.cancel('duplicate definition', token: element.position());
         listener.cancel('existing definition', token: existing.position());
       }
     }
   }
 
   Element localLookup(SourceString elementName) {
     return localScope[elementName];
   }
 
-  void addGetterOrSetter(Element element,
+  void addGetterOrSetter(FunctionElement element,
                          Element existing,
                          DiagnosticListener listener) {
     void reportError(Element other) {
       // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
       listener.cancel('duplicate definition of ${element.name.slowToString()}',
                       element: element);
       listener.cancel('existing definition', element: other);
     }
 
     if (existing != null) {
       if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
         reportError(existing);
       } else {
         AbstractFieldElement field = existing;
         if (element.kind == ElementKind.GETTER) {
           if (field.getter != null && field.getter != element) {
             reportError(field.getter);
           }
           field.getter = element;
         } else {
           if (field.setter != null && field.setter != element) {
             reportError(field.setter);
           }
           field.setter = element;
         }
       }
     } else {
-      AbstractFieldElement field = new AbstractFieldElement(element.name, this);
+      Element container = element.getEnclosingClassOrCompilationUnit();
+      AbstractFieldElement field =
+          new AbstractFieldElement(element.name, container);
       if (element.kind == ElementKind.GETTER) {
         field.getter = element;
       } else {
         field.setter = element;
       }
       addMember(field, listener);
     }
   }
 }
 
@@ skipping 16 matching lines @@
 
 class CompilationUnitOverrideElement extends Element {
   final CompilationUnitElement compilationUnit;
 
   CompilationUnitOverrideElement(CompilationUnitElement compilationUnit,
                                  Element enclosing)
       : this.compilationUnit = compilationUnit,
         super(compilationUnit.name,
               ElementKind.COMPILATION_UNIT_OVERRIDE,
               enclosing);
-
-  CompilationUnitElement asCompilationUnit() => compilationUnit;
-
-  CompilationUnitElement getCompilationUnit() => compilationUnit;
 }
 
 class LibraryElement extends ScopeContainerElement {
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const EmptyLink<CompilationUnitElement>();
 
   Link<ScriptTag> tags = const EmptyLink<ScriptTag>();
   ScriptTag libraryTag;
   bool canUseNative = false;
@@ skipping 52 matching lines @@
   String getLibraryOrScriptName() {
     if (libraryTag !== null) {
       return libraryTag.argument.dartString.slowToString();
     } else {
       // Use the file name as script name.
       String path = uri.path;
       return path.substring(path.lastIndexOf('/') + 1);
     }
   }
 
-  CompilationUnitElement getCompilationUnit() => entryCompilationUnit;
-
   Scope buildEnclosingScope() => new TopScope(this);
 }
 
 class PrefixElement extends Element {
   Map<SourceString, Element> imported;
   Token firstPosition;
 
   PrefixElement(SourceString prefix, Element enclosing, this.firstPosition)
       : imported = new Map<SourceString, Element>(),
         super(prefix, ElementKind.PREFIX, enclosing);
@@ skipping 216 matching lines @@
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
   }
 
   position() {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
     // non-null and defined in the same compilation unit as the
     // abstract element.
+    // TODO(lrn): No we don't know that if the element from the same
+    // compilation unit is patched.
     //
     // We need to make sure that the position returned is relative to
     // the compilation unit of the abstract element.
-    if (getter !== null 
+    if (getter !== null
         && getter.getCompilationUnit() === getCompilationUnit()) {
       return getter.position();
     } else {
       return setter.position();
     }
   }
 
   Modifiers get modifiers() {
     // The resolver ensures that the flags match (ignoring abstract).
     if (getter !== null) {
@@ skipping 88 matching lines @@
   FunctionElement.tooMuchOverloading(SourceString name,
                                      FunctionExpression this.cachedNode,
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
     defaultImplementation = this;
   }
 
-  Script getScript() {
-    if (patch !== null) return patch.getScript();
-    return super.getScript();
-  }
-
   bool get isPatched() => patch !== null;
 
   /**
    * 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.
@@ skipping 620 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, node, type, bound);
     return result;
   }
 }