Introduce element categories and move resolver towards being more compositional.

dart/frog/leg/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');
 
+class ElementCategory {
+  /**
+   * Represents things that we don't expect to find when looking in a
+   * scope.
+   */
+  static final int NONE = 0;
+
+  /** Field, parameter, or variable. */
+  static final int VARIABLE = 1;
+
+  /** Function, method, or foreign function. */
+  static final int FUNCTION = 2;
+
+  static final int CLASS = 4;
+
+  static final int PREFIX = 8;
+
+  /** Constructor or factory. */
+  static final int FACTORY = 16;
+
+  static final int ALIAS = 32;
+
+  static final int SUPER = 64;
+
+  static final int IMPLIES_TYPE = CLASS | ALIAS;
+}
+
 class ElementKind {
   final String id;
+  final int category;
 
-  const ElementKind(String this.id);
+  const ElementKind(String this.id, this.category);
 
-  static final ElementKind VARIABLE = const ElementKind('variable');
-  static final ElementKind PARAMETER = const ElementKind('parameter');
-  static final ElementKind FUNCTION = const ElementKind('function');
-  static final ElementKind CLASS = const ElementKind('class');
-  static final ElementKind FOREIGN = const ElementKind('foreign');
+  static final ElementKind VARIABLE =
+    const ElementKind('variable', ElementCategory.VARIABLE);
+  static final ElementKind PARAMETER =
+    const ElementKind('parameter', ElementCategory.VARIABLE);
+  static final ElementKind FUNCTION =
+    const ElementKind('function', ElementCategory.FUNCTION);
+  static final ElementKind CLASS =
+    const ElementKind('class', ElementCategory.CLASS);
+  static final ElementKind FOREIGN =
+    const ElementKind('foreign', ElementCategory.FUNCTION);
   static final ElementKind GENERATIVE_CONSTRUCTOR =
-      const ElementKind('generative_constructor');
-  static final ElementKind FIELD = const ElementKind('field');
-  static final ElementKind VARIABLE_LIST = const ElementKind('variable_list');
-  static final ElementKind FIELD_LIST = const ElementKind('field_list');
+      const ElementKind('generative_constructor', ElementCategory.FACTORY);
+  static final ElementKind FIELD =
+    const ElementKind('field', ElementCategory.VARIABLE);
+  static final ElementKind VARIABLE_LIST =
+    const ElementKind('variable_list', ElementCategory.NONE);
+  static final ElementKind FIELD_LIST =
+    const ElementKind('field_list', ElementCategory.NONE);
   static final ElementKind GENERATIVE_CONSTRUCTOR_BODY =
-      const ElementKind('generative_constructor_body');
+      const ElementKind('generative_constructor_body', ElementCategory.NONE);
   static final ElementKind COMPILATION_UNIT =
-      const ElementKind('compilation_unit');
-  static final ElementKind GETTER = const ElementKind('getter');
-  static final ElementKind SETTER = const ElementKind('setter');
-  static final ElementKind ABSTRACT_FIELD = const ElementKind('abstract_field');
-  static final ElementKind LIBRARY = const ElementKind('library');
-  static final ElementKind PREFIX = const ElementKind('prefix');
-  static final ElementKind TYPEDEF = const ElementKind('typedef');
+      const ElementKind('compilation_unit', ElementCategory.NONE);
+  static final ElementKind GETTER =
+    const ElementKind('getter',
+                      ElementCategory.VARIABLE); // TODO(ahe): Sb. NONE.
+  static final ElementKind SETTER =
+    const ElementKind('setter',
+                      ElementCategory.VARIABLE); // TODO(ahe): Sb. NONE.
+  static final ElementKind ABSTRACT_FIELD =
+    const ElementKind('abstract_field', ElementCategory.VARIABLE);
+  static final ElementKind LIBRARY =
+    const ElementKind('library', ElementCategory.NONE);
+  static final ElementKind PREFIX =
+    const ElementKind('prefix', ElementCategory.PREFIX);
+  static final ElementKind TYPEDEF =
+    const ElementKind('typedef', ElementCategory.ALIAS);
 
-  static final ElementKind STATEMENT = const ElementKind('statement');
-  static final ElementKind LABEL = const ElementKind('label');
+  static final ElementKind STATEMENT =
+    const ElementKind('statement', ElementCategory.NONE);
+  static final ElementKind LABEL =
+    const ElementKind('label', ElementCategory.NONE);
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Modifiers get modifiers() => null;
 
@@ skipping 13 matching lines @@
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isCompilationUnit() {
     return kind === ElementKind.COMPILATION_UNIT ||
            kind === ElementKind.LIBRARY;
   }
   bool isClass() => kind === ElementKind.CLASS;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
   bool isTypedef() => kind === ElementKind.TYPEDEF;
-  // TODO(ahe): Remove this method.
-  bool isClassOrInterfaceOrTypedef() {
-    return kind == ElementKind.CLASS || kind == ElementKind.TYPEDEF;
-  }
+  bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
 
   const Element(this.name, this.kind, this.enclosingElement);
@@ skipping 107 matching lines @@
 }
 
 class PrefixElement extends Element {
   final LiteralString prefix;
   final LibraryElement library;
 
   PrefixElement(LiteralString prefix,
                 LibraryElement this.library,
                 Element enclosing)
     : this.prefix = prefix,
-      super(prefix.dartString.source, ElementKind.PREFIX, enclosing) {
-    }
+      super(prefix.dartString.source, ElementKind.PREFIX, enclosing);
+
+  lookupLocalMember(SourceString name) => library.lookupLocalMember(name);
 }
 
 class TypedefElement extends Element {
   TypedefElement(SourceString name, Element enclosing)
     : super(name, ElementKind.TYPEDEF, enclosing);
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
@@ skipping 297 matching lines @@
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     Type returnType = compiler.types.voidType;
     type = new FunctionType(returnType, const EmptyLink<Type>(), this);
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = new FunctionExpression(
-        new Identifier.synthetic(''),
+        new Identifier(enclosingElement.position()),
         new NodeList.empty(),
         new Block(new NodeList.empty()),
         null, null, null, null);
     return cachedNode;
   }
 
   Token position() => null;
 }
 
 class ClassElement extends ContainerElement {
@@ skipping 77 matching lines @@
       compiler.resolveType(this);
       isResolved = true;
     }
     return this;
   }
 
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
+  Element lookupSuperMember(SourceString name) {
+    for (ClassElement s = superclass; s != null; s = s.superclass) {
+      Element e = s.lookupLocalMember(name);
+      if (e !== null) return e;
+    }
+    return null;
+  }
+
   Element lookupConstructor(SourceString className,
                             [SourceString constructorName =
                                  const SourceString(''),
                             Element noMatch(Element)]) {
     // TODO(karlklose): have a map from class names to a map of constructors
     //                  instead of creating the name here?
     SourceString normalizedName;
     if (constructorName !== const SourceString('')) {
       normalizedName = Elements.constructConstructorName(className,
                                                          constructorName);
@@ skipping 175 matching lines @@
 
   LabelElement addLabel(Identifier label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 }