Remove feature flags for #:include and #:exclude

documentation/general/dotnet-run-file.md

@@ -215,18 +215,13 @@ The directives are processed as follows:
   where `{0}` is the directive's value and `{1}` is determined by its extension.
   The mapping can be customized by setting the MSBuild property `FileBasedProgramsItemMapping`
   which is by default set to `.cs=Compile;.resx=EmbeddedResource;.json=None;.razor=Content`.
-  (The mapping customization is currently gated under a feature flag that can be enabled by setting the MSBuild property `ExperimentalFileBasedProgramEnableItemMapping=true`.)
 
   It is an error if the value is empty.
 
   Relative paths are resolved relative to the file containing the directive.
 
-  This directive is currently gated under a feature flag that can be enabled by setting the MSBuild property `ExperimentalFileBasedProgramEnableIncludeDirective=true`.
-
 - Each `#:exclude` is injected similarly to `#:include` but with `Remove="{0}"` instead of `Include="{0}"`.
 
-  This directive is currently gated under a feature flag that can be enabled by setting the MSBuild property `ExperimentalFileBasedProgramEnableExcludeDirective=true`.
-
 - Other directive kinds result in an error, reserving them for future use.
 
 Directive values support MSBuild variables (like `$(..)`) normally as they are translated literally and left to MSBuild engine to process.
@@ -245,7 +240,7 @@ and can do that efficiently by stopping the search when it sees the first "C# to
 
 For a given `dotnet run file.cs`, we include directives from the current entry point file (`file.cs`) and all other non-entry-point C# files,
 specifically from all `Compile` items included in the project, no matter whether the `Compile` items are specified in some MSBuild code or inferred from `#:include`.
-(Processing directives from other files is currently gated under a feature flag that can be enabled by setting the MSBuild property `ExperimentalFileBasedProgramEnableTransitiveDirectives=true`.)
+
 The order in which other files are processed is currently unspecified (can change across SDK versions) but deterministic (stable in a given SDK version).
 We do not limit these directives to appear only in entry point files because it allows:
 - a non-entry-point file like `Util.cs` to be self-contained and have all the `#:package`s it needs specified in it,

src/Cli/Microsoft.DotNet.FileBasedPrograms/FileLevelDirectiveHelpers.cs

