anchor.diff:  
       let g = cenv.g
       let denv = env.DisplayEnv
  -
  -    let isSimpleFormalArg (isParamArrayArg, _isInArg, isOutArg, optArgInfo: OptionalArgInfo, callerInfo: CallerInfo, _reflArgInfo: ReflectedArgInfo) =
  -        not isParamArrayArg && not isOutArg && not optArgInfo.IsOptional && callerInfo = NoCallerInfo
  -
       let callerObjArgTys = objArgs |> List.map (tyOfExpr g)
  -
       let calledMeths = calledMethsAndProps |> List.map fst
   
       // Uses of curried members are ALWAYS treated as if they are first class uses of members.
  
positive.code: 
      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
      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
  
      if isProp && Option.isNone curriedCallerArgsOpt then
          error(Error(FSComp.SR.parsIndexerPropertyRequiresAtLeastOneArgument(), mItem))
  
negative.code: 
      match item with
      | Item.MethodGroup (methodName, minfos, _) ->
          let atomicFlag, tyArgsOpt, args, delayed, tpenv = GetSynMemberApplicationArgs delayed tpenv
          // We pass PossiblyMutates here because these may actually mutate a value type object
          // To get better warnings we special case some of the few known mutate-a-struct method names
          let mutates = (if methodName = "MoveNext" || methodName = "GetNextArg" then DefinitelyMutates else PossiblyMutates)
  
  #if !NO_TYPEPROVIDERS
          match TryTcMethodAppToStaticConstantArgs cenv env tpenv (minfos, tyArgsOpt, mExprAndItem, mItem) with
          | Some minfoAfterStaticArguments ->
              // Replace the resolution including the static parameters, plus the extra information about the original method info
              let item = Item.MethodGroup(methodName, [minfoAfterStaticArguments], Some minfos[0])
  