anchor.diff:      let callerArg = CallerArg(calledArgTy, mMethExpr, false, expr)
       preBinder, { NamedArgIdOpt = None; CalledArg = calledArg; CallerArg = callerArg }
   
  +let MakeNullableExprIfNeeded (infoReader: InfoReader) calledArgTy callerArgTy callerArgExpr m =
  +    let g = infoReader.g
  +    let amap = infoReader.amap
  +    if isNullableTy g callerArgTy then 
  +        callerArgExpr
  +    else
  +        let calledNonOptTy = destNullableTy g calledArgTy 
  +        let minfo = GetIntrinsicConstructorInfosOfType infoReader m calledArgTy |> List.head
  +        let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr
  +        MakeMethInfoCall amap m minfo [] [callerArgExprCoerced]
  +
   // Adjust all the optional arguments, filling in values for defaults, 
   let AdjustCallerArgForOptional tcFieldInit eCallerMemberName (infoReader: InfoReader) (assignedArg: AssignedCalledArg<_>) =
       let g = infoReader.g
  -    let amap = infoReader.amap
       let callerArg = assignedArg.CallerArg
       let (CallerArg(callerArgTy, m, isOptCallerArg, callerArgExpr)) = callerArg
       let calledArg = assignedArg.CalledArg
  -    match calledArg.OptArgInfo with 
  -    | NotOptional -> 
  +    let calledArgTy = calledArg.CalledArgumentType
  +    match calledArg.OptArgInfo with
  +    | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) ->
           if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m))
           assignedArg
  -    | _ -> 
  +
  +    | _ ->
  +
           let callerArgExpr2 = 
               match calledArg.OptArgInfo with 
  -            | NotOptional -> failwith "unreachable"
  +            | NotOptional ->
  +                //  T --> Nullable<T> widening at callsites
  +                if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m))
  +                if isNullableTy g calledArgTy then 
  +                    MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m
  +                else
  +                    callerArgExpr
               
               | CallerSide dfltVal -> 
                   let calledArgTy = calledArg.CalledArgumentType
  
positive.code:             calledArgTy
      else
          match calledArg.OptArgInfo with 
          | NotOptional ->
              calledArgTy
  
          // CSharpMethod(x = arg), optional C#-style argument, may have type Nullable<ty>. 
          // The arg should have type ty. However for backwards compat, we also allow arg to have type Nullable<ty>
          | CallerSide _ ->
              if isNullableTy g calledArgTy && g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then 
                  // If inference has worked out it's a nullable then use this
  
negative.code:                     callerArgExpr 
                  else                            
                      // CSharpMethod(x=b) when CSharpMethod(A) --> CSharpMethod(?x=Some(b :> A))
                      if isOptionTy g calledArgTy then 
                          let calledNonOptTy = destOptionTy g calledArgTy 
                          let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr
  