anchor.diff:  
       let candidates = candidateMethsAndProps |> List.map fst
   
  -
  -    // Split the syntactic arguments (if any) into named and unnamed parameters
  -    //
  -    // In one case (the second "single named item" rule) we delay the application of a
  -    // argument until we've produced a lambda that detuples an input tuple
  +    // Step 0. Split the syntactic arguments (if any) into named and unnamed parameters
       let curriedCallerArgsOpt, unnamedDelayedCallerArgExprOpt, exprTy =
  -        match curriedCallerArgs with
  -        | [] ->
  -            None, None, exprTy
  -        | _ ->
  -            let unnamedCurriedCallerArgs, namedCurriedCallerArgs = curriedCallerArgs |> List.map GetMethodArgs |> List.unzip
  -
  -            // There is an mismatch when _uses_ of indexed property setters in the tc.fs code that calls this function.
  -            // The arguments are passed as if they are curried with arity [numberOfIndexParameters;1], however in the TAST, indexed property setters
  -            // are uncurried and have arity [numberOfIndexParameters+1].
  -            //
  -            // Here we work around this mismatch by crunching all property argument lists to uncurried form.
  -            // Ideally the problem needs to be solved at its root cause at the callsites to this function
  -            let unnamedCurriedCallerArgs, namedCurriedCallerArgs =
  -                if isProp then
  -                    [List.concat unnamedCurriedCallerArgs], [List.concat namedCurriedCallerArgs]
  -                else
  -                    unnamedCurriedCallerArgs, namedCurriedCallerArgs
  -
  -            let MakeUnnamedCallerArgInfo x = (x, GetNewInferenceTypeForMethodArg cenv env tpenv x, x.Range)
  -
  -            let singleMethodCurriedArgs =
  -                match candidates with
  -                | [calledMeth] when List.forall isNil namedCurriedCallerArgs  ->
  -                    let curriedCalledArgs = calledMeth.GetParamAttribs(cenv.amap, mItem)
  -                    match curriedCalledArgs with
  -                    | [arg :: _] when isSimpleFormalArg arg -> Some(curriedCalledArgs)
  -                    | _ -> None
  -                | _ -> None
  -
  -            // "single named item" rule. This is where we have a single accessible method
  -            //      member x.M(arg1)
  -            // being used with
  -            //      x.M (x, y)
  -            // Without this rule this requires
  -            //      x.M ((x, y))
  -            match singleMethodCurriedArgs, unnamedCurriedCallerArgs with
  -            | Some [[_]], _ ->
  -                let unnamedCurriedCallerArgs = curriedCallerArgs |> List.map (MakeUnnamedCallerArgInfo >> List.singleton)
  -                let namedCurriedCallerArgs = namedCurriedCallerArgs |> List.map (fun _ -> [])
  -                (Some (unnamedCurriedCallerArgs, namedCurriedCallerArgs), None, exprTy)
  -
  -            // "single named item" rule. This is where we have a single accessible method
  -            //      member x.M(arg1, arg2)
  -            // being used with
  -            //      x.M p
  -            // We typecheck this as if it has been written "(fun (v1, v2) -> x.M(v1, v2)) p"
  -            // Without this rule this requires
  -            //      x.M (fst p, snd p)
  -            | Some [_ :: args], [[_]] when List.forall isSimpleFormalArg args ->
  -                // The call lambda has function type
  -                let exprTy = mkFunTy g (NewInferenceType g) exprTy.Commit
  -
  -                (None, Some unnamedCurriedCallerArgs.Head.Head, MustEqual exprTy)
  -
  -            | _ ->
  -                let unnamedCurriedCallerArgs = unnamedCurriedCallerArgs |> List.mapSquared MakeUnnamedCallerArgInfo
  -                let namedCurriedCallerArgs = namedCurriedCallerArgs |> List.mapSquared (fun (isOpt, nm, x) ->
  -                    let ty = GetNewInferenceTypeForMethodArg cenv env tpenv x
  -                    // #435263: compiler crash with .net optional parameters and F# optional syntax
  -                    // named optional arguments should always have option type
  -                    // STRUCT OPTIONS: if we allow struct options as optional arguments then we should relax this and rely
  -                    // on later inference to work out if this is a struct option or ref option
  -                    let ty = if isOpt then mkOptionTy denv.g ty else ty
  -                    nm, isOpt, x, ty, x.Range)
  -
  -                (Some (unnamedCurriedCallerArgs, namedCurriedCallerArgs), None, exprTy)
  -
  -    let CalledMethHasSingleArgumentGroupOfThisLength n (calledMeth: MethInfo) =
  -       match calledMeth.NumArgs with
  -       | [argAttribs] -> argAttribs = n
  -       | _ -> false
  -
  -    let GenerateMatchingSimpleArgumentTypes (calledMeth: MethInfo) =
  -        let curriedMethodArgAttribs = calledMeth.GetParamAttribs(cenv.amap, mItem)
  -        curriedMethodArgAttribs
  -        |> List.map (List.filter isSimpleFormalArg >> NewInferenceTypes g)
  -
  -    let UnifyMatchingSimpleArgumentTypes exprTy (calledMeth: MethInfo) =
  -        let curriedArgTys = GenerateMatchingSimpleArgumentTypes calledMeth
  -        let returnTy =
  -            (exprTy, curriedArgTys) ||> List.fold (fun exprTy argTys ->
  -                let domainTy, resultTy = UnifyFunctionType None cenv denv mMethExpr exprTy
  -                UnifyTypes cenv env mMethExpr domainTy (mkRefTupledTy g argTys)
  -                resultTy)
  -        curriedArgTys, returnTy
  +        TcMethodApplication_SplitSynArguments cenv env tpenv isProp candidates exprTy curriedCallerArgs mItem
   
       if isProp && Option.isNone curriedCallerArgsOpt then
           error(Error(FSComp.SR.parsIndexerPropertyRequiresAtLeastOneArgument(), mItem))
  
positive.code:     // Bind "out" parameters as part of the result tuple
      let callExpr2, exprTy =
          let expr = callExpr1
          if isNil outArgTmpBinds then expr, exprTy
          else
              let outArgTys = outArgExprs |> List.map (tyOfExpr g)
              let expr =
  
negative.code:             error(Error(FSComp.SR.etMissingStaticArgumentsToMethod(), mItem))
  #endif
  
          let tyArgsOpt, tpenv = TcMemberTyArgsOpt cenv env tpenv tyArgsOpt
          let meths = minfos |> List.map (fun minfo -> minfo, None)
  
          TcMethodApplicationThen cenv env overallTy None tpenv tyArgsOpt objArgs mExprAndItem mItem methodName ad mutates false meths afterResolution NormalValUse args atomicFlag delayed
  
      | Item.Property (nm, pinfos) ->
          // Instance property
  