Replace OPTIMIZE_FOR_SIZE with feature switch

src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs

@@ -143,7 +143,12 @@ public static int SlowRuntimeTimeoutModifier
         public static bool IsStartingProcessesSupported => !IsiOS && !IstvOS;
 
         public static bool IsSpeedOptimized => !IsSizeOptimized;
-        public static bool IsSizeOptimized => IsBrowser || IsWasi || IsAndroid || IsAppleMobile;
+        public static bool IsSizeOptimized => s_linqIsSizeOptimized.Value;
+        private static readonly Lazy<bool> s_linqIsSizeOptimized = new Lazy<bool>(IsLinqSizeOptimized);
+        private static bool IsLinqSizeOptimized()
+        {
+            return (bool)typeof(Enumerable).GetMethod("get_IsSizeOptimized", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, Array.Empty<object>());
+        }
 
         public static bool IsBrowserDomSupported => IsEnvironmentVariableTrue("IsBrowserDomSupported");
         public static bool IsBrowserDomSupportedOrNotBrowser => IsNotBrowser || IsBrowserDomSupported;

src/libraries/System.Linq/src/System.Linq.csproj

@@ -1,23 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent)-android;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos</TargetFrameworks>
+    <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
     <UseCompilerGeneratedDocXmlFile>false</UseCompilerGeneratedDocXmlFile>
   </PropertyGroup>
 
-  <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
-  <PropertyGroup>
-    <TargetPlatformIdentifier>$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))</TargetPlatformIdentifier>
-    <OptimizeForSize Condition="'$(TargetPlatformIdentifier)' == 'browser' or '$(TargetPlatformIdentifier)' == 'android' or '$(TargetPlatformIdentifier)' == 'ios' or '$(TargetPlatformIdentifier)' == 'tvos'">true</OptimizeForSize>
-    <DefineConstants Condition="'$(OptimizeForSize)' == 'true'">$(DefineConstants);OPTIMIZE_FOR_SIZE</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup Condition="'$(OptimizeForSize)' == true">
+  <ItemGroup>
     <Compile Include="System\Linq\Skip.SizeOpt.cs" />
     <Compile Include="System\Linq\Take.SizeOpt.cs" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(OptimizeForSize)' != true">
+  <ItemGroup>
     <Compile Include="System\Linq\AppendPrepend.SpeedOpt.cs" />
     <Compile Include="System\Linq\Cast.SpeedOpt.cs" />
     <Compile Include="System\Linq\Concat.SpeedOpt.cs" />

src/libraries/System.Linq/src/System/Linq/AnyAll.cs

@@ -20,8 +20,7 @@ public static bool Any<TSource>(this IEnumerable<TSource> source)
                 return gc.Count != 0;
             }
 
-#if !OPTIMIZE_FOR_SIZE
-            if (source is Iterator<TSource> iterator)
+            if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 int count = iterator.GetCount(onlyIfCheap: true);
                 if (count >= 0)
@@ -32,7 +31,6 @@ public static bool Any<TSource>(this IEnumerable<TSource> source)
                 iterator.TryGetFirst(out bool found);
                 return found;
             }
-#endif
 
             if (source is ICollection ngc)
             {

src/libraries/System.Linq/src/System/Linq/Count.cs

@@ -20,12 +20,10 @@ public static int Count<TSource>(this IEnumerable<TSource> source)
                 return collectionoft.Count;
             }
 
-#if !OPTIMIZE_FOR_SIZE
-            if (source is Iterator<TSource> iterator)
+            if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 return iterator.GetCount(onlyIfCheap: false);
             }
-#endif
 
             if (source is ICollection collection)
             {
@@ -115,8 +113,7 @@ public static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> s
                 return true;
             }
 
-#if !OPTIMIZE_FOR_SIZE
-            if (source is Iterator<TSource> iterator)
+            if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 int c = iterator.GetCount(onlyIfCheap: true);
                 if (c >= 0)
@@ -125,7 +122,6 @@ public static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> s
                     return true;
                 }
             }
-#endif
 
             if (source is ICollection collection)
             {

src/libraries/System.Linq/src/System/Linq/ElementAt.cs

@@ -23,9 +23,7 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int i
 
             bool found;
             TSource? element =
-#if !OPTIMIZE_FOR_SIZE
-                source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
-#endif
+                !IsSizeOptimized && source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
                 TryGetElementAtNonIterator(source, index, out found);
 
             if (!found)
@@ -123,9 +121,7 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, Index
             }
 
             return
-#if !OPTIMIZE_FOR_SIZE
-                source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
-#endif
+                !IsSizeOptimized && source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
                 TryGetElementAtNonIterator(source, index, out found);
         }
 

src/libraries/System.Linq/src/System/Linq/Enumerable.cs

