Ignore drive casing when comparing on windows platforms

src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerConfigTests.cs

@@ -10,6 +10,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
 using Xunit;
 using static Microsoft.CodeAnalysis.AnalyzerConfig;
 using static Roslyn.Test.Utilities.TestHelpers;
@@ -63,30 +64,30 @@ public void ConfigWithEscapedValues()
         {
             var config = ParseConfigFile(@"is_global = true
 
-[c:/\{f\*i\?le1\}.cs]
+[C:/\{f\*i\?le1\}.cs]
 build_metadata.Compile.ToRetrieve = abc123
 
-[c:/f\,ile\#2.cs]
+[C:/f\,ile\#2.cs]
 build_metadata.Compile.ToRetrieve = def456
 
-[c:/f\;i\!le\[3\].cs]
+[C:/f\;i\!le\[3\].cs]
 build_metadata.Compile.ToRetrieve = ghi789
 ");
 
             var namedSections = config.NamedSections;
-            Assert.Equal("c:/\\{f\\*i\\?le1\\}.cs", namedSections[0].Name);
+            Assert.Equal("C:/\\{f\\*i\\?le1\\}.cs", namedSections[0].Name);
             AssertEx.Equal(
                 new[] { KeyValuePair.Create("build_metadata.compile.toretrieve", "abc123") },
                 namedSections[0].Properties
             );
 
-            Assert.Equal("c:/f\\,ile\\#2.cs", namedSections[1].Name);
+            Assert.Equal("C:/f\\,ile\\#2.cs", namedSections[1].Name);
             AssertEx.Equal(
                 new[] { KeyValuePair.Create("build_metadata.compile.toretrieve", "def456") },
                 namedSections[1].Properties
             );
 
-            Assert.Equal("c:/f\\;i\\!le\\[3\\].cs", namedSections[2].Name);
+            Assert.Equal("C:/f\\;i\\!le\\[3\\].cs", namedSections[2].Name);
             AssertEx.Equal(
                 new[] { KeyValuePair.Create("build_metadata.compile.toretrieve", "ghi789") },
                 namedSections[2].Properties
@@ -115,6 +116,40 @@ public void CanGetSectionsWithSpecialCharacters()
             Assert.Equal("def456", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
         }
 
+        [ConditionalFact(typeof(WindowsOnly))]
+        public void CanGetSectionsWithDifferentDriveCasing()
+        {
+            var config = Parse(@"is_global = true
+build_metadata.compile.toretrieve = global
+
+[c:/goo/file.cs]
+build_metadata.compile.toretrieve = abc123
+
+[C:/goo/other.cs]
+build_metadata.compile.toretrieve = def456
+", pathToFile: @"C:/.editorconfig");
+
+            var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config));
+
+            var sectionOptions = set.GetOptionsForSourcePath(@"c:\goo\file.cs");
+            Assert.Equal("abc123", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+
+            sectionOptions = set.GetOptionsForSourcePath(@"C:\goo\file.cs");
+            Assert.Equal("abc123", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+
+            sectionOptions = set.GetOptionsForSourcePath(@"C:\goo\other.cs");
+            Assert.Equal("def456", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+
+            sectionOptions = set.GetOptionsForSourcePath(@"c:\goo\other.cs");
+            Assert.Equal("def456", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+
+            sectionOptions = set.GetOptionsForSourcePath(@"c:\global.cs");
+            Assert.Equal("global", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+
+            sectionOptions = set.GetOptionsForSourcePath(@"C:\global.cs");
+            Assert.Equal("global", sectionOptions.AnalyzerOptions["build_metadata.compile.toretrieve"]);
+        }
+
         [ConditionalFact(typeof(WindowsOnly))]
         public void WindowsPath()
         {
@@ -2226,7 +2261,7 @@ public void GlobalConfigOptionsAreEmptyWhenNoGlobalConfig()
         [InlineData(@"\", false)] //invalid: editorconfig sees a single escape character
         [InlineData(@"\\", false)] //invalid: editorconfig sees an escaped, literal backslash
         [InlineData(@"/\{\}\,\[\]\*", true)]
-        [InlineData(@"c:\my\file.cs", false)] // invalid: editorconfig sees a single file called 'c:(\m)y(\f)ile.cs' (i.e. \m and \f are escape chars)
+        [InlineData(@"C:\my\file.cs", false)] // invalid: editorconfig sees a single file called 'c:(\m)y(\f)ile.cs' (i.e. \m and \f are escape chars)
         [InlineData(@"\my\file.cs", false)] // invalid: editorconfig sees a single file called '(\m)y(\f)ile.cs' 
         [InlineData(@"\\my\\file.cs", false)] // invalid: editorconfig sees a single file called '\my\file.cs' with literal backslashes
         [InlineData(@"\\\\my\\file.cs", false)] // invalid: editorconfig sees a single file called '\\my\file.cs' not a UNC path
@@ -2261,20 +2296,20 @@ public void GlobalConfigIssuesWarningWithInvalidSectionNames(string sectionName,
         }
 
         [Theory]
-        [InlineData("c:/myfile.cs", true, false)]
+        [InlineData("C:/myfile.cs", true, false)]
         [InlineData("cd:/myfile.cs", false, false)] // windows only allows a single character as a drive specifier
         [InlineData(@"\c\:\/myfile.cs", true, false)] // allow escaped characters
         [InlineData("/myfile.cs", true, true)] //absolute, with a relative drive root
         [InlineData("c:myfile.cs", false, false)] //relative, wit2h an absolute drive root
-        [InlineData(@"c:\myfile.cs", false, false)] //not a valid editorconfig path
+        [InlineData(@"C:\myfile.cs", false, false)] //not a valid editorconfig path
         [InlineData("//?/C:/Test/Foo.txt", false, false)] // ? is a special char in editorconfig
         [InlineData(@"//\?/C:/Test/Foo.txt", true, true)]
         [InlineData(@"\\?\C:\Test\Foo.txt", false, false)]
-        [InlineData(@"c:", false, false)]
-        [InlineData(@"c\", false, false)]
+        [InlineData(@"C:", false, false)]
+        [InlineData(@"C\", false, false)]
         [InlineData(@"\c\:", false, false)]
-        [InlineData("c:/", true, false)]
-        [InlineData("c:/*.cs", false, false)]
+        [InlineData("C:/", true, false)]
+        [InlineData("C:/*.cs", false, false)]
         public void GlobalConfigIssuesWarningWithInvalidSectionNames_PlatformSpecific(string sectionName, bool isValidWindows, bool isValidOther)
             => GlobalConfigIssuesWarningWithInvalidSectionNames(sectionName, ExecutionConditionUtil.IsWindows ? isValidWindows : isValidOther);
 

src/Compilers/Core/CodeAnalysisTest/FileSystem/PathUtilitiesTests.cs

@@ -435,5 +435,29 @@ public void CollapseWithForwardSlash(string input, string output)
         {
             AssertEx.Equal(output, PathUtilities.CollapseWithForwardSlash(input.AsSpan()));
         }
+
+        [ConditionalTheory(typeof(WindowsOnly))]
+        [InlineData(@"//a/b/c", @"//a/b/c")]
+        [InlineData(@"/a\b/c/", @"/a\b/c/")]
+        [InlineData(@"C:B", @"C:B")]
+        [InlineData(@"c:b", @"c:b")]
+        [InlineData(@"c:\b", @"C:\b")]
+        [InlineData(@"c:/b", @"C:/b")]
+        public void NormalizeDriveLetter_Windows(string input, string output)
+        {
+            AssertEx.Equal(output, PathUtilities.NormalizeDriveLetter(input));
+        }
+
+        [ConditionalTheory(typeof(UnixLikeOnly))]
+        [InlineData(@"//a/b/c")]
+        [InlineData(@"/a\b/c/")]
+        [InlineData(@"C:B")]
+        [InlineData(@"c:b")]
+        [InlineData(@"c:\b")]
+        [InlineData(@"c:/b")]
+        public void NormalizeDriveLetter_UnixLike(string input)
+        {
+            AssertEx.Equal(input, PathUtilities.NormalizeDriveLetter(input));
+        }
     }
 }

src/Compilers/Core/Portable/CommandLine/AnalyzerConfig.cs

@@ -256,12 +256,17 @@ public static AnalyzerConfig Parse(SourceText text, string? pathToFile)
             // Add the last section
             addNewSection();
 
+            // Normalize the path to file the same way named sections are
+            pathToFile = PathUtilities.NormalizeDriveLetter(pathToFile);
+
             return new AnalyzerConfig(globalSection!, namedSectionBuilder.ToImmutable(), pathToFile);
 
             void addNewSection()
             {
+                var sectionName = PathUtilities.NormalizeDriveLetter(activeSectionName);
+
                 // Close out the previous section
-                var previousSection = new Section(activeSectionName, activeSectionProperties.ToImmutable());
+                var previousSection = new Section(sectionName, activeSectionProperties.ToImmutable());
                 if (activeSectionName == "")
                 {
                     // This is the global section

src/Compilers/Core/Portable/CommandLine/AnalyzerConfigSet.cs

@@ -185,6 +185,7 @@ public AnalyzerConfigOptionsResult GetOptionsForSourcePath(string sourcePath)
 
             var normalizedPath = PathUtilities.CollapseWithForwardSlash(sourcePath.AsSpan());
             normalizedPath = PathUtilities.ExpandAbsolutePathWithRelativeParts(normalizedPath);
+            normalizedPath = PathUtilities.NormalizeDriveLetter(normalizedPath);
 
             // If we have a global config, add any sections that match the full path. We can have at most one section since
             // we would have merged them earlier.

src/Compilers/Core/Portable/FileSystem/PathUtilities.cs

@@ -735,6 +735,16 @@ public static string NormalizePathPrefix(string filePath, ImmutableArray<KeyValu
             return filePath;
         }
 
+        public static string NormalizeDriveLetter(string filePath)
+        {
+            if (!IsUnixLikePlatform && IsDriveRootedAbsolutePath(filePath))
+            {
+                filePath = char.ToUpper(filePath[0]) + filePath.Substring(1);
+            }
+
+            return filePath;
+        }
+
         /// <summary>
         /// Unfortunately, we cannot depend on Path.GetInvalidPathChars() or Path.GetInvalidFileNameChars()
         /// From MSDN: The array returned from this method is not guaranteed to contain the complete set of characters