.

Author: SimonCropp

src/ApiBuilderTests/FrameworkSplitterTest.cs

@@ -53,18 +53,19 @@ void ProcessFile(string sourceFile, FrameworkIdentifier framework, string framew
         var code = File.ReadAllText(sourceFile);
 
         var frameworkSymbols = framework.Directives;
-        var sharedSymbols = GetSharedSymbols();
+        var featureSymbols = GetFeatureSymbols();
+        var parseSymbols = GetParseSymbols();
 
-        // Parse with ALL symbols (framework + shared)
-        // This makes all code active (both framework and feature code)
-        var allSymbols = frameworkSymbols.Concat(sharedSymbols).ToList();
+        // Parse with framework + parse symbols
+        // This makes code active where those symbols are used
+        var allSymbols = frameworkSymbols.Concat(parseSymbols).ToList();
         var parseOptions = CSharpParseOptions.Default.WithPreprocessorSymbols(allSymbols);
         var syntaxTree = CSharpSyntaxTree.ParseText(code, parseOptions);
 
         // Get the root and remove only framework-related directives
         // Feature directives will be kept
         var root = syntaxTree.GetRoot();
-        var processedRoot = RemoveFrameworkDirectives(root, sharedSymbols);
+        var processedRoot = RemoveFrameworkDirectives(root, featureSymbols);
 
         // Check if the file has any meaningful code
         if (!HasMeaningfulCode(processedRoot))
@@ -148,14 +149,16 @@ or ConversionOperatorDeclarationSyntax
         return hasNonPolyfillTypes;
     }
 
-    static SyntaxNode RemoveFrameworkDirectives(SyntaxNode root, List<string> sharedSymbols)
+    static SyntaxNode RemoveFrameworkDirectives(SyntaxNode root, List<string> featureSymbols)
     {
         // Remove only framework-related preprocessor directives while keeping feature directives
-        var rewriter = new DirectiveRemovalRewriter(sharedSymbols);
+        var rewriter = new DirectiveRemovalRewriter(featureSymbols);
         return rewriter.Visit(root);
     }
 
-    List<string> GetSharedSymbols() =>
+    // Symbols to define during parsing (makes code active)
+    // Excludes symbols that typically appear negated (like !RefsBclMemory)
+    List<string> GetParseSymbols() =>
     [
         "FeatureMemory",
         "FeatureRuntimeInformation",
@@ -167,7 +170,27 @@ List<string> GetSharedSymbols() =>
         "AllowUnsafeBlocks",
         "FeatureValueTask",
         "FeatureValueTuple",
-        "FeatureCompression"
+        "FeatureCompression",
+        "PolyUseEmbeddedAttribute"
+    ];
+
+    // All feature symbols (for IsFrameworkRelated check)
+    // Includes symbols that appear negated - we still want to recognize them as feature flags
+    List<string> GetFeatureSymbols() =>
+    [
+        "FeatureMemory",
+        "FeatureRuntimeInformation",
+        "PolyEnsure",
+        "PolyArgumentExceptions",
+        "PolyPublic",
+        "FeatureHttp",
+        "PolyNullability",
+        "AllowUnsafeBlocks",
+        "FeatureValueTask",
+        "FeatureValueTuple",
+        "FeatureCompression",
+        "PolyUseEmbeddedAttribute",
+        "RefsBclMemory"
     ];
 
     List<FrameworkIdentifier> GetAllTargetFrameworks() =>
