Support CallerArgumentExpression

docs/release-notes/.FSharp.Compiler.Service/10.0.100.md

@@ -7,6 +7,7 @@
 * Diagnostics: add extended data for 'No constructors' error ([PR #18863](https://github.com/dotnet/fsharp/pull/18863))
 * FSharpType.Format: support top-level prefix generic types style. ([PR #18897](https://github.com/dotnet/fsharp/pull/18897))
 * FCS: allow getting captured types ([PR $18878](https://github.com/dotnet/fsharp/pull/18878))
+* Support `CallerArgumentExpression` ([Language Suggestion #966](https://github.com/fsharp/fslang-suggestions/issues/966), [PR #17519](https://github.com/dotnet/fsharp/pull/17519))
 
 ### Fixed
 
@@ -42,6 +43,7 @@
 * Parser: Capture named fields block separators. ([PR #18857](https://github.com/dotnet/fsharp/pull/18857))
 * Type checker: use inner expr range in upcast constraints errors ([PR #18850](https://github.com/dotnet/fsharp/pull/18850))
 * Import `IEnumerable` as `seq`. ([PR #18865](https://github.com/dotnet/fsharp/pull/18865))
+* `assert` keyword enhancement ([Issue #18489](https://github.com/dotnet/fsharp/issues/18489), [PR #17519](https://github.com/dotnet/fsharp/pull/17519))
 
 ### Breaking Changes
 

docs/release-notes/.Language/preview.md

@@ -11,6 +11,7 @@
 * Allow `let!`, `use!`, `and!` type annotations without requiring parentheses (([PR #18508](https://github.com/dotnet/fsharp/pull/18508) and [PR #18682](https://github.com/dotnet/fsharp/pull/18682)))
 * Exception names are now validated for illegal characters using the same mechanism as types/modules/namespaces ([Issue #18763](https://github.com/dotnet/fsharp/issues/18763))
 * Support tail calls in computation expressions ([PR #18804](https://github.com/dotnet/fsharp/pull/18804))
+* Support `CallerArgumentExpression` ([Language Suggestion #966](https://github.com/fsharp/fslang-suggestions/issues/966), [PR #17519](https://github.com/dotnet/fsharp/pull/17519))
 
 ### Fixed
 

src/Compiler/Checking/CheckBasics.fs

@@ -335,6 +335,8 @@ type TcFileState =
 
       // forward call
       TcComputationExpression: TcFileState -> TcEnv -> OverallTy -> UnscopedTyparEnv -> range * Expr * TType * SynExpr -> Expr * UnscopedTyparEnv
+
+      SourceText: ISourceText option
     }
 
     /// Create a new compilation environment
@@ -344,7 +346,8 @@ type TcFileState =
           tcSimplePats,
           tcSequenceExpressionEntry,
           tcArrayOrListSequenceExpression,
-          tcComputationExpression) =
+          tcComputationExpression,
+          sourceText: ISourceText option) =
 
         let niceNameGen = NiceNameGenerator()
         let infoReader = InfoReader(g, amap)
@@ -376,6 +379,7 @@ type TcFileState =
           TcSequenceExpressionEntry = tcSequenceExpressionEntry
           TcArrayOrListComputedExpression = tcArrayOrListSequenceExpression
           TcComputationExpression = tcComputationExpression
+          SourceText = sourceText
         }
 
     override _.ToString() = "<cenv>"

src/Compiler/Checking/CheckBasics.fsi

@@ -313,6 +313,9 @@ type TcFileState =
                 -> UnscopedTyparEnv
                 -> range * Expr * TType * SynExpr
                 -> Expr * UnscopedTyparEnv
+
+        /// The impl file content. Used to support `CallerArgumentExpression` feature.
+        SourceText: ISourceText option
     }
 
     static member Create:
@@ -356,5 +359,6 @@ type TcFileState =
                 -> OverallTy
                 -> UnscopedTyparEnv
                 -> range * Expr * TType * SynExpr
-                -> Expr * UnscopedTyparEnv) ->
+                -> Expr * UnscopedTyparEnv) *
+        sourceText: ISourceText option ->
             TcFileState

src/Compiler/Checking/CheckDeclarations.fs

@@ -5766,7 +5766,8 @@ let CheckOneImplFile
         env,
         rootSigOpt: ModuleOrNamespaceType option,
         synImplFile,
-        diagnosticOptions) =
+        diagnosticOptions,
+        sourceText: ISourceText option) =
 
     let (ParsedImplFileInput (fileName, isScript, qualNameOfFile, _, implFileFrags, isLastCompiland, _, _)) = synImplFile
     let infoReader = InfoReader(g, amap)
@@ -5789,7 +5790,8 @@ let CheckOneImplFile
                 tcSimplePats=TcSimplePats,
                 tcSequenceExpressionEntry=TcSequenceExpressionEntry,
                 tcArrayOrListSequenceExpression=TcArrayOrListComputedExpression,
-                tcComputationExpression=TcComputationExpression)    
+                tcComputationExpression=TcComputationExpression,
+                sourceText=sourceText)    
 
         let envinner, moduleTyAcc = MakeInitialEnv env 
 
@@ -5934,7 +5936,8 @@ let CheckOneSigFile (g, amap, thisCcu, checkForErrors, conditionalDefines, tcSin
             tcSimplePats=TcSimplePats,
             tcSequenceExpressionEntry=TcSequenceExpressionEntry,
             tcArrayOrListSequenceExpression=TcArrayOrListComputedExpression,
-            tcComputationExpression=TcComputationExpression)
+            tcComputationExpression=TcComputationExpression,
+            sourceText=None)
 
     let envinner, moduleTyAcc = MakeInitialEnv tcEnv 
     let m = sigFile.QualifiedName.Range

src/Compiler/Checking/CheckDeclarations.fsi

@@ -59,7 +59,8 @@ val CheckOneImplFile:
     TcEnv *
     ModuleOrNamespaceType option *
     ParsedImplFileInput *
-    FSharpDiagnosticOptions ->
+    FSharpDiagnosticOptions *
+    ISourceText option ->
         Cancellable<TopAttribs * CheckedImplFile * TcEnv * bool>
 
 val CheckOneSigFile:

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -7727,9 +7727,23 @@ and TcConstExpr cenv (overallTy: OverallTy) env m tpenv c =
 // Check an 'assert x' expression.
 and TcAssertExpr cenv overallTy env (m: range) tpenv x =
     let synm = m.MakeSynthetic() // Mark as synthetic so the language service won't pick it up.
+
+    // wrap an extra parentheses so 'assert(x=1) isn't considered a named argument to a method call
+    let arg1Expr = SynExpr.Paren (x, range0, None, synm)
+
+    let argExpr = 
+        match cenv.SourceText with
+        | Some sourceText when cenv.g.langVersion.SupportsFeature LanguageFeature.SupportCallerArgumentExpression -> 
+            let mArgExpr = x.Range.MakeSynthetic()
+            let code = sourceText.GetSubTextFromRange mArgExpr
+            if System.String.IsNullOrEmpty code then arg1Expr
+            else 
+                let arg2Expr = SynExpr.Const (SynConst.String (code, SynStringKind.Regular, mArgExpr), mArgExpr)
+                SynExpr.Tuple(false, [arg1Expr; arg2Expr], [], mArgExpr)
+        | _ -> arg1Expr
+
     let callDiagnosticsExpr = SynExpr.App (ExprAtomicFlag.Atomic, false, mkSynLidGet synm ["System";"Diagnostics";"Debug"] "Assert",
-                                           // wrap an extra parentheses so 'assert(x=1) isn't considered a named argument to a method call
-                                           SynExpr.Paren (x, range0, None, synm), synm)
+                                           argExpr, synm)
 
     TcExpr cenv overallTy env tpenv callDiagnosticsExpr
 
@@ -10309,8 +10323,18 @@ and TcMethodApplication
     /// STEP 5. Build the argument list. Adjust for optional arguments, byref arguments and coercions.
 
     let objArgPreBinder, objArgs, allArgsPreBinders, allArgs, allArgsCoerced, optArgPreBinder, paramArrayPreBinders, outArgExprs, outArgTmpBinds =
+
+        // We apply CallerArgumentExpression to optional parameters only when the method call has syntactic arguments.
+        // Otherwise, we cannot get the range of the argument. The argument range will be the method name range.
+        //      System.ArgumentException.ThrowIfNullOrEmpty(null)              <-- Can get the argument text through its range
+        //      (System.ArgumentException.ThrowIfNullOrEmpty) null             <-- Cannot get the right text
+        //      System.ArgumentException.ThrowIfNullOrEmpty <| null            <-- Cannot get the right text
+        //      null |> System.ArgumentException.ThrowIfNullOrEmpty            <-- Cannot get the right text
+        //      let f = System.ArgumentException.ThrowIfNullOrEmpty in f(null) <-- Cannot get the right text
+        let canApplyCallerArgumentExpression = curriedCallerArgsOpt.IsSome
+
         let tcVal = LightweightTcValForUsingInBuildMethodCall g
-        AdjustCallerArgs tcVal TcFieldInit env.eCallerMemberName cenv.infoReader ad finalCalledMeth objArgs lambdaVars mItem mMethExpr
+        AdjustCallerArgs tcVal TcFieldInit cenv.infoReader ad finalCalledMeth objArgs lambdaVars mItem mMethExpr (env.eCallerMemberName, cenv.SourceText, canApplyCallerArgumentExpression)
 
     // Record the resolution of the named argument for the Language Service
     allArgs |> List.iter (fun assignedArg ->