anchor.diff:              calledArgTy
       else
           match calledArg.OptArgInfo with 
  -        | NotOptional ->
  +        // CSharpMethod(x = arg), non-optional C#-style argument, may have type Nullable<ty>. 
  +        | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) ->
               calledArgTy
   
  +        // The arg should have type ty. However for backwards compat, we also allow arg to have type Nullable<ty>
  +        | NotOptional 
           // 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
  
positive.code:                     callerArgExpr 
                  else                            
                      // CSharpMethod(x=b) when CSharpMethod(A) --> CSharpMethod(?x=Some(b :> A))
                      let calledArgTy = assignedArg.CalledArg.CalledArgumentType
                      if isOptionTy g calledArgTy then 
                          let calledNonOptTy = destOptionTy g calledArgTy 
                          let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr
  
negative.code:     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 callerArg = assignedArg.CallerArg
      let (CallerArg(callerArgTy, m, isOptCallerArg, callerArgExpr)) = callerArg
      let calledArg = assignedArg.CalledArg
      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 ->
                  //  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
  