@@ -480,6 +503,7 @@ partial class DirectiveRemovalRewriter(List<string> sharedSymbols) : CSharpSynta
     {
         readonly HashSet<string> sharedSymbols = sharedSymbols.ToHashSet();
         readonly Stack<bool> directiveStack = new();
+        bool removeNextDisabledText; // Set when we remove a non-taken #else/#elif
 
         readonly HashSet<string> frameworkRelatedKeywords =
         [
@@ -541,9 +565,10 @@ SyntaxTriviaList ProcessTrivia(SyntaxTriviaList triviaList)
                     // Check if this disabled text is part of a framework conditional
                     // Only check the INNERMOST directive (Peek), not any outer ones
                     var insideFrameworkBlock = directiveStack.Count > 0 && directiveStack.Peek();
-                    if (insideFrameworkBlock)
+                    if (insideFrameworkBlock || removeNextDisabledText)
                     {
-                        continue; // Remove disabled text from framework blocks
+                        removeNextDisabledText = false; // Reset the flag
+                        continue; // Remove disabled text
                     }
                     // Keep disabled text from feature blocks (though there shouldn't be any since we parse with all symbols)
                 }
@@ -576,41 +601,63 @@ bool ShouldRemoveDirective(SyntaxTrivia trivia)
             {
                 var isFrameworkRelated = IsFrameworkRelated(ifDirective.Condition.ToString());
 
-                // If the directive is inactive, always remove it (regardless of whether it's framework-related)
-                // Inactive directives mean the code will never be compiled for this target framework
-                if (!ifDirective.IsActive)
+                // If this branch wasn't taken (condition was false), remove it entirely
+                // BranchTaken indicates whether the condition evaluated to true
+                if (!ifDirective.BranchTaken)
                 {
                     directiveStack.Push(true); // Mark for removal so matching endif is also removed
                     return true;
                 }
 
-                // For active directives, only remove if framework-related
+                // For taken branches, only remove if framework-related
                 directiveStack.Push(isFrameworkRelated);
                 return isFrameworkRelated;
             }
 
             // Check if it's an #elif directive
             if (structure is ElifDirectiveTriviaSyntax elifDirective)
             {
-                // #elif is part of the current directive block
+                // If we're already removing this directive block, continue removing
                 if (directiveStack.Count > 0 && directiveStack.Peek())
                 {
+                    // Keep stack as-is so matching #endif is also removed
+                    // Content after #elif (if taken) is active syntax tree, not disabled text
                     return true;
                 }
 
-                return false;
+                // If #if branch was taken, this elif is inactive - remove it
+                if (!elifDirective.BranchTaken)
+                {
+                    removeNextDisabledText = true; // Remove the disabled text that follows
+                    return true;
+                }
+
+                // This elif branch was taken and #if wasn't being removed
+                // Check if it's framework-related
+                var elifFrameworkRelated = IsFrameworkRelated(elifDirective.Condition.ToString());
+                return elifFrameworkRelated;
             }
 
             // Check if it's an #else directive
-            if (structure is ElseDirectiveTriviaSyntax)
+            if (structure is ElseDirectiveTriviaSyntax elseDirective)
             {
-                // #else is part of the current directive block
+                // If we're already removing this directive block, continue removing
                 if (directiveStack.Count > 0 && directiveStack.Peek())
                 {
+                    // Keep stack as-is so matching #endif is also removed
+                    // Content after #else (if taken) is active syntax tree, not disabled text
                     return true;
                 }
 
-                return false;
+                // If previous branch was taken, this else is inactive - remove directive and content
+                if (!elseDirective.BranchTaken)
+                {
+                    removeNextDisabledText = true; // Remove the disabled text that follows
+                    return true;
+                }
+
+                // This else branch was taken - remove the directive but keep content
+                return true;
             }
 
             // Check if it's an #endif directive

src/Consume/Consume.cs

@@ -36,6 +36,7 @@
 using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Linq;
+using Polyfills;
 using MemoryStream = System.IO.MemoryStream;
 // ReSharper disable MethodHasAsyncOverload
 // ReSharper disable RedundantCast

src/Split/net10.0/ArgumentExceptions/ArgumentNullExceptionPolyfill.cs

@@ -11,14 +11,5 @@ static partial class Polyfill
     extension(ArgumentNullException)
     {
 
-#if AllowUnsafeBlocks && !NET9_0_OR_GREATER
-        public static unsafe void ThrowIfNull(void* argument, [CallerArgumentExpression(nameof(argument))] string? paramName = null)
-        {
-            if (argument is null)
-            {
-                throw new ArgumentNullException(paramName);
-            }
-        }
-#endif
     }
 }

src/Split/net10.0/EmbeddedAttribute.cs

@@ -0,0 +1,15 @@
+// <auto-generated />
+#pragma warning disable
+#if PolyUseEmbeddedAttribute
+
+#if PolyPublic
+#error PolyPublic should not be used with PolyUseEmbeddedAttribute.
+#endif
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed partial class EmbeddedAttribute : global::System.Attribute
+    {
+    }
+}
+#endif

src/Split/net10.0/Regex/RegexPolyfill.cs

@@ -18,26 +18,5 @@ static partial class Polyfill
 #if FeatureMemory
 #endif
 
-#if !NET9_0_OR_GREATER && FeatureMemory && FeatureValueTuple
-
-        public static ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern)
-        {
-            var regex = new Regex(pattern);
-            return new ValueSplitEnumerator(input, regex, 0, 0);
-        }
-
-        public static ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options)
-        {
-            var regex = new Regex(pattern, options);
-            return new ValueSplitEnumerator(input, regex, 0, 0);
-        }
-
-        public static ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options, TimeSpan matchTimeout)
-        {
-            var regex = new Regex(pattern, options, matchTimeout);
-            return new ValueSplitEnumerator(input, regex, 0, 0);
-        }
-
-#endif
     }
 }

