Allow interpolated strings in constant expressions

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

@@ -1,6 +1,7 @@
 ### Added
 
 * F# Interactive gains a JSON-RPC server mode, `--fsi-server-jsonrpc:<pipe name>`, in which a host submits interactions over a named pipe and receives structured results — diagnostics with positions, escaping exceptions, the values each interaction bound, and the session's own process id — instead of recovering them by looking for a `SERVER-PROMPT>` marker in the output text. Program output continues to flow through the redirected console streams. The pipe admits only the user running the session; `--fsi-server-client-pid:<pid>` names the host process whose exit ends the session. `FsiEvaluationSession` exposes both options as `JsonRpcServerPipeName` and `JsonRpcClientProcessId`. The mode is part of the .NET fsi only. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))
+* Added the `ConstantInterpolatedStrings` language feature (`--langversion:preview`): an interpolated string whose holes are non-null constant strings without alignment or format specifiers is a constant expression, so `[<Literal>]` values, attribute arguments and type provider static arguments accept it instead of reporting FS0267. ([Suggestion #1347](https://github.com/fsharp/fslang-suggestions/issues/1347), [RFC FS-1352](https://github.com/fsharp/fslang-design/blob/main/RFCs/FS-1352-interpolated-strings-in-constant-expressions.md), [PR #20753](https://github.com/dotnet/fsharp/pull/20753))
 
 ### Fixed
 

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

@@ -4,6 +4,8 @@ Features assigned to F# 11.2 are listed in [11.2](https://fsharp.github.io/fshar
 
 ### Added
 
+* Allow interpolated strings in constant expressions: when each hole is a non-null constant string without alignment or format specifiers, as in C#, an interpolated string can define a `[<Literal>]` value, an attribute argument or a type provider static argument, such as `[<Obsolete($"Use {nameof getItemV2} instead")>]` (`ConstantInterpolatedStrings` preview feature). Outside these contexts interpolated strings, and their quotations, are unchanged. ([Suggestion #1347](https://github.com/fsharp/fslang-suggestions/issues/1347), [RFC FS-1352](https://github.com/fsharp/fslang-design/blob/main/RFCs/FS-1352-interpolated-strings-in-constant-expressions.md), [PR #20753](https://github.com/dotnet/fsharp/pull/20753))
+
 ### Fixed
 
 ### Changed

src/Compiler/Checking/CheckBasics.fs

@@ -247,6 +247,9 @@ type TcEnv =
 
       eInNameOf: bool
 
+      /// Checking an expression that must evaluate to a constant: a literal, an attribute argument or a static argument.
+      eInConstantContext: bool
+
       /// Are we checking the body of an object expression? Such a body has family access to the
       /// implemented type, but its closures are not nested under that type, so they cannot keep it (#5302).
       eInObjectExpr: bool

src/Compiler/Checking/CheckBasics.fsi

@@ -137,6 +137,9 @@ type TcEnv =
         /// Resolving a nameof operand, rather than an executable expression.
         eInNameOf: bool
 
+        /// Checking an expression that must evaluate to a constant: a literal, an attribute argument or a static argument.
+        eInConstantContext: bool
+
         /// Are we checking the body of an object expression? Such a body has family access to the
         /// implemented type, but its closures are not nested under that type, so they cannot keep it (#5302).
         eInObjectExpr: bool

src/Compiler/Checking/CheckDeclarations.fs

@@ -6097,6 +6097,7 @@ let emptyTcEnv g =
       eIsIndexerSetter = false
       eIsControlFlow = false
       eInNameOf = false
+      eInConstantContext = false
       eInObjectExpr = false
       eCaughtExceptionVal = ValueNone
       eCachedImplicitYieldExpressions = HashMultiMap(HashIdentity.Structural, useConcurrentDictionary = true)

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -5048,7 +5048,7 @@ and TcStaticConstantParameter (cenv: cenv) (env: TcEnv) tpenv kind (StripParenTy
     | SynType.StaticConstantExpr(e, _ ) ->
 
         // If an error occurs, don't try to recover, since the constant expression will be nothing like what we need
-        let te, tpenv' = TcExprNoRecover cenv (MustEqual kind) env tpenv e
+        let te, tpenv' = TcExprNoRecover cenv (MustEqual kind) { env with eInConstantContext = true } tpenv e
 
         // Evaluate the constant expression using static attribute argument rules
         let te = EvalLiteralExprOrAttribArg g te
@@ -7803,6 +7803,44 @@ and TcInterpolatedStringViaConcat (cenv: cenv, overallTy: OverallTy, env: TcEnv,
 
     TcPropagatingExprLeafThenConvert cenv overallTy g.string_ty env m (fun () -> resultExpr, tpenv)
 
+/// Fold a string-typed interpolated string in a constant context to its text (RFC FS-1352). Each hole must be
+/// a non-null constant string without alignment or format specifiers.
+and TcConstantInterpolatedString (cenv: cenv, overallTy: OverallTy, env: TcEnv, m: range, tpenv: UnscopedTyparEnv, parts: SynInterpolatedStringPart list) =
+    let g = cenv.g
+    checkLanguageFeatureAndRecover g.langVersion LanguageFeature.ConstantInterpolatedStrings m
+
+    let holeText (fill: Expr) (formatting: SynInterpolationFormatting) (mHole: range) =
+        let invalidHole () =
+            errorR (Error(FSComp.SR.tcConstantInterpolatedStringHole (), mHole))
+            ValueNone
+
+        match formatting with
+        | SynInterpolationFormatting.DotNet(None, None) when isStringTy g (tyOfExpr g fill) ->
+            match EvalLiteralExprOrAttribArg g fill with
+            | Expr.Const(Const.String text, _, _) -> ValueSome text
+            | Expr.Const(Const.Zero, _, _) -> invalidHole ()
+            | _ -> ValueNone // EvalLiteralExprOrAttribArg has reported that the hole is not a constant
+        | _ -> invalidHole ()
+
+    let text = Text.StringBuilder()
+    let mutable tpenvAcc = tpenv
+    // Only the first hole that breaks a rule is reported; later holes are still type-checked.
+    let mutable holesAreConstant = true
+
+    for part in parts do
+        match part with
+        | SynInterpolatedStringPart.String(s, _) -> text.Append(s.Replace("%%", "%")) |> ignore
+        | SynInterpolatedStringPart.FillExpr(synFill, formatting) ->
+            let fill, tpenvAfter = TcExprFlex2 cenv (NewInferenceType g) env false tpenvAcc synFill
+            tpenvAcc <- tpenvAfter
+
+            if holesAreConstant then
+                match holeText fill formatting synFill.Range with
+                | ValueSome hole -> text.Append(hole: string) |> ignore
+                | ValueNone -> holesAreConstant <- false
+
+    TcPropagatingExprLeafThenConvert cenv overallTy g.string_ty env m (fun () -> mkString g m (text.ToString()), tpenvAcc)
+
 /// Check an interpolated string expression
 and [<TailCall>] warnForFunctionValuesInFillExprs (g: TcGlobals) argTys synFillExprs =
     match argTys, synFillExprs with
@@ -7950,6 +7988,8 @@ and TcInterpolatedStringExpr cenv (overallTy: OverallTy) env m tpenv (parts: Syn
             else
                 let str = mkString g m printfFormatString
                 mkCallNewFormat g m printerTy printerArgTy printerResidueTy printerResultTy printerTupleTy str, tpenv
+        elif isString && env.eInConstantContext then
+            TcConstantInterpolatedString (cenv, overallTy, env, m, tpenv, parts)
         elif isString then
             // String-typed interpolation: lower to a reflection-free System.String.Concat of the parts,
             // type-checking each hole in place (no separate batch, no flat fill-expression list).
@@ -11806,7 +11846,7 @@ and TcLiteral (cenv: cenv) overallTy env tpenv (attrs, synLiteralValExpr) =
         hasFlag valFlags WellKnownValAttributes.LiteralAttribute
 
     if hasLiteralAttr then
-        let literalValExpr, _ = TcExpr cenv (MustEqual overallTy) env tpenv synLiteralValExpr
+        let literalValExpr, _ = TcExpr cenv (MustEqual overallTy) { env with eInConstantContext = true } tpenv synLiteralValExpr
         match EvalLiteralExprOrAttribArg g literalValExpr with
         | Expr.Const (c, _, ty) ->
             if c = Const.Zero && isStructTy g ty then
@@ -12012,7 +12052,7 @@ and TcAttributeEx canFail (cenv: cenv) (env: TcEnv) attrTgt attrEx (synAttr: Syn
                 let meths = minfos |> List.map (fun minfo -> minfo, None)
                 let afterResolution = ForNewConstructors cenv.tcSink env tyId.idRange methodName minfos
                 let (expr, attributeAssignedNamedItems, _), _ =
-                  TcMethodApplication true cenv env tpenv None [] mAttr mAttr methodName None ad PossiblyMutates false meths afterResolution NormalValUse [arg] (MustEqual ty) None []
+                  TcMethodApplication true cenv { env with eInConstantContext = true } tpenv None [] mAttr mAttr methodName None ad PossiblyMutates false meths afterResolution NormalValUse [arg] (MustEqual ty) None []
 
                 UnifyTypes cenv env mAttr ty (tyOfExpr g expr)
 

src/Compiler/FSComp.txt

@@ -1806,3 +1806,5 @@ featureTypeArgumentDependencyOrdering,"ordering explicit type arguments by their
 3923,tcMethodRequiresNamedArguments,"The method '%s' requires named arguments. Use named-argument syntax, e.g. 'MethodName(argumentName = value)'."
 3924,chkNativePtrStackallocInHandler,"'NativePtr.stackalloc' cannot be used inside the 'with' handler, filter or 'finally' block of a 'try' expression. The 'localloc' IL instruction this emits is rejected inside an exception-handling region, producing a 'System.InvalidProgramException' when the method is loaded."
 featureReraiseInComputationExpressions,"calls to 'reraise' in a computation expression handler"
+3925,tcConstantInterpolatedStringHole,"This interpolated string must be a constant, so each hole must be a non-null constant expression of type 'string' without alignment or format specifiers."
+featureConstantInterpolatedStrings,"interpolated strings in constant expressions"

src/Compiler/Facilities/LanguageFeatures.fs

@@ -69,6 +69,7 @@ type LanguageFeature =
     | ErrorOnBitwiseOpsOnNonIntegralEnums
     | OptimizeClosureIfNotInlined
     | ReraiseInComputationExpressions
+    | ConstantInterpolatedStrings
 
 /// LanguageVersion management
 type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
@@ -178,6 +179,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
                 // F# preview
                 // Unfinished features that still need work before they can be assigned a release language version.
                 LanguageFeature.FromEndSlicing, previewVersion // Unfinished features --- needs work
+                LanguageFeature.ConstantInterpolatedStrings, previewVersion
             ]
 
     static let defaultLanguageVersion = LanguageVersion("default")
@@ -327,6 +329,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
         | LanguageFeature.ErrorOnBitwiseOpsOnNonIntegralEnums -> FSComp.SR.featureErrorOnBitwiseOpsOnNonIntegralEnums ()
         | LanguageFeature.OptimizeClosureIfNotInlined -> FSComp.SR.featureOptimizeClosureIfNotInlined ()
         | LanguageFeature.ReraiseInComputationExpressions -> FSComp.SR.featureReraiseInComputationExpressions ()
+        | LanguageFeature.ConstantInterpolatedStrings -> FSComp.SR.featureConstantInterpolatedStrings ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -60,6 +60,7 @@ type LanguageFeature =
     | ErrorOnBitwiseOpsOnNonIntegralEnums
     | OptimizeClosureIfNotInlined
     | ReraiseInComputationExpressions
+    | ConstantInterpolatedStrings
 
 /// LanguageVersion management
 type LanguageVersion =