anchor.diff:          }
         }
       }
  -  }
  -
  -  ResolutionResult oldVisitSend(Send node) {
  -    bool oldSendIsMemberAccess = sendIsMemberAccess;
  -    sendIsMemberAccess = node.isPropertyAccess || node.isCall;
  -
  -    ResolutionResult result = resolveSend(node);
  -    sendIsMemberAccess = oldSendIsMemberAccess;
  -
  -    Element target = result.element;
  -
  -    if (target != null
  -        && target == compiler.mirrorSystemGetNameFunction
  -        && !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
  -      compiler.reportHint(
  -          node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
  -          {'class': compiler.mirrorSystemClass.name,
  -           'name': compiler.mirrorSystemGetNameFunction.name});
  -    }
  -
  -    if (target != null) {
  -      if (target.isErroneous) {
  -        registry.registerThrowNoSuchMethod();
  -      } else if (target.isAbstractField) {
  -        AbstractFieldElement field = target;
  -        target = field.getter;
  -        if (target == null) {
  -          if (!inInstanceContext || field.isTopLevel || field.isStatic) {
  -            registry.registerThrowNoSuchMethod();
  -            target = reportAndCreateErroneousElement(node.selector, field.name,
  -                MessageKind.CANNOT_RESOLVE_GETTER, const {});
  -          }
  -        }
  -      } else if (target.isTypeVariable) {
  -        ClassElement cls = target.enclosingClass;
  -        assert(enclosingElement.enclosingClass == cls);
  -        if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
  -          compiler.reportError(node,
  -              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
  -              {'typeVariableName': node.selector});
  -        }
  -        registry.registerClassUsingVariableExpression(cls);
  -        registry.registerTypeVariableExpression();
  -        registerTypeLiteralAccess(node, target);
  -      } else if (target.impliesType && (!sendIsMemberAccess || node.isCall)) {
  -        registerTypeLiteralAccess(node, target);
  -      }
  -      registerPotentialAccessInClosure(node, target);
  -    }
  -
  -    resolveArguments(node.argumentsNode);
  -
  -    // If the selector is null, it means that we will not be generating
  -    // code for this as a send.
  -    Selector selector = registry.getSelector(node);
  -    if (selector == null) return const NoneResult();
  -
  -    if (node.isCall) {
  -      if (Elements.isUnresolved(target) ||
  -          target.isGetter ||
  -          target.isField ||
  -          Elements.isClosureSend(node, target)) {
  -        // If we don't know what we're calling or if we are calling a getter,
  -        // we need to register that fact that we may be calling a closure
  -        // with the same arguments.
  -        Selector call = new Selector.callClosureFrom(selector);
  -        registry.registerDynamicInvocation(
  -            new UniverseSelector(selector, null));
  -      } else if (target.impliesType) {
  -        // We call 'call()' on a Type instance returned from the reference to a
  -        // 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.computeType(compiler);
  -        }
  -        if (!selector.applies(target, compiler.world)) {
  -          registry.registerThrowNoSuchMethod();
  -          if (node.isSuperCall) {
  -            internalError(node, "Unexpected super call $node");
  -          }
  -        }
  -      }
  -
  -      handleForeignCall(node, target, selector);
  -    }
  -
  -    registry.useElement(node, target);
  -    registerSend(selector, target);
  -    if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
  -      registry.registerGetOfStaticFunction(target.declaration);
  -    }
  -    return node.isPropertyAccess
  -        ? new ResolutionResult.forElement(target) : const NoneResult();
     }
   
     // TODO(johnniwinther): Move this to the backend resolution callbacks.
  
positive.code:     } 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 {
  
negative.code:     // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
      // of parse errors to make [element] erroneous. Fix this!
      member.computeType(compiler);
  
  
      if (member == compiler.mirrorSystemGetNameFunction &&
          !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
        compiler.reportHint(
            node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
            {'class': compiler.mirrorSystemClass.name,
             'name': compiler.mirrorSystemGetNameFunction.name});
      }
  
      Selector selector;
      AccessSemantics semantics =
  