src/Split/net10.0/StringInterpolation/Polyfill_StringBuilder_Append.cs

@@ -8,21 +8,6 @@ namespace Polyfills;
 
 static partial class Polyfill
 {
-#if FeatureMemory && !NET6_0_OR_GREATER
-    /// <summary>Appends the specified interpolated string to this instance.</summary>
-    public static StringBuilder Append(
-        StringBuilder target,
-        [InterpolatedStringHandlerArgument(nameof(target))]
-        ref AppendInterpolatedStringHandler handler) => target;
-
-    /// <summary>Appends the specified interpolated string to this instance.</summary>
-    public static StringBuilder Append(
-        StringBuilder target,
-        IFormatProvider? provider,
-        [InterpolatedStringHandlerArgument(nameof(target), nameof(provider))]
-        ref AppendInterpolatedStringHandler handler) => target;
-
-#elif NET6_0_OR_GREATER
 
     /// <summary>Appends the specified interpolated string to this instance.</summary>
 
@@ -39,5 +24,4 @@ public static StringBuilder Append(
         [InterpolatedStringHandlerArgument(nameof(target), nameof(provider))] ref StringBuilder.AppendInterpolatedStringHandler handler) =>
         target.Append(provider, ref handler);
 
-#endif
 }

src/Split/net10.0/StringInterpolation/Polyfill_StringBuilder_AppendLine.cs

@@ -8,24 +8,6 @@ namespace Polyfills;
 
 static partial class Polyfill
 {
-#if FeatureMemory && !NET6_0_OR_GREATER
-
-    /// <summary>Appends the specified interpolated string followed by the default line terminator to the end of the current StringBuilder object.</summary>
-    public static StringBuilder AppendLine(
-        StringBuilder target,
-        [InterpolatedStringHandlerArgument(nameof(target))]
-        ref AppendInterpolatedStringHandler handler) =>
-        target.AppendLine();
-
-    /// <summary>Appends the specified interpolated string followed by the default line terminator to the end of the current StringBuilder object.</summary>
-    public static StringBuilder AppendLine(
-        StringBuilder target,
-        IFormatProvider? provider,
-        [InterpolatedStringHandlerArgument(nameof(target), nameof(provider))]
-        ref AppendInterpolatedStringHandler handler) =>
-        target.AppendLine();
-
-#elif NET6_0_OR_GREATER
 
     /// <summary>Appends the specified interpolated string followed by the default line terminator to the end of the current StringBuilder object.</summary>
 
@@ -43,6 +25,5 @@ public static StringBuilder AppendLine(
         [InterpolatedStringHandlerArgument(nameof(target), nameof(provider))]
         ref StringBuilder.AppendInterpolatedStringHandler handler) =>
         target.AppendLine(provider, ref handler);
-#endif
 
 }

src/Split/net461/EmbeddedAttribute.cs

@@ -0,0 +1,15 @@
+// <auto-generated />
+#pragma warning disable
+#if PolyUseEmbeddedAttribute
+
+#if PolyPublic
+#error PolyPublic should not be used with PolyUseEmbeddedAttribute.
+#endif
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed partial class EmbeddedAttribute : global::System.Attribute
+    {
+    }
+}
+#endif

src/Split/net461/FilePolyfill.cs

@@ -257,12 +257,8 @@ public static Task AppendAllTextAsync(string path, string? contents, Cancellatio
 
         public static async Task<byte[]> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default)
         {
-            #if (NETCOREAPP2_0_OR_GREATER || NETSTANDARD) && FeatureRuntimeInformation
-            var options = FileOptions.Asynchronous | (OperatingSystem.IsWindows() ? FileOptions.SequentialScan : FileOptions.None);
-            #else
-            var options = FileOptions.Asynchronous | FileOptions.SequentialScan;
-            #endif
-            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, options);
+                                    var options = FileOptions.Asynchronous | FileOptions.SequentialScan;
+                        using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, options);
             var length = (int) stream.Length;
             var bytes = new byte[length];
             var bytesRead = 0;

src/Split/net461/FileUnixModePolyfill.cs

@@ -26,11 +26,6 @@ public static UnixFileMode GetUnixFileMode(string path)
             {
                 throw new PlatformNotSupportedException();
             }
-#else
-            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
-            {
-                throw new PlatformNotSupportedException();
-            }
 #endif
             if (string.IsNullOrEmpty(path))
             {
@@ -184,11 +179,6 @@ public static void SetUnixFileMode(string path, UnixFileMode mode)
             {
                 throw new PlatformNotSupportedException();
             }
-#else
-            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
-            {
-                throw new PlatformNotSupportedException();
-            }
 #endif
             if (string.IsNullOrEmpty(path))
             {