@@ -2,13 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace System.Linq
 {
     public static partial class Enumerable
     {
+        [FeatureSwitchDefinition("System.Linq.Enumerable.IsSizeOptimized")]
+        internal static bool IsSizeOptimized { get; } = AppContext.TryGetSwitch("System.Linq.Enumerable.IsSizeOptimized", out bool isEnabled) ? isEnabled : false;
+
         public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source) => source;
 
         /// <summary>Returns an empty <see cref="IEnumerable{TResult}"/>.</summary>

src/libraries/System.Linq/src/System/Linq/First.cs

@@ -70,9 +70,7 @@ public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source,
             }
 
             return
-#if !OPTIMIZE_FOR_SIZE
-                source is Iterator<TSource> iterator ? iterator.TryGetFirst(out found) :
-#endif
+                !IsSizeOptimized && source is Iterator<TSource> iterator ? iterator.TryGetFirst(out found) :
                 TryGetFirstNonIterator(source, out found);
         }
 

src/libraries/System.Linq/src/System/Linq/Iterator.cs

@@ -88,11 +88,9 @@ public Iterator<TSource> GetEnumerator()
             /// <typeparam name="TResult">The type of the mapped items.</typeparam>
             /// <param name="selector">The selector used to map each item.</param>
             public virtual IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-#if OPTIMIZE_FOR_SIZE
-                new IEnumerableSelectIterator<TSource, TResult>(this, selector);
-#else
-                new IteratorSelectIterator<TSource, TResult>(this, selector);
-#endif
+                !IsSizeOptimized
+                ? new IteratorSelectIterator<TSource, TResult>(this, selector)
+                : new IEnumerableSelectIterator<TSource, TResult>(this, selector);
 
 
             /// <summary>

src/libraries/System.Linq/src/System/Linq/Last.cs

@@ -69,9 +69,7 @@ public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, F
             }
 
             return
-#if !OPTIMIZE_FOR_SIZE
-                source is Iterator<TSource> iterator ? iterator.TryGetLast(out found) :
-#endif
+                !IsSizeOptimized && source is Iterator<TSource> iterator ? iterator.TryGetLast(out found) :
                 TryGetLastNonIterator(source, out found);
         }
 

src/libraries/System.Linq/src/System/Linq/Skip.SizeOpt.cs

@@ -7,7 +7,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
+        private static IEnumerable<TSource> SizeOptimizedSkipIterator<TSource>(IEnumerable<TSource> source, int count)
         {
             using IEnumerator<TSource> e = source.GetEnumerator();
             while (count > 0 && e.MoveNext()) count--;

src/libraries/System.Linq/src/System/Linq/Skip.SpeedOpt.cs

@@ -7,7 +7,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count) =>
+        private static IEnumerable<TSource> SpeedOptimizedSkipIterator<TSource>(IEnumerable<TSource> source, int count) =>
             source is IList<TSource> sourceList ?
                 (IEnumerable<TSource>)new IListSkipTakeIterator<TSource>(sourceList, count, int.MaxValue) :
                 new IEnumerableSkipTakeIterator<TSource>(source, count, -1);

src/libraries/System.Linq/src/System/Linq/Skip.cs

@@ -30,14 +30,12 @@ public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> sourc
 
                 count = 0;
             }
-#if !OPTIMIZE_FOR_SIZE
-            else if (source is Iterator<TSource> iterator)
+            else if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 return iterator.Skip(count) ?? Empty<TSource>();
             }
-#endif
 
-            return SkipIterator(source, count);
+            return IsSizeOptimized ? SizeOptimizedSkipIterator(source, count) : SpeedOptimizedSkipIterator(source, count);
         }
 
         public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)

src/libraries/System.Linq/src/System/Linq/Take.SizeOpt.cs

@@ -8,7 +8,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
+        private static IEnumerable<TSource> SizeOptimizedTakeIterator<TSource>(IEnumerable<TSource> source, int count)
         {
             Debug.Assert(count > 0);
 
@@ -19,7 +19,7 @@ private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> s
             }
         }
 
