Allow interpolated strings in constant expressions

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, such as `[<Literal>] let Items = $"{Root}/items"` and `[<Obsolete($"Use {nameof f} instead")>]`, when each hole is a non-null constant string without alignment or format specifier (`ConstantInterpolatedStrings` preview feature). ([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,8 @@ type TcEnv =
 
       eInNameOf: bool
 
+      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,8 @@ type TcEnv =
         /// Resolving a nameof operand, rather than an executable expression.
         eInNameOf: bool
 
+        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

@@ -6055,6 +6055,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

@@ -4247,6 +4247,18 @@ let EliminateNullnessFromInputType (g: TcGlobals) (inputTy: TType) (pat: Pattern
     | None -> eliminateNull inputTy pat
     | _ -> inputTy
 
+let tryEvalConstant (g: TcGlobals) (expr: Expr) =
+    try
+        suppressErrorReporting (fun () -> ValueSome(EvalLiteralExprOrAttribArg g expr))
+    with
+    | ReportedError _
+    | :? DivideByZeroException -> ValueNone
+
+let tryConstantHoleText (g: TcGlobals) (formatting: SynInterpolationFormatting) (hole: Expr) =
+    match formatting, tryEvalConstant g hole with
+    | SynInterpolationFormatting.DotNet(None, None), ValueSome(Expr.Const(Const.String text, _, _)) -> ValueSome text
+    | _ -> ValueNone
+
 //-------------------------------------------------------------------------
 // Checking types and type constraints
 //-------------------------------------------------------------------------
@@ -5093,7 +5105,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
@@ -7864,6 +7876,27 @@ and TcInterpolatedStringViaConcat (cenv: cenv, overallTy: OverallTy, env: TcEnv,
 
     TcPropagatingExprLeafThenConvert cenv overallTy g.string_ty env m (fun () -> resultExpr, tpenv)
 
+and TcConstantInterpolatedString (cenv: cenv, overallTy: OverallTy, env: TcEnv, m: range, tpenv: UnscopedTyparEnv, parts: SynInterpolatedStringPart list) =
+    let g = cenv.g
+
+    let partTexts, tpenv =
+        (tpenv, parts) ||> List.mapFold (fun tpenv part ->
+            match part with
+            | SynInterpolatedStringPart.String(text, _) -> Choice1Of2(text.Replace("%%", "%")), tpenv
+            | SynInterpolatedStringPart.FillExpr(synFill, formatting) ->
+                let hole, tpenv = TcExprFlex2 cenv (NewInferenceType g) env false tpenv synFill
+
+                match tryConstantHoleText g formatting hole with
+                | ValueSome text -> Choice1Of2 text, tpenv
+                | ValueNone -> Choice2Of2(mkCallStringOperator g synFill.Range (tyOfExpr g hole) hole), tpenv)
+
+    let expr =
+        match partTexts |> List.tryPick (function Choice2Of2 nonConstant -> Some nonConstant | Choice1Of2 _ -> None) with
+        | Some nonConstant -> nonConstant
+        | None -> mkString g m (partTexts |> List.map (function Choice1Of2 text -> text | Choice2Of2 _ -> "") |> String.concat "")
+
+    TcPropagatingExprLeafThenConvert cenv overallTy g.string_ty env m (fun () -> expr, tpenv)
+
 /// Check an interpolated string expression
 and [<TailCall>] warnForFunctionValuesInFillExprs (g: TcGlobals) argTys synFillExprs =
     match argTys, synFillExprs with
@@ -8010,6 +8043,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 && g.langVersion.SupportsFeature LanguageFeature.ConstantInterpolatedStrings then
+            TcConstantInterpolatedString (cenv, overallTy, env, m, tpenv, parts)
         elif isString then
             // String-typed interpolation: concatenate rendered parts,
             // type-checking each hole in place (no separate batch, no flat fill-expression list).
@@ -11841,7 +11876,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
@@ -12047,7 +12082,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

@@ -1804,3 +1804,4 @@ featureTypeArgumentDependencyOrdering,"ordering explicit type arguments by their
 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."
 3925,optInlineMemberCannotUseBase,"An inline member cannot use 'base' or protected members unless those uses can be eliminated before the member itself is inlined."
 featureReraiseInComputationExpressions,"calls to 'reraise' in a computation expression handler"
+featureConstantInterpolatedStrings,"interpolated strings in constant expressions"

src/Compiler/Facilities/LanguageFeatures.fs

@@ -65,6 +65,7 @@ type LanguageFeature =
     | ErrorOnBitwiseOpsOnNonIntegralEnums
     | OptimizeClosureIfNotInlined
     | ReraiseInComputationExpressions
+    | ConstantInterpolatedStrings
 
 /// LanguageVersion management
 type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
@@ -164,6 +165,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")
@@ -308,6 +310,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

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

tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj

@@ -386,6 +386,7 @@
     <Compile Include="Language\CompilerDirectiveTests.fs" />
     <Compile Include="Language\CodeQuotationTests.fs" />
     <Compile Include="Language\InterpolatedStringsTests.fs" />
+    <Compile Include="Language\ConstantInterpolatedStringsTests.fs" />
     <Compile Include="Language\ComputationExpressionTests.fs" />
     <Compile Include="Language\CE_PipelineRange19550.fs" />
     <Compile Include="Language\StateMachineTests.fs" />