Reduce usage of .enclosingElement to get enclosing class.

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('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 100 matching lines @@
 
   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() =>
-      enclosingElement !== null && enclosingElement.kind === ElementKind.CLASS;
+  bool isMember() {
+    // Check that this element is defined in the scope of a Class.
+    Element enclosing = enclosingElement;
+    // TODO(lrn): Skip any synthetic elements inserted, e.g.,

[Anders Johnsen, 2012/08/09 08:08:37]

Maybe just travel up the tree and see if you hit a class?

[Lasse Reichstein Nielsen, 2012/08/09 11:22:09]

Alas no. That would make the parameter of a method itself a member of the class,
which it isn't.

+    // 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;
   }
   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 isAssignable() {
@@ skipping 31 matching lines @@
   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.kind === ElementKind.CLASS) return e;
+      if (e.isClass()) 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) {
       if (e.isMember() || e.isTopLevel()) {
         return e;
       }
     }
     return null;
   }
 
   /**
    * Creates the scope for this element. The scope of the
@@ skipping 1058 matching lines @@
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }