Compute more SendStructures on ResolverVisitor.

pkg/compiler/lib/src/resolution/members.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.
 
 part of resolution;
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
@@ skipping 169 matching lines @@
       compiler.reportError(node, kind, arguments);
     } else {
       compiler.reportWarning(node, kind, arguments);
     }
     // TODO(ahe): Use [allowedCategory] to synthesize a more precise subclass
     // of [ErroneousElementX]. For example, [ErroneousFieldElementX],
     // [ErroneousConstructorElementX], etc.
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
+  /// Report a warning or error on an unresolved access in non-instance context.
+  ///
+  /// The [ErroneousElement] corresponding to the message is returned.
+  ErroneousElement reportCannotResolve(Node node, String name) {
+    assert(invariant(node, !inInstanceContext,
+        message: "ResolverVisitor.reportCannotResolve must not be called in "
+                 "instance context."));
+
+    // We report an error within initializers because `this` is implicitly
+    // accessed when unqualified identifiers are not resolved.  For
+    // details, see section 16.14.3 of the spec (2nd edition):
+    //   An unqualified invocation `i` of the form `id(a1, ...)`
+    //   ...
+    //   If `i` does not occur inside a top level or static function, `i`
+    //   is equivalent to `this.id(a1 , ...)`.
+    bool inInitializer =
+        enclosingElement.isGenerativeConstructor ||
+        (enclosingElement.isInstanceMember && enclosingElement.isField);
+    MessageKind kind;
+    Map arguments = {'name': name};
+    if (inInitializer) {
+      kind = MessageKind.CANNOT_RESOLVE_IN_INITIALIZER;
+    } else if (name == 'await') {
+      var functionName = enclosingElement.name;
+      if (functionName == '') {
+        kind = MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE;
+      } else {
+        kind = MessageKind.CANNOT_RESOLVE_AWAIT;
+        arguments['functionName'] = functionName;
+      }
+    } else {
+      kind = MessageKind.CANNOT_RESOLVE;
+    }
+    registry.registerThrowNoSuchMethod();
+    return reportAndCreateErroneousElement(
+        node, name, kind, arguments, isError: inInitializer);
+  }
+
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': 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 {
       String name = node.source;
       Element element = lookupInScope(compiler, node, scope, name);
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // objects than [Element] from this method.
         element = compiler.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
         registry.setType(node, const DynamicType());
       }
-      element = reportLookupErrorIfAny(element, node, node.source);
+      element = reportLookupErrorIfAny(element, node, name);
       if (element == null) {
         if (!inInstanceContext) {
-          // We report an error within initializers because `this` is implicitly
-          // accessed when unqualified identifiers are not resolved.  For
-          // details, see section 16.14.3 of the spec (2nd edition):
-          //   An unqualified invocation `i` of the form `id(a1, ...)`
-          //   ...
-          //   If `i` does not occur inside a top level or static function, `i`
-          //   is equivalent to `this.id(a1 , ...)`.
-          bool inInitializer = enclosingElement.isGenerativeConstructor ||
-              (enclosingElement.isInstanceMember && enclosingElement.isField);
-          MessageKind kind;
-          Map arguments = {'name': name};
-          if (inInitializer) {
-            kind = MessageKind.CANNOT_RESOLVE_IN_INITIALIZER;
-          } else if (name == 'await') {
-            var functionName = enclosingElement.name;
-            if (functionName == '') {
-              kind = MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE;
-            } else {
-              kind = MessageKind.CANNOT_RESOLVE_AWAIT;
-              arguments['functionName'] = functionName;
-            }
-          } else {
-            kind = MessageKind.CANNOT_RESOLVE;
-          }
-          element = reportAndCreateErroneousElement(node, name, kind,
-              arguments, isError: inInitializer);
-          registry.registerThrowNoSuchMethod();
+          element = reportCannotResolve(node, name);
         }
       } else if (element.isErroneous) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           element = reportAndCreateErroneousElement(
               node, name, MessageKind.GENERIC,
               // TODO(ahe): Improve error message. Need UX input.
               {'text': "is not an expression $element"});
         }