@@ -598,11 +598,6 @@ public enum IncludeOrExcludeKind
     /// </summary>
     public sealed class IncludeOrExclude(in ParseInfo info) : Named(info)
     {
-        public const string ExperimentalFileBasedProgramEnableIncludeDirective = nameof(ExperimentalFileBasedProgramEnableIncludeDirective);
-        public const string ExperimentalFileBasedProgramEnableExcludeDirective = nameof(ExperimentalFileBasedProgramEnableExcludeDirective);
-        public const string ExperimentalFileBasedProgramEnableTransitiveDirectives = nameof(ExperimentalFileBasedProgramEnableTransitiveDirectives);
-        public const string ExperimentalFileBasedProgramEnableItemMapping = nameof(ExperimentalFileBasedProgramEnableItemMapping);
-
         public const string MappingPropertyName = "FileBasedProgramsItemMapping";
 
         public static string DefaultMappingString => ".cs=Compile;.resx=EmbeddedResource;.json=None;.razor=Content";

src/Cli/Microsoft.DotNet.FileBasedPrograms/InternalAPI.Unshipped.txt

@@ -1,7 +1,3 @@
-const Microsoft.DotNet.FileBasedPrograms.CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableExcludeDirective = "ExperimentalFileBasedProgramEnableExcludeDirective" -> string!
-const Microsoft.DotNet.FileBasedPrograms.CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableIncludeDirective = "ExperimentalFileBasedProgramEnableIncludeDirective" -> string!
-const Microsoft.DotNet.FileBasedPrograms.CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableItemMapping = "ExperimentalFileBasedProgramEnableItemMapping" -> string!
-const Microsoft.DotNet.FileBasedPrograms.CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableTransitiveDirectives = "ExperimentalFileBasedProgramEnableTransitiveDirectives" -> string!
 const Microsoft.DotNet.FileBasedPrograms.CSharpDirective.IncludeOrExclude.MappingPropertyName = "FileBasedProgramsItemMapping" -> string!
 Microsoft.DotNet.FileBasedPrograms.CSharpDirective
 Microsoft.DotNet.FileBasedPrograms.CSharpDirective.CSharpDirective(in Microsoft.DotNet.FileBasedPrograms.CSharpDirective.ParseInfo info) -> void

src/Microsoft.DotNet.ProjectTools/Resources.resx

@@ -162,8 +162,4 @@ Make the profile names distinct.</value>
     <value>File included via #:include directive (or Compile item) not found: {0}</value>
     <comment>{Locked="#:include"}{Locked="Compile"}. {0} is file path.</comment>
   </data>
-  <data name="ExperimentalFeatureDisabled" xml:space="preserve">
-    <value>This is an experimental feature, set MSBuild property '{0}' to 'true' to enable it.</value>
-    <comment>{Locked="MSBuild"}{Locked="true"}. {0} is MSBuild property name.</comment>
-  </data>
 </root>

src/Microsoft.DotNet.ProjectTools/VirtualProjectBuilder.cs

@@ -221,12 +221,10 @@ private ImmutableArray<CSharpDirective> EvaluateDirectives(
 
     internal ImmutableArray<(string Extension, string ItemType)> GetItemMapping(ProjectInstance project, ErrorReporter reportError)
     {
-        return MSBuildUtilities.ConvertStringToBool(project.GetPropertyValue(CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableItemMapping))
-            ? CSharpDirective.IncludeOrExclude.ParseMapping(
-                project.GetPropertyValue(CSharpDirective.IncludeOrExclude.MappingPropertyName),
-                EntryPointSourceFile,
-                reportError)
-            : CSharpDirective.IncludeOrExclude.DefaultMapping;
+        return CSharpDirective.IncludeOrExclude.ParseMapping(
+            project.GetPropertyValue(CSharpDirective.IncludeOrExclude.MappingPropertyName),
+            EntryPointSourceFile,
+            reportError);
     }
 
     public static ProjectInstance CreateProjectInstance(
@@ -276,8 +274,6 @@ internal void CreateProjectInstance(
                 evaluatedDirectives,
                 addGlobalProperties);
 
-            CheckDirectives(project, evaluatedDirectives, reportError);
-
             return;
         }
 
@@ -325,8 +321,6 @@ internal void CreateProjectInstance(
         evaluatedDirectives = evaluatedDirectiveBuilder.ToImmutable();
         _evaluatedDirectives = (directivesOriginal, evaluatedDirectives);
 
-        CheckDirectives(project, evaluatedDirectives, reportError);
-
         bool TryGetNextFileToProcess()
         {
             while (filesToProcess.TryDequeue(out var filePath))
@@ -399,51 +393,6 @@ ProjectRootElement CreateProjectRootElement(string projectFileText, ProjectColle
         }
     }
 
-    private void CheckDirectives(
-        ProjectInstance project,
-        ImmutableArray<CSharpDirective> directives,
-        ErrorReporter reportError)
-    {
-        bool? includeEnabled = null;
-        bool? excludeEnabled = null;
-        bool? transitiveEnabled = null;
-
-        foreach (var directive in directives)
-        {
-            if (directive is CSharpDirective.IncludeOrExclude includeOrExcludeDirective)
-            {
-                if (includeOrExcludeDirective.Kind == CSharpDirective.IncludeOrExcludeKind.Include)
-                {
-                    CheckFlagEnabled(ref includeEnabled, CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableIncludeDirective, directive);
-                }
-                else
-                {
-                    Debug.Assert(includeOrExcludeDirective.Kind == CSharpDirective.IncludeOrExcludeKind.Exclude);
-                    CheckFlagEnabled(ref excludeEnabled, CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableExcludeDirective, directive);
-                }
-            }
-
-            if (directive.Info.SourceFile.Path != EntryPointSourceFile.Path)
-            {
-                CheckFlagEnabled(ref transitiveEnabled, CSharpDirective.IncludeOrExclude.ExperimentalFileBasedProgramEnableTransitiveDirectives, directive);
-            }
-        }
-
-        void CheckFlagEnabled(ref bool? flag, string flagName, CSharpDirective directive)
-        {
-            bool value = flag ??= MSBuildUtilities.ConvertStringToBool(project.GetPropertyValue(flagName));
-
-            if (!value)
-            {
-                reportError(
-                    directive.Info.SourceFile.Text,
-                    directive.Info.SourceFile.Path,
-                    directive.Info.Span,
-                    string.Format(Resources.ExperimentalFeatureDisabled, flagName));
-            }
-        }
-    }
-
     internal static void WriteProjectFile(
         TextWriter writer,
         ImmutableArray<CSharpDirective> directives,