Add --disableLanguageFeature CLI switch and MSBuild property to selectively disable language features (#19167)

Author: Copilot

.github/copilot-instructions.md

@@ -62,6 +62,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/10.0.200.md

@@ -0,0 +1,3 @@
+### Added
+
+* Add `--disableLanguageFeature` CLI switch and MSBuild property to selectively disable specific F# language features on a per-project basis. ([PR #19167](https://github.com/dotnet/fsharp/pull/19167))

src/Compiler/Driver/CompilerConfig.fs

@@ -637,6 +637,8 @@ type TcConfigBuilder =
 
         mutable langVersion: LanguageVersion
 
+        mutable disabledLanguageFeatures: Set<LanguageFeature>
+
         mutable xmlDocInfoLoader: IXmlDocumentationInfoLoader option
 
         mutable exiter: Exiter
@@ -827,6 +829,7 @@ type TcConfigBuilder =
             pathMap = PathMap.empty
             applyLineDirectives = true
             langVersion = LanguageVersion.Default
+            disabledLanguageFeatures = Set.empty
             implicitIncludeDir = implicitIncludeDir
             defaultFSharpBinariesDir = defaultFSharpBinariesDir
             reduceMemoryUsage = reduceMemoryUsage
@@ -1402,6 +1405,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

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

src/Compiler/Driver/CompilerOptions.fs

@@ -1168,11 +1168,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

@@ -1555,6 +1555,7 @@ 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."
 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."
@@ -1801,4 +1802,5 @@ featureAllowLetOrUseBangTypeAnnotationWithoutParens,"Allow let! and use! type an
 3878,tcAttributeIsNotValidForUnionCaseWithFields,"This attribute is not valid for use on union cases with fields."
 3879,xmlDocNotFirstOnLine,"XML documentation comments should be the first non-whitespace text on a line."
 featureReturnFromFinal,"Support for ReturnFromFinal/YieldFromFinal in computation expressions to enable tailcall optimization when available on the builder."
-3879,optsLangVersionOutOfSupport,"Language version '%s' is out of support. The last .NET SDK supporting it is available at https://dotnet.microsoft.com/en-us/download/dotnet/%s"
+3880,optsLangVersionOutOfSupport,"Language version '%s' is out of support. The last .NET SDK supporting it is available at https://dotnet.microsoft.com/en-us/download/dotnet/%s"
+3881,optsUnrecognizedLanguageFeature,"Unrecognized language feature name: '%s'. Use a valid feature name such as 'NameOf' or 'StringInterpolation'."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -106,7 +106,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
@@ -287,11 +287,22 @@ type LanguageVersion(versionText) =
 
     let specifiedString = versionToString specified
 
+    let disabledFeatures: LanguageFeature array = defaultArg disabledFeaturesArray [||]
+
+    /// Get the disabled features
+    member _.DisabledFeatures = disabledFeatures
+
     /// 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() =
@@ -436,11 +447,38 @@ 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
+        | :? LanguageVersion as y ->
+            x.SpecifiedVersion = y.SpecifiedVersion
+            && x.DisabledFeatures.Length = y.DisabledFeatures.Length
+            && (x.DisabledFeatures, y.DisabledFeatures) ||> Array.forall2 (=)
         | _ -> false
 
-    override x.GetHashCode() = hash x.SpecifiedVersion
+    override x.GetHashCode() =
+        let mutable h = hash x.SpecifiedVersion
+
+        for f in x.DisabledFeatures do
+            h <- h ^^^ hash f
+
+        h
 
     static member Default = defaultLanguageVersion

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -100,7 +100,7 @@ type LanguageFeature =
 type LanguageVersion =
 
     /// Create a LanguageVersion management object
-    new: string -> LanguageVersion
+    new: string * ?disabledFeaturesArray: LanguageFeature array -> LanguageVersion
 
     /// Is the selected LanguageVersion valid
     static member ContainsVersion: string -> bool
@@ -117,6 +117,12 @@ type LanguageVersion =
     /// Does the selected LanguageVersion support the specified feature
     member SupportsFeature: LanguageFeature -> bool
 
+    /// Get the disabled features
+    member DisabledFeatures: LanguageFeature array
+
+    /// Create a new LanguageVersion with updated disabled features
+    member WithDisabledFeatures: LanguageFeature array -> LanguageVersion
+
     /// Get the list of valid versions
     static member ValidVersions: string[]
 
@@ -138,4 +144,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

src/Compiler/Service/IncrementalBuild.fs

@@ -556,7 +556,7 @@ type FrameworkImportsCache(size) =
         // for each cached project.  So here we create a new tcGlobals, with the existing framework values
         // and updated realsig and langversion
         let tcGlobals =
-            if tcGlobals.langVersion.SpecifiedVersion <> tcConfig.langVersion.SpecifiedVersion
+            if tcGlobals.langVersion <> tcConfig.langVersion
                 || tcGlobals.realsig <> tcConfig.realsig then
                     TcGlobals(
                         tcGlobals.compilingFSharpCore,

src/Compiler/Service/TransparentCompiler.fs

@@ -490,7 +490,12 @@ type internal TransparentCompiler
 
         let applyCompilerOptions tcConfig =
             let fsiCompilerOptions = GetCoreFsiCompilerOptions tcConfig
-            ParseCompilerOptions(ignore, fsiCompilerOptions, otherOptions)
+
+            try
+                ParseCompilerOptions(ignore, fsiCompilerOptions, otherOptions)
+            with
+            | :? OperationCanceledException -> reraise ()
+            | exn -> errorRecovery exn range0
 
         let closure =
             LoadClosure.ComputeClosureOfScriptText(
@@ -900,8 +905,16 @@ type internal TransparentCompiler
             tcConfigB.useSimpleResolution <- useSimpleResolution
 
             // Apply command-line arguments and collect more source files if they are in the arguments
+            // Wrap in try/catch to ensure command-line parsing errors are properly captured
+            // as diagnostics rather than escaping as exceptions
             let sourceFilesNew =
-                ApplyCommandLineArgs(tcConfigB, projectSnapshot.SourceFileNames, commandLineArgs)
+                try
+                    ApplyCommandLineArgs(tcConfigB, projectSnapshot.SourceFileNames, commandLineArgs)
+                with
+                | :? OperationCanceledException -> reraise ()
+                | exn ->
+                    errorRecovery exn range0
+                    projectSnapshot.SourceFileNames
 
             // Never open PDB files for the language service, even if --standalone is specified
             tcConfigB.openDebugInformationForLaterStaticLinking <- false
@@ -949,6 +962,33 @@ type internal TransparentCompiler
                 // Prepare the frameworkTcImportsCache
                 let! tcGlobals, frameworkTcImports = ComputeFrameworkImports tcConfig frameworkDLLs nonFrameworkResolutions
 
+                // If the tcGlobals was loaded from a different project, langVersion and realsig may be different
+                // for each cached project.  So here we create a new tcGlobals, with the existing framework values
+                // and updated realsig and langversion
+                let tcGlobals =
+                    if
+                        tcGlobals.langVersion <> tcConfig.langVersion
+                        || tcGlobals.realsig <> tcConfig.realsig
+                    then
+                        TcGlobals(
+                            tcGlobals.compilingFSharpCore,
+                            tcGlobals.ilg,
+                            tcGlobals.fslibCcu,
+                            tcGlobals.directoryToResolveRelativePaths,
+                            tcGlobals.isInteractive,
+                            tcGlobals.checkNullness,
+                            tcGlobals.useReflectionFreeCodeGen,
+                            tcGlobals.tryFindSysTypeCcuHelper,
+                            tcGlobals.emitDebugInfoInQuotations,
+                            tcGlobals.noDebugAttributes,
+                            tcGlobals.pathMap,
+                            tcConfig.langVersion,
+                            tcConfig.realsig,
+                            tcConfig.compilationMode
+                        )
+                    else
+                        tcGlobals
+
                 // Note we are not calling diagnosticsLogger.GetDiagnostics() anywhere for this task.
                 // This is ok because not much can actually go wrong here.
                 let diagnosticsLogger =
@@ -1013,7 +1053,6 @@ type internal TransparentCompiler
 
     let computeBootstrapInfoInner (projectSnapshot: ProjectSnapshot) =
         async {
-
             let! tcConfigB, sourceFiles, loadClosureOpt = ComputeTcConfigBuilder projectSnapshot
 
             // If this is a builder for a script, re-apply the settings inferred from the