anchor.diff:    void pushInvokeStatic(ast.Node location,
                           Element element,
                           List<HInstruction> arguments,
  -                        [TypeMask type]) {
  -    if (tryInlineMethod(element, null, arguments, location)) {
  +                        {TypeMask typeMask,
  +                         InterfaceType instanceType}) {
  +    if (tryInlineMethod(element, null, arguments, location,
  +                        instanceType: instanceType)) {
         return;
       }
   
  -    if (type == null) {
  -      type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
  +    if (typeMask == null) {
  +      typeMask =
  +          TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
       }
       bool targetCanThrow = !compiler.world.getCannotThrow(element);
       // TODO(5346): Try to avoid the need for calling [declaration] before
       // creating an [HInvokeStatic].
       HInvokeStatic instruction = new HInvokeStatic(
  -        element.declaration, arguments, type, targetCanThrow: targetCanThrow);
  +        element.declaration, arguments, typeMask,
  +        targetCanThrow: targetCanThrow);
       if (!currentInlinedInstantiations.isEmpty) {
         instruction.instantiatedTypes = new List<DartType>.from(
             currentInlinedInstantiations);
  
positive.code:       : directLocals = new Map<Local, HInstruction>.from(other.directLocals),
          redirectionMapping = other.redirectionMapping,
          executableContext = other.executableContext,
          builder = other.builder,
          closureData = other.closureData;
  
  
negative.code:         type = type.substByContext(
              contextClass.asInstanceOf(typeContext));
        }
      }
      if (instanceType != null) {
        type = type.substByContext(instanceType);
      }
      return type;
    }
  