-        private static IEnumerable<TSource> TakeRangeIterator<TSource>(IEnumerable<TSource> source, int startIndex, int endIndex)
+        private static IEnumerable<TSource> SizeOptimizedTakeRangeIterator<TSource>(IEnumerable<TSource> source, int startIndex, int endIndex)
         {
             Debug.Assert(source is not null);
             Debug.Assert(startIndex >= 0 && startIndex < endIndex);

src/libraries/System.Linq/src/System/Linq/Take.SpeedOpt.cs

@@ -8,7 +8,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
+        private static IEnumerable<TSource> SpeedOptimizedTakeIterator<TSource>(IEnumerable<TSource> source, int count)
         {
             Debug.Assert(source is not null && !IsEmptyArray(source));
             Debug.Assert(count > 0);
@@ -19,7 +19,7 @@ private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> s
                 new IEnumerableSkipTakeIterator<TSource>(source, 0, count - 1);
         }
 
-        private static IEnumerable<TSource> TakeRangeIterator<TSource>(IEnumerable<TSource> source, int startIndex, int endIndex)
+        private static IEnumerable<TSource> SpeedOptimizedTakeRangeIterator<TSource>(IEnumerable<TSource> source, int startIndex, int endIndex)
         {
             Debug.Assert(source is not null && !IsEmptyArray(source));
             Debug.Assert(startIndex >= 0 && startIndex < endIndex);

src/libraries/System.Linq/src/System/Linq/Take.cs

@@ -15,9 +15,12 @@ public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> sourc
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            return count <= 0 || IsEmptyArray(source) ?
-                [] :
-                TakeIterator(source, count);
+            if (count <= 0 || IsEmptyArray(source))
+            {
+                return [];
+            }
+
+            return IsSizeOptimized ? SizeOptimizedTakeIterator(source, count) : SpeedOptimizedTakeIterator(source, count);
         }
 
         /// <summary>Returns a specified range of contiguous elements from a sequence.</summary>
@@ -60,9 +63,12 @@ public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> sourc
             }
             else if (!isEndIndexFromEnd)
             {
-                return startIndex >= endIndex ?
-                    [] :
-                    TakeRangeIterator(source, startIndex, endIndex);
+                if (startIndex >= endIndex)
+                {
+                    return [];
+                }
+
+                return IsSizeOptimized ? SizeOptimizedTakeRangeIterator(source, startIndex, endIndex) : SpeedOptimizedTakeRangeIterator(source, startIndex, endIndex);
             }
 
             return TakeRangeFromEndIterator(source, isStartIndexFromEnd, startIndex, isEndIndexFromEnd, endIndex);
@@ -88,7 +94,10 @@ private static IEnumerable<TSource> TakeRangeFromEndIterator<TSource>(IEnumerabl
 
                 if (startIndex < endIndex)
                 {
-                    foreach (TSource element in TakeRangeIterator(source, startIndex, endIndex))
+                    IEnumerable<TSource> rangeIterator = IsSizeOptimized
+                        ? SizeOptimizedTakeRangeIterator(source, startIndex, endIndex)
+                        : SpeedOptimizedTakeRangeIterator(source, startIndex, endIndex);
+                    foreach (TSource element in rangeIterator)
                     {
                         yield return element;
                     }

src/libraries/System.Linq/src/System/Linq/ToCollection.cs

@@ -11,12 +11,10 @@ public static partial class Enumerable
     {
         public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
         {
-#if !OPTIMIZE_FOR_SIZE
-            if (source is Iterator<TSource> iterator)
+            if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 return iterator.ToArray();
             }
-#endif
 
             if (source is ICollection<TSource> collection)
             {
@@ -64,12 +62,10 @@ public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-#if !OPTIMIZE_FOR_SIZE
-            if (source is Iterator<TSource> iterator)
+            if (!IsSizeOptimized && source is Iterator<TSource> iterator)
             {
                 return iterator.ToList();
             }
-#endif
 
             return new List<TSource>(source);
         }

src/libraries/System.Linq/tests/CountTests.cs

@@ -178,10 +178,11 @@ public static IEnumerable<object[]> NonEnumeratedCount_SupportedEnumerables()
 
             yield return WrapArgs(0, Enumerable.Empty<string>());
 
+            yield return WrapArgs(100, Enumerable.Range(1, 100));
+            yield return WrapArgs(80, Enumerable.Repeat(1, 80));
+
             if (PlatformDetection.IsSpeedOptimized)
             {
-                yield return WrapArgs(100, Enumerable.Range(1, 100));
-                yield return WrapArgs(80, Enumerable.Repeat(1, 80));
                 yield return WrapArgs(50, Enumerable.Range(1, 50).Select(x => x + 1));
                 yield return WrapArgs(4, new int[] { 1, 2, 3, 4 }.Select(x => x + 1));
                 yield return WrapArgs(50, Enumerable.Range(1, 50).Select(x => x + 1).Select(x => x - 1));
@@ -202,8 +203,6 @@ public static IEnumerable<object[]> NonEnumeratedCount_UnsupportedEnumerables()
 
             if (!PlatformDetection.IsSpeedOptimized)
             {
-                yield return WrapArgs(Enumerable.Range(1, 100));
-                yield return WrapArgs(Enumerable.Repeat(1, 80));
                 yield return WrapArgs(Enumerable.Range(1, 50).Select(x => x + 1));
                 yield return WrapArgs(new int[] { 1, 2, 3, 4 }.Select(x => x + 1));            
                 yield return WrapArgs(Enumerable.Range(1, 50).Select(x => x + 1).Select(x => x - 1));