@@ skipping 224 matching lines @@
   }
 
   ResolutionResult resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) registry.registerSuperUse(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert) {
-        SendStructure sendStructure = const AssertStructure();
-        if (selector.argumentCount != 1) {
-          error(node.selector,
-                MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
-                {'argumentCount': selector.argumentCount});
-          sendStructure = const InvalidAssertStructure();
-        } else if (selector.namedArgumentCount != 0) {
-          error(node.selector,
-                MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
-                {'argumentCount': selector.namedArgumentCount});
-          sendStructure = const InvalidAssertStructure();
-        }
-        registry.registerAssert(node);
-        registry.registerSendStructure(node, sendStructure);
-        return const AssertResult();
+        internalError(node, "Unexpected assert: $node");
       }
 
       return node.selector.accept(this);
     }
 
     var oldCategory = allowedCategory;
     allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
 
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     int oldAllowedCategory = allowedCategory;
@@ skipping 189 matching lines @@
         : new Selector.call(identifier.source, library, arity, named);
   }
 
   Selector resolveSelector(Send node, Element element) {
     LibraryElement library = enclosingElement.library;
     Selector selector = computeSendSelector(node, library, element);
     if (selector != null) registry.setSelector(node, selector);
     return selector;
   }
 
-  void resolveArguments(NodeList list) {
-    if (list == null) return;
+  CallStructure resolveArguments(NodeList list) {
+    if (list == null) return null;
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     Map<String, Node> seenNamedArguments = new Map<String, Node>();
+    int argumentCount = 0;
+    List<String> namedArguments = <String>[];
     for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       visit(argument);
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         String source = namedArgument.name.source;
+        namedArguments.add(source);
         if (seenNamedArguments.containsKey(source)) {
           reportDuplicateDefinition(
               source,
               argument,
               seenNamedArguments[source]);
         } else {
           seenNamedArguments[source] = namedArgument;
         }
       } else if (!seenNamedArguments.isEmpty) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
+      argumentCount++;
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
+    return new CallStructure(argumentCount, namedArguments);
   }
 
   void registerTypeLiteralAccess(Send node, Element target) {
     // Set the type of the node to [Type] to mark this send as a
     // type literal.
     DartType type;
 
     // TODO(johnniwinther): Remove this hack when we can pass more complex
     // information between methods than resolved elements.
     if (target == compiler.typeClass && node.receiver == null) {
@@ skipping 17 matching lines @@
           // the element on the selector, so [analyzeConstant] can build
           // the type literal from the selector.
           registry.useElement(node.selector, target);
         }
         analyzeConstantDeferred(node.selector, enforceConst: false);
       }
     }
   }
 
   /// Check that access to `super` is currently allowed.
