Introduce element categories and move resolver towards being more compositional.

dart/frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 515 matching lines @@
 
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   bool inInstanceContext;
   Scope context;
   ClassElement currentClass;
   bool typeRequired = false;
   StatementScope statementScope;
+  int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
       this.context  = element.isMember()
         ? new ClassScope(element.enclosingElement, element.getLibrary())
         : new TopScope(element.getLibrary()),
       this.currentClass = element.isMember() ? element.enclosingElement : null,
@@ skipping 21 matching lines @@
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
     action();
     inInstanceContext = wasInstanceContext;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
-  visitIdentifier(Identifier node) {
+  Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
+      if ((ElementCategory.SUPER & allowedCategory) == 0) {
+        error(node, MessageKind.INVALID_USE_OF_SUPER);
+      }
       return null;
     } else {
       Element element = lookup(node, node.source);
-      if (element == null) {
-        error(node, MessageKind.CANNOT_RESOLVE, [node]);
+      if (element === null) {
+        if (!inInstanceContext) error(node, MessageKind.CANNOT_RESOLVE, [node]);
+      } else {
+        if ((element.kind.category & allowedCategory) == 0) {
+          // TODO(ahe): Improve error message. Need UX input.
+          error(node, MessageKind.GENERIC, ["is not an expression $element"]);
+        }
       }
       return useElement(node, element);
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     SourceString className;
     if (node.typeName.asSend() !== null) {
       // In new and const expressions, the type name can be a Send to
       // denote named constructors or library prefixes.
       Send send = node.typeName.asSend();
       className = send.receiver.asIdentifier().source;
     } else {
       className = node.typeName.asIdentifier().source;
     }
     if (className == const SourceString('var')) return null;
     if (className == const SourceString('void')) return null;
     Element element = context.lookup(className);
     if (element === null) {
       if (typeRequired) {
         error(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
       } else {
         warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
       }
-    } else if (!element.isClassOrInterfaceOrTypedef()) {
+    } else if (!element.impliesType()) {
       if (typeRequired) {
         error(node, MessageKind.NOT_A_TYPE, [className]);
       } else {
         warning(node, MessageKind.NOT_A_TYPE, [className]);
       }
     } else {
       if (element.isClass()) {
         // TODO(ngeoffray): Should we also resolve typedef?
         ClassElement cls = element;
         compiler.resolver.toResolve.add(element);
@@ skipping 110 matching lines @@
     setupFunction(node, enclosingElement);
     defineElement(node, enclosingElement, doAddToScope: node.name !== null);
 
     // Run the body in a fresh statement scope.
     StatementScope oldScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldScope;
 
     context = context.parent;
-    return enclosingElement;
   }
 
   visitIf(If node) {
     visit(node.condition);
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (str === '&&' || str == '||' || str == '!');
   }
 
   Element resolveSend(Send node) {
+    if (node.receiver === null || node.selector.isThis()) {
+      return node.selector.accept(this);
+    }
+    var oldCategory = allowedCategory;
+    allowedCategory |=
+      ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
+    allowedCategory = oldCategory;
 
-    Element target = null;
-    if (node.selector.asIdentifier() === null) {
-      // We are calling a closure returned from an expression.
-      assert(node.selector.asExpression() !== null);
-      assert(resolvedReceiver === null);
-      visit(node.selector);
-    } else {
-      SourceString name = node.selector.asIdentifier().source;
-      if (node.receiver === null) {
-        target = lookup(node, name);
-        if (target === null && !inInstanceContext) {
-          error(node, MessageKind.CANNOT_RESOLVE, [name]);
-        }
-      } else if (node.isSuperCall) {
-        if (currentClass !== null) {
-          ClassElement superElement = currentClass.superclass;
-          if (superElement !== null) {
-            // TODO(ngeoffray): The lookup should continue on super
-            // classes.
-            target = superElement.lookupLocalMember(name);
-          }
-          if (target === null) {
-            error(node,
-                  MessageKind.METHOD_NOT_FOUND,
-                  [superElement.name, name]);
-          }
-        }
-      } else if (resolvedReceiver === null) {
+    Element target;
+    SourceString name = node.selector.asIdentifier().source;
+    if (node.isSuperCall) {
+      if (isUserDefinableOperator(name.stringValue)) {
+        name = Elements.constructOperatorName(const SourceString('operator'),
+                                              name);
+      }
+      if (!inInstanceContext) {
+        error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, [name]);
         return null;
-      } else if (resolvedReceiver.kind === ElementKind.CLASS) {
-        ClassElement receiverClass = resolvedReceiver;
-        target = receiverClass.resolve(compiler).lookupLocalMember(name);
-        if (target === null) {
-          error(node, MessageKind.METHOD_NOT_FOUND, [receiverClass.name, name]);
-        } else if (target.isInstanceMember()) {
-          error(node, MessageKind.MEMBER_NOT_STATIC,
-                [receiverClass.name, name]);
-        }
-      } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
-        PrefixElement prefix = resolvedReceiver;
-        target = prefix.library.lookupLocalMember(name);
-        if (target == null) {
-          error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER,
-                [resolvedReceiver.name, name]);
-        }
+      }
+      target = currentClass.lookupSuperMember(name);
+      if (target === null) {
+        error(node.selector, MessageKind.METHOD_NOT_FOUND,
+              [currentClass.superclass.name, name]);
+      }
+    } else if (resolvedReceiver === null) {
+      return null;
+    } else if (resolvedReceiver.kind === ElementKind.CLASS) {
+      ClassElement receiverClass = resolvedReceiver;
+      target = receiverClass.resolve(compiler).lookupLocalMember(name);
+      if (target === null) {
+        error(node, MessageKind.METHOD_NOT_FOUND, [receiverClass.name, name]);
+      } else if (target.isInstanceMember()) {
+        error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
+      }
+    } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
+      PrefixElement prefix = resolvedReceiver;
+      target = prefix.lookupLocalMember(name);
+      if (target == null) {
+        error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER, [prefix.name, name]);
       }
     }
     return target;
   }
 
   resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node == null) {
       node = argument.asSend().receiver;
     }
