[WIP] Add --disableLanguageFeature CLI switch and MSBuild property to selectively disable language features

.github/copilot-instructions.md

@@ -33,6 +33,21 @@ Always run the core command. Always verify exit codes. No assumptions.
 ```
 Non‑zero → classify & stop.
 
+### CRITICAL TEST EXECUTION RULES
+**ALWAYS** run tests before claiming success. **NEVER** mark work complete without verified passing tests.
+
+When running tests, **ALWAYS** report:
+- Total number of tests executed
+- Number passed / failed / skipped
+- Execution duration
+- Example: "Ran 5 tests: 5 passed, 0 failed, 0 skipped. Duration: 4.2 seconds"
+
+**ASSUME YOUR CODE IS THE PROBLEM**: When tests fail, ALWAYS assume your implementation is incorrect FIRST. Only after thorough investigation with evidence should you consider other causes like build issues or test infrastructure problems.
+
+**UNDERSTAND WHAT YOU'RE TESTING**: Before writing tests, understand exactly what behavior the feature controls. Research the codebase to see how the feature is actually used, not just how you think it should work.
+
+**TEST INCREMENTALLY**: After each code change, immediately run the relevant tests to verify the change works as expected. Don't accumulate multiple changes before testing.
+
 ## 2. Bootstrap (Failure Detection Only)
 Two-phase build. No separate bootstrap command.  
 Early proto/tool errors (e.g. "Error building tools") → `BootstrapFailure` (capture key lines). Stop.

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))
+* Add `--disableLanguageFeature` CLI switch and MSBuild property to selectively disable specific F# language features on a per-project basis. ([PR #TBD](https://github.com/dotnet/fsharp/pull/TBD))
 
 ### Fixed
 

src/Compiler/Driver/CompilerConfig.fs

@@ -644,6 +644,8 @@ type TcConfigBuilder =
 
         mutable langVersion: LanguageVersion
 
+        mutable disabledLanguageFeatures: Set<LanguageFeature>
+
         mutable xmlDocInfoLoader: IXmlDocumentationInfoLoader option
 
         mutable exiter: Exiter
@@ -836,6 +838,7 @@ type TcConfigBuilder =
             pathMap = PathMap.empty
             applyLineDirectives = true
             langVersion = LanguageVersion.Default
+            disabledLanguageFeatures = Set.empty
             implicitIncludeDir = implicitIncludeDir
             defaultFSharpBinariesDir = defaultFSharpBinariesDir
             reduceMemoryUsage = reduceMemoryUsage
@@ -1421,6 +1424,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.CloneToBuilder() =
         { data with
             conditionalDefines = data.conditionalDefines
+            disabledLanguageFeatures = data.disabledLanguageFeatures
         }
 
     member tcConfig.ComputeCanContainEntryPoint(sourceFiles: string list) =

src/Compiler/Driver/CompilerConfig.fsi

@@ -512,6 +512,8 @@ type TcConfigBuilder =
 
         mutable langVersion: LanguageVersion
 
+        mutable disabledLanguageFeatures: Set<LanguageFeature>
+
         mutable xmlDocInfoLoader: IXmlDocumentationInfoLoader option
 
         mutable exiter: Exiter

src/Compiler/Driver/CompilerOptions.fs

@@ -1177,11 +1177,28 @@ let languageFlags tcConfigB =
         CompilerOption(
             "langversion",
             tagLangVersionValues,
-            OptionString(fun switch -> tcConfigB.langVersion <- setLanguageVersion switch),
+            OptionString(fun switch ->
+                let newVersion = setLanguageVersion switch
+                // Preserve disabled features when updating version
+                tcConfigB.langVersion <- newVersion.WithDisabledFeatures(Set.toArray tcConfigB.disabledLanguageFeatures)),
             None,
             Some(FSComp.SR.optsSetLangVersion ())
         )
 
+        // -disableLanguageFeature:<string>  Disable a specific language feature by name (repeatable)
+        CompilerOption(
+            "disableLanguageFeature",
+            tagString,
+            OptionStringList(fun featureName ->
+                match LanguageVersion.TryParseFeature(featureName) with
+                | Some feature ->
+                    tcConfigB.disabledLanguageFeatures <- Set.add feature tcConfigB.disabledLanguageFeatures
+                    tcConfigB.langVersion <- tcConfigB.langVersion.WithDisabledFeatures(Set.toArray tcConfigB.disabledLanguageFeatures)
+                | None -> error (Error(FSComp.SR.optsUnrecognizedLanguageFeature featureName, rangeCmdArgs))),
+            None,
+            Some(FSComp.SR.optsDisableLanguageFeature ())
+        )
+
         CompilerOption(
             "checked",
             tagNone,

src/Compiler/FSComp.txt

@@ -1570,6 +1570,8 @@ optsCheckNulls,"Enable nullness declarations and checks (%s by default)"
 fSharpBannerVersion,"%s for F# %s"
 optsGetLangVersions,"Display the allowed values for language version."
 optsSetLangVersion,"Specify language version such as 'latest' or 'preview'."
+optsDisableLanguageFeature,"Disable a specific language feature by name."
+3879,optsUnrecognizedLanguageFeature,"Unrecognized language feature name: '%s'. Use a valid feature name such as 'NameOf' or 'StringInterpolation'."
 optsSupportedLangVersions,"Supported language versions:"
 optsStrictIndentation,"Override indentation rules implied by the language version (%s by default)"
 nativeResourceFormatError,"Stream does not begin with a null resource and is not in '.RES' format."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -107,7 +107,7 @@ type LanguageFeature =
     | ReturnFromFinal
 
 /// LanguageVersion management
-type LanguageVersion(versionText) =
+type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
 
     // When we increment language versions here preview is higher than current RTM version
     static let languageVersion46 = 4.6m
@@ -279,11 +279,19 @@ type LanguageVersion(versionText) =
 
     let specifiedString = versionToString specified
 
+    let disabledFeatures: LanguageFeature array = defaultArg disabledFeaturesArray [||]
+
     /// Check if this feature is supported by the selected langversion
     member _.SupportsFeature featureId =
-        match features.TryGetValue featureId with
-        | true, v -> v <= specified
-        | false, _ -> false
+        if Array.contains featureId disabledFeatures then
+            false
+        else
+            match features.TryGetValue featureId with
+            | true, v -> v <= specified
+            | false, _ -> false
+
+    /// Create a new LanguageVersion with updated disabled features
+    member _.WithDisabledFeatures(disabled: LanguageFeature array) = LanguageVersion(versionText, disabled)
 
     /// Has preview been explicitly specified
     member _.IsExplicitlySpecifiedAs50OrBefore() =
@@ -422,6 +430,24 @@ type LanguageVersion(versionText) =
         | true, v -> versionToString v
         | _ -> invalidArg "feature" "Internal error: Unable to find feature."
 
+    /// Try to parse a feature name string to a LanguageFeature option using reflection
+    static member TryParseFeature(featureName: string) =
+        let normalized = featureName.Trim()
+
+        let bindingFlags =
+            System.Reflection.BindingFlags.Public
+            ||| System.Reflection.BindingFlags.NonPublic
+
+        Microsoft.FSharp.Reflection.FSharpType.GetUnionCases(typeof<LanguageFeature>, bindingFlags)
+        |> Array.tryFind (fun case -> System.String.Equals(case.Name, normalized, System.StringComparison.OrdinalIgnoreCase))
+        |> Option.bind (fun case ->
+            let union =
+                Microsoft.FSharp.Reflection.FSharpValue.MakeUnion(case, [||], bindingFlags)
+
+            match box union with
+            | null -> None
+            | obj -> Some(obj :?> LanguageFeature))
+
     override x.Equals(yobj: obj) =
         match yobj with
         | :? LanguageVersion as y -> x.SpecifiedVersion = y.SpecifiedVersion

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -101,7 +101,7 @@ type LanguageFeature =
 type LanguageVersion =
 
     /// Create a LanguageVersion management object
-    new: string -> LanguageVersion
+    new: string * ?disabledFeaturesArray: LanguageFeature array -> LanguageVersion
 
     /// Get the list of valid versions
     static member ContainsVersion: string -> bool
@@ -115,6 +115,9 @@ type LanguageVersion =
     /// Does the selected LanguageVersion support the specified feature
     member SupportsFeature: LanguageFeature -> bool
 
+    /// Create a new LanguageVersion with updated disabled features
+    member WithDisabledFeatures: LanguageFeature array -> LanguageVersion
+
     /// Get the list of valid versions
     static member ValidVersions: string[]
 
@@ -136,4 +139,7 @@ type LanguageVersion =
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString: feature: LanguageFeature -> string
 
+    /// Try to parse a feature name string to a LanguageFeature option
+    static member TryParseFeature: featureName: string -> LanguageFeature option
+
     static member Default: LanguageVersion