anchor.diff:              new ast.NullLiteral(), node.methodName.name, new ast.Arguments([]),
               candidateTarget: element);
         }
  -      return new ast.MethodInvocation(new ast.StaticGet(method), callName,
  -          buildArgumentsForInvocation(node));
  +      return new ast.MethodInvocation(
  +          new ast.StaticGet(method),
  +          callName,
  +          buildArgumentsForInvocation(node),
  +          scope.resolveInterfaceFunctionCall(element));
       } else if (target == null && !scope.allowThis ||
           target is Identifier && target.staticElement is ClassElement ||
           target is Identifier && target.staticElement is PrefixElement) {
  
positive.code:       return new ast.MethodInvocation(
            new ast.VariableGet(scope.getVariableReference(element)),
            callName,
            buildArgumentsForInvocation(node));
      } else if (isStaticMethod(element)) {
        var method = scope.resolveConcreteMethod(element);
        var arguments = buildArgumentsForInvocation(node);
  
negative.code:   ast.Member resolveInterfaceGet(Element element, Element auxiliary) {
      if (!strongMode) return null;
      return _resolveGet(element, auxiliary, supportsInterfaceGet);
    }
  
    DartType getterTypeOfElement(Element element) {
      if (element is VariableElement) {
        return element.type;
      } else if (element is PropertyAccessorElement && element.isGetter) {
        return element.returnType;
      } else {
        return null;
      }
    }
  
    /// Returns the interface target of a `call` dispatch to the given member.
    ///
    /// For example, if the member is a field of type C, the target will be the
    /// `call` method of class C, if it has such a method.
    ///
    /// If the class C has a getter or field named `call`, this method returns
    /// `null` - the static type system does support typed calls with indirection.
    ast.Member resolveInterfaceFunctionCall(Element element) {
      if (!strongMode || element == null) return null;
      return resolveInterfaceFunctionCallOnType(getterTypeOfElement(element));
    }
  
    /// Returns the `call` method of [callee], if it has one, otherwise `null`.
    ast.Member resolveInterfaceFunctionCallOnType(DartType callee) {
      return callee is InterfaceType
          ? resolveInterfaceMethod(callee.getMethod('call'))
          : null;
    }
  
    ast.Member _resolveSet(
  