@@ skipping 40 matching lines @@
       mapping.setSelector(node, Selector.GETTER);
     } else {
       handleArguments(node);
     }
     if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
     }
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
-    return useElement(node, target);
+    useElement(node, target);
+    if (node.isPropertyAccess) return target;
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     Element setter = null;
     Element getter = null;
     if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       setter = field.setter;
       getter = field.getter;
@@ skipping 314 matching lines @@
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
       element.interfaces = element.interfaces.prepend(visit(link.head));
     }
     return element.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
-    Identifier name = node.typeName.asIdentifier();
-    if (name === null) {
-      unimplemented(node.typeName, "prefixes");
-    }
-    return visit(name);
+    return visit(node.typeName);
   }
 
   Type visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element === null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
-    } else if (!element.isClassOrInterfaceOrTypedef()) {
+    } else if (!element.impliesType()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
     } else {
       if (element.isClass()) {
         compiler.resolver.toResolve.add(element);
       }
       // TODO(ngeoffray): Use type variables.
       return element.computeType(compiler);
     }
     return null;
   }
+
+  Type visitSend(Send node) {
+    Identifier prefix = node.receiver.asIdentifier();
+    if (prefix === null) {
+      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      return null;
+    }
+    Element element = context.lookup(prefix.source);
+    if (element === null || element.kind !== ElementKind.PREFIX) {
+      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      return null;
+    }
+    var e = element.library.lookupLocalMember(node.selector.source);
+    if (e === null || !e.impliesType()) {
+      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
+      return null;
+    }
+    return e.computeType(compiler);
+  }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
@@ skipping 310 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }