Polyfill span.Contains(T)

src/coreclr/tools/Common/TypeSystem/IL/ILDisassembler.cs

@@ -283,7 +283,7 @@ public string GetNextInstruction()
             // Quick and dirty way to get the opcode name is to convert the enum value to string.
             // We need some adjustments though.
             string opCodeString = opCode.ToString().Replace("_", ".");
-            if (opCodeString.EndsWith("."))
+            if (opCodeString.EndsWith('.'))
                 opCodeString = opCodeString.Substring(0, opCodeString.Length - 1);
 
             decodedInstruction.Append(opCodeString);

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/PInvokeMethodFixupNode.cs

@@ -57,7 +57,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
             // Entry point name
             string entryPointName = _pInvokeMethodData.EntryPointName;
-            if (factory.Target.IsWindows && entryPointName.StartsWith("#", StringComparison.OrdinalIgnoreCase))
+            if (factory.Target.IsWindows && entryPointName.StartsWith('#'))
             {
                 // Windows-specific ordinal import
                 // CLR-compatible behavior: Strings that can't be parsed as a signed integer are treated as zero.

src/coreclr/tools/aot/ILCompiler.Compiler/ILCompiler.Compiler.csproj

@@ -4,7 +4,7 @@
     <AssemblyName>ILCompiler.Compiler</AssemblyName>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <NoWarn>$(NoWarn);CA1866;CA1867</NoWarn>
+    <NoWarn>$(NoWarn);CA1866</NoWarn>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <Platforms>x64;x86</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>

src/coreclr/tools/aot/ILCompiler.TypeSystem/ILCompiler.TypeSystem.csproj

@@ -5,7 +5,6 @@
     <AssemblyName>ILCompiler.TypeSystem</AssemblyName>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <NoWarn>$(NoWarn);CA1866</NoWarn>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <Platforms>x64;x86</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>

src/libraries/Common/src/Interop/Linux/cgroups/Interop.cgroups.cs

@@ -324,7 +324,7 @@ internal static bool TryFindHierarchyMount(CGroupVersion cgroupVersion, string m
                             {
                                 if (cgroupVersion == CGroupVersion.CGroup1)
                                 {
-                                    bool validCGroup1Entry = mount.FileSystemType.SequenceEqual("cgroup") && mount.SuperOptions.IndexOf(subsystem) >= 0;
+                                    bool validCGroup1Entry = mount.FileSystemType.SequenceEqual("cgroup") && mount.SuperOptions.Contains(subsystem, StringComparison.Ordinal);
                                     if (!validCGroup1Entry)
                                     {
                                         continue;

src/libraries/Common/src/Interop/Unix/System.Native/Interop.IsMemberOfGroup.cs

@@ -33,7 +33,7 @@ internal static unsafe bool IsMemberOfGroup(uint gid)
                 if (rv >= 0)
                 {
                     // success
-                    return groups.Slice(0, rv).IndexOf(gid) >= 0;
+                    return groups.Slice(0, rv).Contains(gid);
                 }
                 else if (rv == -1 && Interop.Sys.GetLastError() == Interop.Error.EINVAL)
                 {

src/libraries/Common/src/System/CodeDom/CodeTypeReference.cs

@@ -264,11 +264,7 @@ private void Initialize(string? typeName, CodeTypeReferenceOptions options)
             }
 
             // Now see if we have some arity.  baseType could be null if this is an array type.
-#if NET
-            if (_baseType != null && _baseType.Contains('`')) // string.Contains(char) is .NetCore2.1+ specific
-#else
-            if (_baseType != null && _baseType.IndexOf('`') != -1) // string.Contains(char) is .NetCore2.1+ specific
-#endif
+            if (_baseType != null && _baseType.Contains('`'))
             {
                 _needsFixup = false;
             }

src/libraries/Common/src/System/Data/Common/DbConnectionOptions.Common.cs

@@ -396,12 +396,11 @@ internal static int GetKeyValuePair(string connectionString, int currentPosition
             return currentPosition;
         }
 
-#pragma warning disable CA2249 // Consider using 'string.Contains' instead of 'string.IndexOf'. This file is built into libraries that don't have string.Contains(char).
         private static bool IsValueValidInternal(string? keyvalue)
         {
             if (null != keyvalue)
             {
-                return (-1 == keyvalue.IndexOf('\u0000')); // string.Contains(char) is .NetCore2.1+ specific
+                return !keyvalue.Contains('\u0000');
             }
             return true;
         }
@@ -412,14 +411,12 @@ private static bool IsKeyNameValid([NotNullWhen(true)] string? keyname)
             {
 #if DEBUG
                 bool compValue = ConnectionStringValidKeyRegex.IsMatch(keyname);
-                Debug.Assert(((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000'))) == compValue, "IsValueValid mismatch with regex");
+                Debug.Assert(((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && !keyname.Contains('\u0000')) == compValue, "IsValueValid mismatch with regex");
 #endif
-                // string.Contains(char) is .NetCore2.1+ specific
-                return ((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000')));
+                return ((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && !keyname.Contains('\u0000'));
             }
             return false;
         }
-#pragma warning restore CA2249 // Consider using 'string.Contains' instead of 'string.IndexOf'
 
 #if DEBUG
         private static Dictionary<string, string> SplitConnectionString(string connectionString, Dictionary<string, string>? synonyms, bool firstKey)

src/libraries/Common/src/System/Diagnostics/NetFrameworkUtils.cs

@@ -178,7 +178,7 @@ internal static string GetLatestBuildDllDirectory(string machineName)
                                         string majorVersion = majorVersions[i];
 
                                         // If this looks like a key of the form v{something}.{something}, we should see if it's a usable build.
-                                        if (majorVersion.Length > 1 && majorVersion[0] == 'v' && majorVersion.Contains(".")) // string.Contains(char) is .NetCore2.1+ specific
+                                        if (majorVersion.Length > 1 && majorVersion[0] == 'v' && majorVersion.Contains('.'))
                                         {
                                             int[] currentVersion = new int[] { -1, -1, -1 };
 

src/libraries/Common/src/System/MemoryExtensionsPolyfills.cs

@@ -6,6 +6,9 @@ namespace System
     /// <summary>Provides downlevel polyfills for span extension methods.</summary>
     internal static class MemoryExtensionsPolyfills
     {
+        public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T> =>
+            span.IndexOf(value) >= 0;
+
         public static bool ContainsAnyExcept(this ReadOnlySpan<char> span, char value)
         {
             for (int i = 0; i < span.Length; i++)

src/libraries/Common/src/System/StringPolyfills.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System
+{
+    /// <summary>Provides downlevel polyfills for string extension methods.</summary>
+    internal static class StringPolyfills
+    {
+        public static bool StartsWith(this string s, char value) =>
+            s.Length > 0 && s[0] == value;
+
+        public static bool EndsWith(this string s, char value) =>
+            s.Length > 0 && s[s.Length - 1] == value;
+
+        public static bool Contains(this string s, char value) =>
+            s.IndexOf(value) >= 0;
+    }
+}

src/libraries/Directory.Build.targets

@@ -187,6 +187,7 @@
   <ItemGroup Condition="'$(IncludeSpanPolyfills)' == 'true' and
                         '$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <Compile Include="$(LibrariesProjectRoot)\Common\src\System\MemoryExtensionsPolyfills.cs" Link="System\MemoryExtensionsPolyfills.cs" />
+    <Compile Include="$(LibrariesProjectRoot)\Common\src\System\StringPolyfills.cs" Link="System\StringPolyfills.cs" />
     <Compile Include="$(LibrariesProjectRoot)\Common\src\System\Buffers\SearchValuesPolyfills.cs" Link="System\Buffers\SearchValuesPolyfills.cs" />
     <Compile Include="$(LibrariesProjectRoot)\Common\src\System\Text\AsciiPolyfills.cs" Link="System\Text\AsciiPolyfills.cs" />
     <Compile Include="$(LibrariesProjectRoot)\Common\src\System\Text\EncodingPolyfills.cs" Link="System\Text\EncodingPolyfills.cs" />

src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationProvider.cs

@@ -54,11 +54,11 @@ public override void Load()
                     {
                         keyStartIndex = 2;
                     }
-                    else if (currentArg.StartsWith("-"))
+                    else if (currentArg.StartsWith('-'))
                     {
                         keyStartIndex = 1;
                     }
-                    else if (currentArg.StartsWith("/"))
+                    else if (currentArg.StartsWith('/'))
                     {
                         // "/SomeSwitch" is equivalent to "--SomeSwitch" when interpreting switch mappings
                         // So we do a conversion to simplify later processing
@@ -141,7 +141,7 @@ private static Dictionary<string, string> GetValidatedSwitchMappingsCopy(IDictio
             foreach (KeyValuePair<string, string> mapping in switchMappings)
             {
                 // Only keys start with "--" or "-" are acceptable
-                if (!mapping.Key.StartsWith("-") && !mapping.Key.StartsWith("--"))
+                if (!mapping.Key.StartsWith('-'))
                 {
                     throw new ArgumentException(
                         SR.Format(SR.Error_InvalidSwitchMapping, mapping.Key),

src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/Microsoft.Extensions.Configuration.CommandLine.csproj

@@ -2,12 +2,15 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
-    <NoWarn>$(NoWarn);CA1866</NoWarn>
     <EnableDefaultItems>true</EnableDefaultItems>
     <IsPackable>true</IsPackable>
     <PackageDescription>Command line configuration provider implementation for Microsoft.Extensions.Configuration. This package enables you to read configuration parameters from the command line arguments of your application. You can use CommandLineConfigurationExtensions.AddCommandLine extension method on IConfigurationBuilder to add the command line configuration provider to the configuration builder.</PackageDescription>
   </PropertyGroup>
 
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+    <Compile Include="$(LibrariesProjectRoot)\Common\src\System\StringPolyfills.cs" Link="System\StringPolyfills.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\src\Microsoft.Extensions.Configuration.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Abstractions\src\Microsoft.Extensions.Configuration.Abstractions.csproj" />

src/libraries/Microsoft.Extensions.FileProviders.Physical/src/Internal/FileSystemInfoHelper.cs

@@ -15,7 +15,7 @@ public static bool IsExcluded(FileSystemInfo fileSystemInfo, ExclusionFilters fi
             {
                 return false;
             }
-            else if (fileSystemInfo.Name.StartsWith(".", StringComparison.Ordinal) && (filters & ExclusionFilters.DotPrefixed) != 0)
+            else if (fileSystemInfo.Name.StartsWith('.') && (filters & ExclusionFilters.DotPrefixed) != 0)
             {
                 return true;
             }

src/libraries/Microsoft.Extensions.FileProviders.Physical/src/Microsoft.Extensions.FileProviders.Physical.csproj

@@ -4,7 +4,6 @@
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <RootNamespace>Microsoft.Extensions.FileProviders</RootNamespace>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <NoWarn>$(NoWarn);CA1865;CA1866</NoWarn>
     <EnableDefaultItems>true</EnableDefaultItems>
     <IsPackable>true</IsPackable>
     <PackageDescription>File provider for physical files for Microsoft.Extensions.FileProviders.</PackageDescription>

src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs

@@ -153,24 +153,10 @@ private IChangeToken GetOrAddChangeToken(string pattern)
                 LazyInitializer.EnsureInitialized(ref _timer, ref _timerInitialized, ref _timerLock, _timerFactory);
             }
 
-            IChangeToken changeToken;
-#if NET
-            bool isWildCard = pattern.Contains('*');
-#else
-            bool isWildCard = pattern.IndexOf('*') != -1;
-#endif
-            if (isWildCard || IsDirectoryPath(pattern))
-            {
-                changeToken = GetOrAddWildcardChangeToken(pattern);
-            }
-            else
-            {
+            return pattern.Contains('*') || IsDirectoryPath(pattern)
+                ? GetOrAddWildcardChangeToken(pattern)
                 // get rid of \. in Windows and ./ in UNIX's at the start of path file
-                var filePath = RemoveRelativePathSegment(pattern);
-                changeToken = GetOrAddFilePathChangeToken(filePath);
-            }
-
-            return changeToken;
+                : GetOrAddFilePathChangeToken(RemoveRelativePathSegment(pattern));
         }
 
         private static string RemoveRelativePathSegment(string pattern) =>

src/libraries/Microsoft.Win32.Registry/src/Microsoft.Win32.Registry.csproj

@@ -4,7 +4,6 @@
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);REGISTRY_ASSEMBLY</DefineConstants>
-    <NoWarn>$(NoWarn);CA2249</NoWarn>
     <UseCompilerGeneratedDocXmlFile>false</UseCompilerGeneratedDocXmlFile>
   </PropertyGroup>
 

src/libraries/System.CodeDom/src/Microsoft/CSharp/CSharpCodeGenerator.cs

@@ -192,10 +192,8 @@ private string QuoteSnippetString(string value)
             // If the string is short, use C style quoting (e.g "\r\n")
             // Also do it if it is too long to fit in one line
             // If the string contains '\0', verbatim style won't work.
-#pragma warning disable CA2249 // Consider using 'string.Contains' instead of 'string.IndexOf'
-            if (value.Length < 256 || value.Length > 1500 || (value.IndexOf('\0') != -1)) // string.Contains(char) is .NetCore2.1+ specific
+            if (value.Length < 256 || value.Length > 1500 || value.Contains('\0'))
                 return QuoteSnippetStringCStyle(value);
-#pragma warning restore CA2249
 
             // Otherwise, use 'verbatim' style quoting (e.g. @"foo")
             return QuoteSnippetStringVerbatimStyle(value);

src/libraries/System.CodeDom/src/Microsoft/VisualBasic/VBCodeGenerator.cs

@@ -862,11 +862,7 @@ protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression
                 string typeName = GetTypeOutput(e.CreateType);
                 Output.Write(typeName);
 
-#if NET
                 if (!typeName.Contains('('))
-#else
-                if (typeName.IndexOf('(') == -1)
-#endif
                 {
                     Output.Write("()");
                 }

src/libraries/System.Configuration.ConfigurationManager/src/System.Configuration.ConfigurationManager.csproj

@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
-    <NoWarn>$(NoWarn);CA2249</NoWarn>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <UseCompilerGeneratedDocXmlFile>false</UseCompilerGeneratedDocXmlFile>
     <IsPackable>true</IsPackable>

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/BaseConfigurationRecord.cs

@@ -3078,7 +3078,7 @@ internal static string NormalizeLocationSubPath(string subPath, IConfigErrorInfo
                 throw new ConfigurationErrorsException(SR.Config_location_path_invalid_first_character, errorInfo);
 
             // do not allow problematic starting characters
-            if (InvalidFirstSubPathCharacters.IndexOf(subPath[0]) != -1)
+            if (InvalidFirstSubPathCharacters.Contains(subPath[0]))
                 throw new ConfigurationErrorsException(SR.Config_location_path_invalid_first_character, errorInfo);
 
             // do not allow whitespace at end of subPath, as the OS
@@ -3088,7 +3088,7 @@ internal static string NormalizeLocationSubPath(string subPath, IConfigErrorInfo
                 throw new ConfigurationErrorsException(SR.Config_location_path_invalid_last_character, errorInfo);
 
             // the file system ignores trailing '.', '\', or '/', so do not allow it in a location subpath specification
-            if (InvalidLastSubPathCharacters.IndexOf(subPath[subPath.Length - 1]) != -1)
+            if (InvalidLastSubPathCharacters.Contains(subPath[subPath.Length - 1]))
                 throw new ConfigurationErrorsException(SR.Config_location_path_invalid_last_character, errorInfo);
 
             // combination of URI reserved characters and OS invalid filename characters, minus / (allowed reserved character)

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationProperty.cs

@@ -133,11 +133,7 @@ internal ConfigurationProperty(PropertyInfo info)
 
                 if (collectionAttribute != null)
                 {
-#if NET
                     if (!collectionAttribute.AddItemName.Contains(','))
-#else
-                    if (collectionAttribute.AddItemName.IndexOf(',') == -1)
-#endif
                     {
                         AddElementName = collectionAttribute.AddItemName;
                     }

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionCollection.cs

@@ -85,11 +85,7 @@ public ConfigurationSection Get(string name)
                 throw ExceptionUtil.ParameterNullOrEmpty(nameof(name));
 
             // prevent GetConfig from returning config not in this collection
-#if NET
             if (name.Contains('/'))
-#else
-            if (name.IndexOf('/') >= 0)
-#endif
                 return null;
 
             // get the section from the config record

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionGroupCollection.cs

@@ -89,11 +89,7 @@ public ConfigurationSectionGroup Get(string name)
                 throw ExceptionUtil.ParameterNullOrEmpty(nameof(name));
 
             // prevent GetConfig from returning config not in this collection
-#if NET
             if (name.Contains('/'))
-#else
-            if (name.IndexOf('/') >= 0)
-#endif
                 return null;
 
             // get the section group

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/StringAttributeCollection.cs

@@ -77,7 +77,7 @@ private void ThrowIfReadOnly()
 
         private static void ThrowIfContainsDelimiter(string value)
         {
-            if (value.Contains(",")) // string.Contains(char) is .NetCore2.1+ specific
+            if (value.Contains(','))
                 throw new ConfigurationErrorsException(SR.Format(SR.Config_base_value_cannot_contain, ","));
         }
 

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/StringValidator.cs

@@ -1,11 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Buffers;
+
 namespace System.Configuration
 {
     public class StringValidator : ConfigurationValidatorBase
     {
-        private readonly string _invalidChars;
+        private readonly SearchValues<char> _invalidChars;
         private readonly int _maxLength;
         private readonly int _minLength;
 
@@ -21,7 +23,7 @@ public StringValidator(int minLength, int maxLength, string invalidCharacters)
         {
             _minLength = minLength;
             _maxLength = maxLength;
-            _invalidChars = invalidCharacters;
+            _invalidChars = SearchValues.Create(invalidCharacters ?? string.Empty);
         }
 
         public override bool CanValidate(Type type)
@@ -42,14 +44,9 @@ public override void Validate(object value)
                 throw new ArgumentException(SR.Format(SR.Validator_string_max_length, _maxLength));
 
             // Check if the string contains any invalid characters
-            if ((len > 0) && !string.IsNullOrEmpty(_invalidChars))
+            if (data.AsSpan().ContainsAny(_invalidChars))
             {
-                char[] array = new char[_invalidChars.Length];
-
-                _invalidChars.CopyTo(0, array, 0, _invalidChars.Length);
-
-                if (data.IndexOfAny(array) != -1)
-                    throw new ArgumentException(SR.Format(SR.Validator_string_invalid_chars, _invalidChars));
+                throw new ArgumentException(SR.Format(SR.Validator_string_invalid_chars, _invalidChars));
             }
         }
     }

src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/TypeUtil.cs

@@ -49,7 +49,7 @@ private static Type GetImplicitType(string typeString)
 
             // Don't bother to look around if we've already got something that
             // is clearly not a simple type name.
-            if (string.IsNullOrEmpty(typeString) || typeString.IndexOf(',') != -1) // string.Contains(char) is .NetCore2.1+ specific
+            if (string.IsNullOrEmpty(typeString) || typeString.Contains(','))
                 return null;
 
             // Ignore all exceptions, otherwise callers will get unexpected