-  bool checkSuperAccess(Node node) {
+  bool checkSuperAccess(Send node) {
     if (!inInstanceContext) {
-      compiler.reportError(node, MessageKind.NO_SUPER_AVAILABLE);
+      compiler.reportError(node, MessageKind.NO_SUPER_IN_STATIC);
+      return false;
+    }
+    if (node.isConditional) {
+      // `super?.foo` is not allowed.
+      compiler.reportError(node, MessageKind.INVALID_USE_OF_SUPER);
       return false;
     }
     if (currentClass.supertype == null) {
       // This is just to guard against internal errors, so no need
       // for a real error message.
       compiler.reportError(node, MessageKind.GENERIC,
             {'text': "Object has no superclass"});
       return false;
     }
     registry.registerSuperUse(node);
     return true;
   }
 
+  /// Check that access to `this` is currently allowed.
+  bool checkThisAccess(Send node) {
+    if (!inInstanceContext) {
+      compiler.reportError(node, MessageKind.NO_THIS_AVAILABLE);
+      return false;
+    }
+    if (node.isConditional) {
+      // `this?.foo` is not allowed.
+      compiler.reportError(node, MessageKind.INVALID_USE_OF_THIS);
+      return false;
+    }
+    return true;
+  }
+
   /// Compute the [AccessSemantics] corresponding to a super access of [target].
   AccessSemantics computeSuperAccess(Spannable node, Element target) {
     if (target.isErroneous) {
       return new StaticAccess.unresolvedSuper(target);
     } else if (target.isGetter) {
       return new StaticAccess.superGetter(target);
     } else if (target.isSetter) {
       return new StaticAccess.superSetter(target);
     } else if (target.isField) {
       return new StaticAccess.superField(target);
     } else {
       assert(invariant(node, target.isFunction,
           message: "Unexpected super target '$target'."));
       return new StaticAccess.superMethod(target);
     }
   }
 
+  /// Compute the [AccessSemantics] for accessing the name of [selector] on the
+  /// super class.
+  ///
+  /// If no matching super member is found and error is reported and
+  /// `noSuchMethod` on `super` is registered. Furthermore, if [alternateName]
+  /// is provided, the [AccessSemantics] corresponding to the alternate name is
+  /// returned. For instance, the access of a super setter for an unresolved
+  /// getter:
+  ///
+  ///     class Super {
+  ///       set name(_) {}
+  ///     }
+  ///     class Sub extends Super {
+  ///       foo => super.name; // Access to the setter.
+  ///     }
+  ///
   AccessSemantics computeSuperSemantics(Spannable node,
                                         Selector selector,
                                         {Name alternateName}) {
     Name name = selector.memberName;
     // TODO(johnniwinther): Ensure correct behavior if currentClass is a
     // patch.
     Element target = currentClass.lookupSuperByName(name);
     // [target] may be null which means invoking noSuchMethod on super.
     if (target == null) {
       Element error = reportAndCreateErroneousElement(
           node, name.text, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': name});
       if (alternateName != null) {
         target = currentClass.lookupSuperByName(alternateName);
       }
       if (target == null) {
         // If a setter wasn't resolved, use the [ErroneousElement].
         target = error;
       }
       // We still need to register the invocation, because we might
       // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
       registry.registerDynamicInvocation(selector);
       registry.registerSuperNoSuchMethod();
     }
     return computeSuperAccess(node, target);
   }
 
+  /// Resolve [node] as subexpression that is _not_ the prefix of a member
+  /// access. For instance `a` in `a + b`, as opposed to `a` in `a.b`.
   ResolutionResult visitExpression(Node node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     ResolutionResult result = visit(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
     return result;
   }
 
+  /// Handle a type test expression, like `a is T` and `a is! T`.
   ResolutionResult handleIs(Send node) {
     Node expression = node.receiver;
     visitExpression(expression);
 
     // TODO(johnniwinther): Use seen type tests to avoid registration of
     // mutation/access to unpromoted variables.
 
     Send notTypeNode = node.arguments.head.asSend();
     DartType type;
     SendStructure sendStructure;
     if (notTypeNode != null) {
       // `e is! T`.
       Node typeNode = notTypeNode.receiver;
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsNotStructure(type);
     } else {
       // `e is T`.
       Node typeNode = node.arguments.head;
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsStructure(type);
     }
     registry.registerIsCheck(type);
     registry.registerSendStructure(node, sendStructure);
     return null;
   }
 
+  /// Handle a type cast expression, like `a as T`.
   ResolutionResult handleAs(Send node) {
     Node expression = node.receiver;
     visitExpression(expression);
 
     Node typeNode = node.arguments.head;
     DartType type = resolveTypeAnnotation(typeNode);
     registry.registerAsCheck(type);
     registry.registerSendStructure(node, new AsStructure(type));
     return null;
   }
 
+  /// Handle the unary expression of an unresolved unary operator [text], like
+  /// the no longer supported `+a`.
   ResolutionResult handleUnresolvedUnary(Send node, String text) {
     Node expression = node.receiver;
     if (node.isSuperCall) {
       checkSuperAccess(node);
     } else {
       visitExpression(expression);
     }
 
     registry.registerSendStructure(node, const InvalidUnaryStructure());
     return null;
   }
 
+  /// Handle the unary expression of a user definable unary [operator], like
+  /// `-a`, and `-super`.
   ResolutionResult handleUserDefinableUnary(Send node, UnaryOperator operator) {
     Node expression = node.receiver;
     Selector selector = operator.selector;
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
 
     AccessSemantics semantics;
     if (node.isSuperCall) {
       if (checkSuperAccess(node)) {
@@ skipping 14 matching lines @@
     }
     if (semantics != null) {
       // TODO(johnniwinther): Support invalid super access as an
       // [AccessSemantics].
       registry.registerSendStructure(node,
           new UnaryStructure(semantics, operator));
     }
     return null;
   }
 
+  /// Handle a not expression, like `!a`.
   ResolutionResult handleNot(Send node, UnaryOperator operator) {
     assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
 
     Node expression = node.receiver;
     visitExpression(expression);
     registry.registerSendStructure(node,
         new NotStructure(new DynamicAccess.dynamicProperty(expression)));
     return null;
   }
 
+  /// Handle a logical and expression, like `a && b`.
   ResolutionResult handleLogicalAnd(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     doInPromotionScope(left, () => visitExpression(left));
     doInPromotionScope(right, () => visitExpression(right));
     registry.registerSendStructure(node, const LogicalAndStructure());
     return null;
   }
 
+  /// Handle a logical or expression, like `a || b`.
   ResolutionResult handleLogicalOr(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     visitExpression(left);
     visitExpression(right);
     registry.registerSendStructure(node, const LogicalOrStructure());
     return null;
   }
 
+  /// Handle an if-null expression, like `a ?? b`.
   ResolutionResult handleIfNull(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     visitExpression(left);
     visitExpression(right);
     registry.registerSendStructure(node, const IfNullStructure());
     return null;
   }
 
+  /// Handle the binary expression of an unresolved binary operator [text], like
+  /// the no longer supported `a === b`.
   ResolutionResult handleUnresolvedBinary(Send node, String text) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     if (node.isSuperCall) {
       checkSuperAccess(node);
     } else {
       visitExpression(left);
     }
     visitExpression(right);
     registry.registerSendStructure(node, const InvalidBinaryStructure());
     return null;
   }
 
+  /// Handle the binary expression of a user definable binary [operator], like
+  /// `a + b`, `super + b`, `a == b` and `a != b`.
   ResolutionResult handleUserDefinableBinary(Send node,
                                              BinaryOperator operator) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     AccessSemantics semantics;
     Selector selector;
     if (operator.kind == BinaryOperatorKind.INDEX) {
       selector = new Selector.index();
     } else {
       selector = new Selector.binaryOperator(operator.selectorName);
     }
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
 
     if (node.isSuperCall) {
       if (checkSuperAccess(node)) {
         semantics = computeSuperSemantics(node, selector);
         // TODO(johnniwinther): Add information to [AccessSemantics] about
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(johnniwinther): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
-
       }
     } else {
       visitExpression(left);
       registry.registerDynamicInvocation(selector);
       semantics = new DynamicAccess.dynamicProperty(left);
     }
     visitExpression(right);
 
     if (semantics != null) {
       // TODO(johnniwinther): Support invalid super access as an
@@ skipping 30 matching lines @@
         case BinaryOperatorKind.LOGICAL_OR:
         case BinaryOperatorKind.IF_NULL:
           internalError(node, "Unexpected binary operator '${operator}'.");
           break;
       }
       registry.registerSendStructure(node, sendStructure);
     }
     return null;
   }
 
+  /// Handle an invocation of an expression, like `(){}()` or `(foo)()`.
+  ResolutionResult handleExpressionInvoke(Send node) {
+    assert(invariant(node, node.isCall,
+        message: "Unexpected expression: $node"));
+    Node expression = node.selector;
+    visitExpression(expression);
+    CallStructure callStructure = resolveArguments(node.argumentsNode);
+    Selector selector = callStructure.callSelector;
+    // TODO(johnniwinther): Remove this when all information goes through the

[karlklose, 2015/05/29 11:12:14]

Maybe extract setSelector/registerDynamicInvocation pairs into a helper so that
you only need to add the TODO there.

[Johnni Winther, 2015/05/29 12:47:54]

The two are not always paired :(

+    // [SendStructure].
+    registry.setSelector(node, selector);
+    registry.registerDynamicInvocation(selector);
+    registry.registerSendStructure(node,
+        new InvokeStructure(new AccessSemantics.expression(), selector));
+    return null;
+  }
+
+  /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
+  ResolutionResult handleAssert(Send node) {
+    assert(invariant(node, node.isCall,
+        message: "Unexpected assert: $node"));
+    // If this send is of the form "assert(expr);", then
+    // this is an assertion.
+
+    CallStructure callStructure = resolveArguments(node.argumentsNode);
+    SendStructure sendStructure = const AssertStructure();
+    if (callStructure.argumentCount != 1) {
+      compiler.reportError(
+          node.selector,
+          MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
+          {'argumentCount': callStructure.argumentCount});
+      sendStructure = const InvalidAssertStructure();
+    } else if (callStructure.namedArgumentCount != 0) {
+      compiler.reportError(
+          node.selector,
+          MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
+          {'argumentCount': callStructure.namedArgumentCount});
+      sendStructure = const InvalidAssertStructure();
+    }
+    registry.registerAssert(node);
+    registry.registerSendStructure(node, sendStructure);
+    return const AssertResult();
+  }
+
+  /// Handle access of a property of [name] on `this`, like `this.name` and
+  /// `this.name()`, or `name` and `name()` in instance context.
+  ResolutionResult handleThisPropertyAccess(Send node, Name name) {
+    AccessSemantics accessSemantics = new AccessSemantics.thisProperty();
+    SendStructure sendStructure;
+    Selector selector;
+    if (node.isCall) {
+      CallStructure callStructure = resolveArguments(node.argumentsNode);
+      selector = new Selector(SelectorKind.CALL, name, callStructure);
+      registry.registerDynamicInvocation(selector);
+      sendStructure = new InvokeStructure(accessSemantics, selector);
+    } else {
+      assert(invariant(node, node.isPropertyAccess));
+      selector = new Selector(
+          SelectorKind.GETTER, name, CallStructure.NO_ARGS);
+      registry.registerDynamicGetter(selector);
+      sendStructure = new GetStructure(accessSemantics, selector);
+    }
+    registry.registerSendStructure(node, sendStructure);
+    // TODO(johnniwinther): Remove this when all information goes through
+    // the [SendStructure].
+    registry.setSelector(node, selector);
+    return null;
+  }
+
+  /// Handle access on `this`, like `this()` and `this` when it is parsed as a
+  /// [Send] node.
+  ResolutionResult handleThisAccess(Send node) {
+    AccessSemantics accessSemantics = new AccessSemantics.thisAccess();
+    if (node.isCall) {
+      CallStructure callStructure = resolveArguments(node.argumentsNode);
+      Selector selector = callStructure.callSelector;
+      // Handle invalid this access as an [AccessSemantics].
+      if (checkThisAccess(node)) {
+        registry.registerDynamicInvocation(selector);
+        registry.registerSendStructure(node,
+            new InvokeStructure(accessSemantics, selector));
+      }
+      // TODO(johnniwinther): Remove this when all information goes through
+      // the [SendStructure].
+      registry.setSelector(node, selector);
+    } else {
+      // TODO(johnniwinther): Handle get of `this` when it is a [Send] node.
+      internalError(node, "Unexpected node '$node'.");
+    }
+    return null;
+  }
+
+  /// Handle access of a super property, like `super.foo` and `super.foo()`.
+  ResolutionResult handleSuperPropertyAccess(Send node, Name name) {
+    Element target;
+    Selector selector;
+    CallStructure callStructure = CallStructure.NO_ARGS;
+    if (node.isCall) {
+      callStructure = resolveArguments(node.argumentsNode);
+      selector = new Selector(SelectorKind.CALL, name, callStructure);
+    } else {
+      selector = new Selector(SelectorKind.GETTER, name, callStructure);
+    }
+    if (checkSuperAccess(node)) {
+      AccessSemantics semantics = computeSuperSemantics(
+          node, selector, alternateName: name.setter);
+      if (node.isCall) {
+        bool isIncompatibleInvoke = false;
+        switch (semantics.kind) {
+          case AccessKind.SUPER_METHOD:
+            MethodElementX superMethod = semantics.element;
+            superMethod.computeSignature(compiler);
+            if (!callStructure.signatureApplies(superMethod)) {
+              registry.registerThrowNoSuchMethod();
+              registry.registerDynamicInvocation(selector);
+              registry.registerSuperNoSuchMethod();
+              isIncompatibleInvoke = true;
+            } else {
+              registry.registerStaticInvocation(semantics.element);
+            }
+            break;
+          case AccessKind.SUPER_FIELD:
+          case AccessKind.SUPER_GETTER:
+            registry.registerStaticUse(semantics.element);
+            selector = callStructure.callSelector;
+            registry.registerDynamicInvocation(selector);
+            break;
+          case AccessKind.SUPER_SETTER:
+          case AccessKind.UNRESOLVED_SUPER:
+            // NoSuchMethod registered in [computeSuperSemantics].
+            break;
+          default:
+            internalError(node, "Unexpected super property access $semantics.");
+            break;
+        }
+        registry.registerSendStructure(node,
+            isIncompatibleInvoke
+                ? new IncompatibleInvokeStructure(semantics, selector)
+                : new InvokeStructure(semantics, selector));
+      } else {
+        switch (semantics.kind) {
+          case AccessKind.SUPER_METHOD:
+            // TODO(johnniwinther): Method this should be registered as a
+            // closurization.
+            registry.registerStaticUse(semantics.element);
+            break;
+          case AccessKind.SUPER_FIELD:
+          case AccessKind.SUPER_GETTER:
+            registry.registerStaticUse(semantics.element);
+            break;
+          case AccessKind.SUPER_SETTER:
+          case AccessKind.UNRESOLVED_SUPER:
+            // NoSuchMethod registered in [computeSuperSemantics].
+            break;
+          default:
+            internalError(node, "Unexpected super property access $semantics.");
+            break;
+        }
+        registry.registerSendStructure(node,
+            new GetStructure(semantics, selector));
+      }
+      target = semantics.element;
+    }
+    if (node.isConditional) {

[karlklose, 2015/05/29 11:12:14]

Should this be an internalError?

[Johnni Winther, 2015/05/29 12:47:54]

Removed.

+
+    }
+    // TODO(johnniwinther): Remove these when all information goes through
+    // the [SendStructure].
+    registry.useElement(node, target);
+    registry.setSelector(node, selector);
+    return null;
+  }
+
+  /// Handle a [Send] whose selector is an [Operator], like `a && b`, `a is T`,
+  /// `a + b`, and `~a`.
+  ResolutionResult handleOperatorSend(Send node) {
+    String operatorText = node.selector.asOperator().source;
+    if (operatorText == 'is') {
+      return handleIs(node);
+    } else if (operatorText  == 'as') {
+      return handleAs(node);
+    } else if (node.arguments.isEmpty) {
+      UnaryOperator operator = UnaryOperator.parse(operatorText);
+      if (operator == null) {
+        return handleUnresolvedUnary(node, operatorText);
+      } else {
+        switch (operator.kind) {
+          case UnaryOperatorKind.NOT:
+            return handleNot(node, operator);
+          case UnaryOperatorKind.COMPLEMENT:
+          case UnaryOperatorKind.NEGATE:
+            assert(invariant(node, operator.isUserDefinable,
+                message: "Unexpected unary operator '${operator}'."));
+            return handleUserDefinableUnary(node, operator);
+        }
+        return handleUserDefinableUnary(node, operator);
+      }
+    } else {
+      BinaryOperator operator = BinaryOperator.parse(operatorText);
+      if (operator == null) {
+        return handleUnresolvedBinary(node, operatorText);
+      } else {
+        switch (operator.kind) {
+          case BinaryOperatorKind.LOGICAL_AND:
+            return handleLogicalAnd(node);
+          case BinaryOperatorKind.LOGICAL_OR:
+            return handleLogicalOr(node);
+          case BinaryOperatorKind.IF_NULL:
+            return handleIfNull(node);
+          case BinaryOperatorKind.EQ:
+          case BinaryOperatorKind.NOT_EQ:
+          case BinaryOperatorKind.INDEX:
+          case BinaryOperatorKind.ADD:
+          case BinaryOperatorKind.SUB:
+          case BinaryOperatorKind.MUL:
+          case BinaryOperatorKind.DIV:
+          case BinaryOperatorKind.IDIV:
+          case BinaryOperatorKind.MOD:
+          case BinaryOperatorKind.SHL:
+          case BinaryOperatorKind.SHR:
+          case BinaryOperatorKind.GTEQ:
+          case BinaryOperatorKind.GT:
+          case BinaryOperatorKind.LTEQ:
+          case BinaryOperatorKind.LT:
+          case BinaryOperatorKind.AND:
+          case BinaryOperatorKind.OR:
+          case BinaryOperatorKind.XOR:
+            return handleUserDefinableBinary(node, operator);
+        }
+      }
+    }
+  }
+
+  /// Handle a qualified [Send], that is where the receiver is non-null, like
+  /// `a.b`, `a.b()`, `this.a()` and `super.a()`.
+  ResolutionResult handleQualifiedSend(Send node) {
+    Identifier selector = node.selector.asIdentifier();
+    Name name = new Name(selector.source, enclosingElement.library);
+    if (node.isSuperCall) {
+      return handleSuperPropertyAccess(node, name);
+    } else if (node.receiver.isThis()) {
+      return handleThisPropertyAccess(node, name);
+    }
+    // TODO(johnniwinther): Handle remaining qualified sends.
+    return oldVisitSend(node);
+  }
+
+  /// Handle access unresolved access to [name] in a non-instance context.
+  ResolutionResult handleUnresolvedAccess(
+        Send node, Name name, Element element) {
+    // TODO(johnniwinther): Support unresolved top level access as an
+    // [AccessSemantics].
+    AccessSemantics accessSemantics = new StaticAccess.unresolved(element);
+    SendStructure sendStructure;
+    Selector selector;
+    if (node.isCall) {
+      CallStructure callStructure = resolveArguments(node.argumentsNode);
+      selector = new Selector(SelectorKind.CALL, name, callStructure);
+      registry.registerDynamicInvocation(selector);
+      sendStructure = new InvokeStructure(accessSemantics, selector);
+    } else {
+      assert(invariant(node, node.isPropertyAccess));
+      selector = new Selector(
+          SelectorKind.GETTER, name, CallStructure.NO_ARGS);
+      registry.registerDynamicGetter(selector);
+      sendStructure = new GetStructure(accessSemantics, selector);
+    }
+    // TODO(johnniwinther): Remove this when all information goes through
+    // the [SendStructure].
+    registry.setSelector(node, selector);
+    registry.useElement(node, element);
+    registry.registerSendStructure(node, sendStructure);
+    return null;
+  }
+
+  /// Handle an unqualified [Send], that is where the receiver is null, like

[karlklose, 2015/05/29 11:12:14]

Make clear that the receiver Node is null, not the value.

[Johnni Winther, 2015/05/29 12:47:54]

Good call!

+  /// `a`, `a()`, `this()`, `assert()`, and `(){}()`.
+  ResolutionResult handleUnqualifiedSend(Send node) {
+    Identifier selector = node.selector.asIdentifier();
+    if (selector == null) {
+      // `(){}()` and `(foo)()`.
+      return handleExpressionInvoke(node);
+    }
+    String text = selector.source;
+    if (text == 'assert') {
+      // `assert()`.
+      return handleAssert(node);
+    } else if (text == 'this') {
+      // `this()`.
+      return handleThisAccess(node);
+    } else if (text == 'dynamic') {
+      // `dynamic` || `dynamic()`.
+      // TODO(johnniwinther): Handle dynamic type literal access.
+      return oldVisitSend(node);
+    }
+    // `name` or `name()`
+    Name name = new Name(text, enclosingElement.library);
+    Element element = lookupInScope(compiler, node, scope, text);
+    if (element == null) {
+      if (inInstanceContext) {
+        // Implicitly `this.name`.
+        return handleThisPropertyAccess(node, name);
+      } else {
+        // Create [ErroneousElement] for unresolved access.
+        ErroneousElement error = reportCannotResolve(node, text);
+        return handleUnresolvedAccess(node, name, error);
+      }
+    }
+    return oldVisitSend(node);
+  }
+
   ResolutionResult visitSend(Send node) {
     if (node.isOperator) {
-      String operatorText = node.selector.asOperator().source;
-      if (operatorText == 'is') {
-        return handleIs(node);
-      } else if (operatorText  == 'as') {
-        return handleAs(node);
-      } else if (node.arguments.isEmpty) {
-        UnaryOperator operator = UnaryOperator.parse(operatorText);
-        if (operator == null) {
-          return handleUnresolvedUnary(node, operatorText);
-        } else {
-          switch (operator.kind) {
-            case UnaryOperatorKind.NOT:
-              return handleNot(node, operator);
-            case UnaryOperatorKind.COMPLEMENT:
-            case UnaryOperatorKind.NEGATE:
-              assert(invariant(node, operator.isUserDefinable,
-                  message: "Unexpected unary operator '${operator}'."));
-              return handleUserDefinableUnary(node, operator);
-          }
-          return handleUserDefinableUnary(node, operator);
-        }
-      } else {
-        BinaryOperator operator = BinaryOperator.parse(operatorText);
-        if (operator == null) {
-          return handleUnresolvedBinary(node, operatorText);
-        } else {
-          switch (operator.kind) {
-            case BinaryOperatorKind.LOGICAL_AND:
-              return handleLogicalAnd(node);
-            case BinaryOperatorKind.LOGICAL_OR:
-              return handleLogicalOr(node);
-            case BinaryOperatorKind.IF_NULL:
-              return handleIfNull(node);
-            case BinaryOperatorKind.EQ:
-            case BinaryOperatorKind.NOT_EQ:
-            case BinaryOperatorKind.INDEX:
-            case BinaryOperatorKind.ADD:
-            case BinaryOperatorKind.SUB:
-            case BinaryOperatorKind.MUL:
-            case BinaryOperatorKind.DIV:
-            case BinaryOperatorKind.IDIV:
-            case BinaryOperatorKind.MOD:
-            case BinaryOperatorKind.SHL:
-            case BinaryOperatorKind.SHR:
-            case BinaryOperatorKind.GTEQ:
-            case BinaryOperatorKind.GT:
-            case BinaryOperatorKind.LTEQ:
-            case BinaryOperatorKind.LT:
-            case BinaryOperatorKind.AND:
-            case BinaryOperatorKind.OR:
-            case BinaryOperatorKind.XOR:
-              return handleUserDefinableBinary(node, operator);
-          }
-        }
-      }
-    }
-
+      return handleOperatorSend(node);
+    } else if (node.receiver != null) {
+      return handleQualifiedSend(node);
+    } else {
+      return handleUnqualifiedSend(node);
+    }
+    return oldVisitSend(node);
+  }
+
+  ResolutionResult oldVisitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
 
     ResolutionResult result = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
 
     Element target = result != null ? result.element : null;
 
     if (target != null
         && target == compiler.mirrorSystemGetNameFunction
@@ skipping 63 matching lines @@
         // class or typedef literal. We do not need to register this call as a
         // dynamic invocation, because we statically know what the target is.
       } else {
         if (target is FunctionElement) {
           FunctionElement function = target;
           function.computeSignature(compiler);
         }
         if (!selector.applies(target, compiler.world)) {
           registry.registerThrowNoSuchMethod();
           if (node.isSuperCall) {
-            // Similar to what we do when we can't find super via selector
-            // in [resolveSend] above, we still need to register the invocation,
-            // because we might call [:super.noSuchMethod:] which calls
-            // [JSInvocationMirror._invokeOn].
-            registry.registerDynamicInvocation(selector);
-            registry.registerSuperNoSuchMethod();
+            internalError(node, "Unexpected super call $node");
           }
         }
       }
 
       if (target != null && target.isForeign(compiler.backend)) {
         if (selector.name == 'JS') {
           registry.registerJsCall(node, this);
         } else if (selector.name == 'JS_EMBEDDED_GLOBAL') {
           registry.registerJsEmbeddedGlobalCall(node, this);
         } else if (selector.name == 'JS_BUILTIN') {
@@ skipping 13 matching lines @@
     registry.useElement(node, target);
     registerSend(selector, target);
     if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
       registry.registerGetOfStaticFunction(target.declaration);
     }
     return node.isPropertyAccess ? new ElementResult(target) : null;
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(Node node, String typeName) {
-    Element element = lookupInScope(compiler, node,
-                                    scope, typeName);
+    Element element = lookupInScope(compiler, node, scope, typeName);
     if (element == null) return null;
     if (element is! ClassElement) return null;
     ClassElement cls = element;
     cls.ensureResolved(compiler);
     return cls.computeType(compiler);
   }
 
   ResolutionResult visitSendSet(SendSet node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
@@ skipping 1087 matching lines @@
   visitTypedef(Typedef node) {
     internalError(node, 'typedef');
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }