From 5bd0153adc19e8e4725561aa3af61b74ba0fc079 Mon Sep 17 00:00:00 2001 From: AR-May <67507805+AR-May@users.noreply.github.com> Date: Mon, 19 Jan 2026 16:51:23 +0100 Subject: [PATCH 1/3] Move some functions from shared files to framework assembly --- src/Framework/FileUtilities.cs | 133 +++++++++++++++++++++ src/MSBuildTaskHost/MSBuildTaskHost.csproj | 5 +- src/Shared/FileUtilities.cs | 51 ++------ 3 files changed, 148 insertions(+), 41 deletions(-) create mode 100644 src/Framework/FileUtilities.cs diff --git a/src/Framework/FileUtilities.cs b/src/Framework/FileUtilities.cs new file mode 100644 index 00000000000..23cc707631b --- /dev/null +++ b/src/Framework/FileUtilities.cs @@ -0,0 +1,133 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.IO; + +namespace Microsoft.Build.Framework +{ + // TODO: this should be unified with Shared\FileUtilities, but it is hard to untangle everything in one go. + // Moved some of the methods here for now. + + /// + /// This class contains utility methods for file IO. + /// Functions from FileUtilities are transferred here as part of the effort to remove Shared files. + /// + internal static class FrameworkFileUtilities + { + internal static readonly char[] Slashes = ['/', '\\']; + + /// + /// Indicates if the given character is a slash. + /// + /// + /// true, if slash + internal static bool IsSlash(char c) + { + return (c == Path.DirectorySeparatorChar) || (c == Path.AltDirectorySeparatorChar); + } + + /// + /// Indicates if the given file-spec ends with a slash. + /// + /// The file spec. + /// true, if file-spec has trailing slash + internal static bool EndsWithSlash(string fileSpec) + { + return (fileSpec.Length > 0) + ? IsSlash(fileSpec[fileSpec.Length - 1]) + : false; + } + + internal static string FixFilePath(string path) + { + return string.IsNullOrEmpty(path) || Path.DirectorySeparatorChar == '\\' ? path : path.Replace('\\', '/'); + } + + /// + /// If the given path doesn't have a trailing slash then add one. + /// If the path is an empty string, does not modify it. + /// + /// The path to check. + /// A path with a slash. + internal static string EnsureTrailingSlash(string fileSpec) + { + fileSpec = FixFilePath(fileSpec); + if (fileSpec.Length > 0 && !IsSlash(fileSpec[fileSpec.Length - 1])) + { + fileSpec += Path.DirectorySeparatorChar; + } + + return fileSpec; + } + + /// + /// Ensures the path does not have a trailing slash. + /// + internal static string EnsureNoTrailingSlash(string path) + { + path = FixFilePath(path); + if (EndsWithSlash(path)) + { + path = path.Substring(0, path.Length - 1); + } + + return path; + } + +#if !TASKHOST + /// + /// If the given path doesn't have a trailing slash then add one. + /// + /// The absolute path to check. + /// An absolute path with a trailing slash. + internal static AbsolutePath EnsureTrailingSlash(AbsolutePath path) + { + return new AbsolutePath(EnsureTrailingSlash(path.Value), + original: path.OriginalValue, + ignoreRootedCheck: true); + } + + /// + /// Ensures the absolute path does not have a trailing slash. + /// + /// The absolute path to check. + /// An absolute path without a trailing slash. + internal static AbsolutePath EnsureNoTrailingSlash(AbsolutePath path) + { + return new AbsolutePath(EnsureNoTrailingSlash(path.Value), + original: path.OriginalValue, + ignoreRootedCheck: true); + } + + /// + /// Gets the canonicalized full path of the provided path. + /// Resolves relative segments like "." and "..". Fixes directory separators. + /// ASSUMES INPUT IS ALREADY UNESCAPED. + /// + internal static AbsolutePath NormalizePath(AbsolutePath path) + { + return new AbsolutePath(FixFilePath(Path.GetFullPath(path.Value)), + original: path.OriginalValue, + ignoreRootedCheck: true); + } + + /// + /// Resolves relative segments like "." and "..". + /// ASSUMES INPUT IS ALREADY UNESCAPED. + /// + internal static AbsolutePath RemoveRelativeSegments(AbsolutePath path) + { + return new AbsolutePath(Path.GetFullPath(path.Value), + original: path.OriginalValue, + ignoreRootedCheck: true); + } + + internal static AbsolutePath FixFilePath(AbsolutePath path) + { + return new AbsolutePath(FixFilePath(path.Value), + original: path.OriginalValue, + ignoreRootedCheck: true); + } +#endif + } +} \ No newline at end of file diff --git a/src/MSBuildTaskHost/MSBuildTaskHost.csproj b/src/MSBuildTaskHost/MSBuildTaskHost.csproj index 66d83585f5d..a514cbcdcbf 100644 --- a/src/MSBuildTaskHost/MSBuildTaskHost.csproj +++ b/src/MSBuildTaskHost/MSBuildTaskHost.csproj @@ -88,9 +88,12 @@ ExceptionHandling.cs - + FileUtilities.cs + + SharedFileUtilities.cs + FileUtilitiesRegex.cs diff --git a/src/Shared/FileUtilities.cs b/src/Shared/FileUtilities.cs index 34e36d5c3d3..91c5611fc18 100644 --- a/src/Shared/FileUtilities.cs +++ b/src/Shared/FileUtilities.cs @@ -143,7 +143,7 @@ public static bool GetIsFileSystemCaseSensitive() internal static char[] InvalidFileNameChars => InvalidFileNameCharsArray; #endif - internal static readonly char[] Slashes = { '/', '\\' }; + internal static readonly char[] Slashes = FrameworkFileUtilities.Slashes; internal static readonly string DirectorySeparatorString = Path.DirectorySeparatorChar.ToString(); @@ -246,16 +246,7 @@ internal static void ClearCacheDirectory() /// /// The path to check. /// A path with a slash. - internal static string EnsureTrailingSlash(string fileSpec) - { - fileSpec = FixFilePath(fileSpec); - if (fileSpec.Length > 0 && !IsSlash(fileSpec[fileSpec.Length - 1])) - { - fileSpec += Path.DirectorySeparatorChar; - } - - return fileSpec; - } + internal static string EnsureTrailingSlash(string fileSpec) => FrameworkFileUtilities.EnsureTrailingSlash(fileSpec); /// /// Ensures the path does not have a leading or trailing slash after removing the first 'start' characters. @@ -263,16 +254,16 @@ internal static string EnsureTrailingSlash(string fileSpec) internal static string EnsureNoLeadingOrTrailingSlash(string path, int start) { int stop = path.Length; - while (start < stop && IsSlash(path[start])) + while (start < stop && FrameworkFileUtilities.IsSlash(path[start])) { start++; } - while (start < stop && IsSlash(path[stop - 1])) + while (start < stop && FrameworkFileUtilities.IsSlash(path[stop - 1])) { stop--; } - return FixFilePath(path.Substring(start, stop - start)); + return FrameworkFileUtilities.FixFilePath(path.Substring(start, stop - start)); } /// @@ -281,12 +272,12 @@ internal static string EnsureNoLeadingOrTrailingSlash(string path, int start) internal static string EnsureTrailingNoLeadingSlash(string path, int start) { int stop = path.Length; - while (start < stop && IsSlash(path[start])) + while (start < stop && FrameworkFileUtilities.IsSlash(path[start])) { start++; } - return FixFilePath(start < stop && IsSlash(path[stop - 1]) ? + return FrameworkFileUtilities.FixFilePath(start < stop && FrameworkFileUtilities.IsSlash(path[stop - 1]) ? path.Substring(start) : #if NET string.Concat(path.AsSpan(start), new(in Path.DirectorySeparatorChar))); @@ -298,16 +289,7 @@ internal static string EnsureTrailingNoLeadingSlash(string path, int start) /// /// Ensures the path does not have a trailing slash. /// - internal static string EnsureNoTrailingSlash(string path) - { - path = FixFilePath(path); - if (EndsWithSlash(path)) - { - path = path.Substring(0, path.Length - 1); - } - - return path; - } + internal static string EnsureNoTrailingSlash(string path) => FrameworkFileUtilities.EnsureNoTrailingSlash(path); /// /// Ensures the path is enclosed within single quotes. @@ -370,22 +352,14 @@ internal static string EnsureQuotes(string path, bool isSingleQuote = true) /// /// The file spec. /// true, if file-spec has trailing slash - internal static bool EndsWithSlash(string fileSpec) - { - return (fileSpec.Length > 0) - ? IsSlash(fileSpec[fileSpec.Length - 1]) - : false; - } + internal static bool EndsWithSlash(string fileSpec) => FrameworkFileUtilities.EndsWithSlash(fileSpec); /// /// Indicates if the given character is a slash. /// /// /// true, if slash - internal static bool IsSlash(char c) - { - return (c == Path.DirectorySeparatorChar) || (c == Path.AltDirectorySeparatorChar); - } + internal static bool IsSlash(char c) => FrameworkFileUtilities.IsSlash(c); /// /// Trims the string and removes any double quotes around it. @@ -578,10 +552,7 @@ From Path.cs in the CLR } #endif // FEATURE_LEGACY_GETFULLPATH - internal static string FixFilePath(string path) - { - return string.IsNullOrEmpty(path) || Path.DirectorySeparatorChar == '\\' ? path : path.Replace('\\', '/'); // .Replace("//", "/"); - } + internal static string FixFilePath(string path) => FrameworkFileUtilities.FixFilePath(path); /// /// Normalizes all path separators (both forward and back slashes) to forward slashes. From 6362a96ef9c419a5b29ce2fb5ce0a926c8f4b52c Mon Sep 17 00:00:00 2001 From: AR-May <67507805+AR-May@users.noreply.github.com> Date: Tue, 20 Jan 2026 17:09:41 +0100 Subject: [PATCH 2/3] Make ErrorUtilities static --- src/Framework/ErrorUtilities.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Framework/ErrorUtilities.cs b/src/Framework/ErrorUtilities.cs index c430b87dbf1..e9b9275d7c8 100644 --- a/src/Framework/ErrorUtilities.cs +++ b/src/Framework/ErrorUtilities.cs @@ -11,7 +11,7 @@ namespace Microsoft.Build.Framework // because some of the errors there will use localized resources from different assemblies, // which won't be referenceable in Framework. - internal class FrameworkErrorUtilities + internal static class FrameworkErrorUtilities { /// /// This method should be used in places where one would normally put From 1a7148b5ad084752285aea50b053b4bea544b2af Mon Sep 17 00:00:00 2001 From: AR-May <67507805+AR-May@users.noreply.github.com> Date: Wed, 21 Jan 2026 12:50:28 +0100 Subject: [PATCH 3/3] refactor to use FrameworkFileUtilities functions directly. --- .../SolutionFile_OldParser_Tests.cs | 2 +- .../Evaluation/Expander_Tests.cs | 2 +- .../FileAccesses/FileAccessManager.cs | 3 +- .../RequestBuilder/TargetUpToDateChecker.cs | 14 ++-- .../SdkResolution/SdkResolverManifest.cs | 3 +- .../Construction/ProjectImportElement.cs | 4 +- src/Build/Construction/ProjectRootElement.cs | 2 +- .../Construction/ProjectUsingTaskElement.cs | 8 +-- .../Solution/SolutionProjectGenerator.cs | 2 +- src/Build/Definition/Toolset.cs | 5 +- .../FunctionCallExpressionNode.cs | 5 +- src/Build/Evaluation/Expander.cs | 4 +- src/Build/Evaluation/IntrinsicFunctions.cs | 2 +- src/Build/Instance/ProjectItemInstance.cs | 4 +- src/Build/Instance/TaskRegistry.cs | 2 +- src/Build/Logging/FileLogger.cs | 2 +- src/Build/Utilities/FileSpecMatchTester.cs | 3 +- src/MSBuild/CommandLine/CommandLineParser.cs | 6 +- src/MSBuild/XMake.cs | 8 +-- src/Shared/FileMatcher.cs | 10 +-- src/Shared/FileUtilities.cs | 69 +++++-------------- src/Shared/FrameworkLocationHelper.cs | 4 +- src/Shared/Modifiers.cs | 9 +-- src/Shared/TempFileUtilities.cs | 3 +- src/Shared/UnitTests/FileMatcher_Tests.cs | 14 ++-- src/Shared/UnitTests/FileUtilities_Tests.cs | 57 +++++++-------- src/Tasks.UnitTests/CodeTaskFactoryTests.cs | 8 +-- src/Tasks.UnitTests/Copy_Tests.cs | 4 +- .../CreateCSharpManifestResourceName_Tests.cs | 2 +- ...teVisualBasicManifestResourceName_Tests.cs | 12 ++-- .../FindAppConfigFile_Tests.cs | 4 +- src/Tasks.UnitTests/FindInList_Tests.cs | 4 +- src/Tasks.UnitTests/FindUnderPath_Tests.cs | 4 +- .../AssemblyDependency/ReferenceTable.cs | 4 +- .../ResolveAssemblyReference.cs | 2 +- src/Tasks/AssignTargetPath.cs | 2 +- src/Tasks/CreateCSharpManifestResourceName.cs | 6 +- .../CreateVisualBasicManifestResourceName.cs | 2 +- src/Tasks/DependencyFile.cs | 4 +- src/Tasks/FindInList.cs | 2 +- src/Tasks/GetFrameworkSDKPath.cs | 17 +++-- src/Tasks/GetSDKReferenceFiles.cs | 4 +- src/Tasks/ListOperators/FindUnderPath.cs | 6 +- src/Tasks/MakeDir.cs | 2 +- src/Tasks/ResGenDependencies.cs | 5 +- src/Tasks/ResolveSDKReference.cs | 2 +- .../ResourceHandling/MSBuildResXReader.cs | 3 +- src/Tasks/Touch.cs | 2 +- src/Tasks/Unzip.cs | 2 +- .../CommandLineBuilder_Tests.cs | 5 +- .../ToolLocationHelper_Tests.cs | 4 +- .../TrackedDependencies/FileTrackerTests.cs | 22 +++--- src/Utilities/CommandLineBuilder.cs | 2 +- src/Utilities/TargetPlatformSDK.cs | 3 +- src/Utilities/TaskItem.cs | 6 +- src/Utilities/ToolLocationHelper.cs | 17 ++--- .../CanonicalTrackedInputFiles.cs | 4 +- .../CanonicalTrackedOutputFiles.cs | 2 +- .../TrackedDependencies/FileTracker.cs | 22 +++--- .../TrackedDependencies/FlatTrackingData.cs | 2 +- 60 files changed, 210 insertions(+), 229 deletions(-) diff --git a/src/Build.UnitTests/Construction/SolutionFile_OldParser_Tests.cs b/src/Build.UnitTests/Construction/SolutionFile_OldParser_Tests.cs index 7688d60acb9..0d197044b63 100644 --- a/src/Build.UnitTests/Construction/SolutionFile_OldParser_Tests.cs +++ b/src/Build.UnitTests/Construction/SolutionFile_OldParser_Tests.cs @@ -2555,7 +2555,7 @@ public void AbsolutePathShouldHandleUriLikeRelativePathsOnUnix() /// /// Test to verify that the fix for issue #1769 works by directly testing - /// FileUtilities.FixFilePath integration in AbsolutePath. + /// FrameworkFileUtilities.FixFilePath integration in AbsolutePath. /// This test simulates scenarios where intermediate path processing might /// leave backslashes in the AbsolutePath on Unix systems. /// diff --git a/src/Build.UnitTests/Evaluation/Expander_Tests.cs b/src/Build.UnitTests/Evaluation/Expander_Tests.cs index 46762a8712e..03d4397e0df 100644 --- a/src/Build.UnitTests/Evaluation/Expander_Tests.cs +++ b/src/Build.UnitTests/Evaluation/Expander_Tests.cs @@ -3455,7 +3455,7 @@ public void PropertyFunctionStaticMethodDirectoryNameOfFileAbove() string result = expander.ExpandIntoStringAndUnescape(@"$([MSBuild]::GetDirectoryNameOfFileAbove($(StartingDirectory), $(FileToFind)))", ExpanderOptions.ExpandProperties, MockElementLocation.Instance); - Assert.Equal(Microsoft.Build.Shared.FileUtilities.EnsureTrailingSlash(tempPath), Microsoft.Build.Shared.FileUtilities.EnsureTrailingSlash(result)); + Assert.Equal(FrameworkFileUtilities.EnsureTrailingSlash(tempPath), FrameworkFileUtilities.EnsureTrailingSlash(result)); result = expander.ExpandIntoStringAndUnescape(@"$([MSBuild]::GetDirectoryNameOfFileAbove($(StartingDirectory), Hobbits))", ExpanderOptions.ExpandProperties, MockElementLocation.Instance); diff --git a/src/Build/BackEnd/Components/FileAccesses/FileAccessManager.cs b/src/Build/BackEnd/Components/FileAccesses/FileAccessManager.cs index 63f9a7b7f29..d45e5bd870f 100644 --- a/src/Build/BackEnd/Components/FileAccesses/FileAccessManager.cs +++ b/src/Build/BackEnd/Components/FileAccesses/FileAccessManager.cs @@ -9,6 +9,7 @@ using Microsoft.Build.BackEnd; using Microsoft.Build.Execution; using Microsoft.Build.Experimental.FileAccess; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; @@ -44,7 +45,7 @@ public void InitializeComponent(IBuildComponentHost host) { _scheduler = host.GetComponent(BuildComponentType.Scheduler) as IScheduler; _configCache = host.GetComponent(BuildComponentType.ConfigCache) as IConfigCache; - _tempDirectory = FileUtilities.EnsureNoTrailingSlash(FileUtilities.TempFileDirectory); + _tempDirectory = FrameworkFileUtilities.EnsureNoTrailingSlash(FileUtilities.TempFileDirectory); } public void ShutdownComponent() diff --git a/src/Build/BackEnd/Components/RequestBuilder/TargetUpToDateChecker.cs b/src/Build/BackEnd/Components/RequestBuilder/TargetUpToDateChecker.cs index 16afcef0c2e..56094d8f078 100644 --- a/src/Build/BackEnd/Components/RequestBuilder/TargetUpToDateChecker.cs +++ b/src/Build/BackEnd/Components/RequestBuilder/TargetUpToDateChecker.cs @@ -978,7 +978,7 @@ internal static bool IsAnyOutOfDate(out DependencyAnalysisLogDetail dependenc // possibly the outputs list isn't actually the shortest list. However it always is the shortest // in the cases I've seen, and adding this optimization would make the code hard to read. - string oldestOutput = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(outputs[0].ToString())); + string oldestOutput = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(outputs[0].ToString())); ErrorUtilities.ThrowIfTypeDoesNotImplementToString(outputs[0]); DateTime oldestOutputFileTime = DateTime.MinValue; @@ -996,7 +996,7 @@ internal static bool IsAnyOutOfDate(out DependencyAnalysisLogDetail dependenc if (oldestOutputFileTime == DateTime.MinValue) { // First output is missing: we must build the target - string arbitraryInput = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(inputs[0].ToString())); + string arbitraryInput = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(inputs[0].ToString())); ErrorUtilities.ThrowIfTypeDoesNotImplementToString(inputs[0]); dependencyAnalysisDetailEntry = new DependencyAnalysisLogDetail(arbitraryInput, oldestOutput, null, null, OutofdateReason.MissingOutput); return true; @@ -1004,7 +1004,7 @@ internal static bool IsAnyOutOfDate(out DependencyAnalysisLogDetail dependenc for (int i = 1; i < outputs.Count; i++) { - string candidateOutput = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(outputs[i].ToString())); + string candidateOutput = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(outputs[i].ToString())); ErrorUtilities.ThrowIfTypeDoesNotImplementToString(outputs[i]); DateTime candidateOutputFileTime = DateTime.MinValue; try @@ -1022,7 +1022,7 @@ internal static bool IsAnyOutOfDate(out DependencyAnalysisLogDetail dependenc { // An output is missing: we must build the target string arbitraryInput = - EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(inputs[0].ToString())); + EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(inputs[0].ToString())); ErrorUtilities.ThrowIfTypeDoesNotImplementToString(inputs[0]); dependencyAnalysisDetailEntry = new DependencyAnalysisLogDetail(arbitraryInput, candidateOutput, null, null, OutofdateReason.MissingOutput); return true; @@ -1039,7 +1039,7 @@ internal static bool IsAnyOutOfDate(out DependencyAnalysisLogDetail dependenc // Now compare the oldest output with each input and break out if we find one newer. foreach (T input in inputs) { - string unescapedInput = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(input.ToString())); + string unescapedInput = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(input.ToString())); ErrorUtilities.ThrowIfTypeDoesNotImplementToString(input); DateTime inputFileTime = DateTime.MaxValue; try @@ -1127,8 +1127,8 @@ private void RecordUniqueInputsAndOutputs(IList inputs, IList outputs) /// true, if "input" is newer than "output" private bool IsOutOfDate(string input, string output, string inputItemName, string outputItemName) { - input = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(input)); - output = EscapingUtilities.UnescapeAll(FileUtilities.FixFilePath(output)); + input = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(input)); + output = EscapingUtilities.UnescapeAll(FrameworkFileUtilities.FixFilePath(output)); ProjectErrorUtilities.VerifyThrowInvalidProject(input.AsSpan().IndexOfAny(MSBuildConstants.InvalidPathChars) < 0, _project.ProjectFileLocation, "IllegalCharactersInFileOrDirectory", input, inputItemName); ProjectErrorUtilities.VerifyThrowInvalidProject(output.AsSpan().IndexOfAny(MSBuildConstants.InvalidPathChars) < 0, _project.ProjectFileLocation, "IllegalCharactersInFileOrDirectory", output, outputItemName); bool outOfDate = (CompareLastWriteTimes(input, output, out bool inputDoesNotExist, out bool outputDoesNotExist) == 1) || inputDoesNotExist; diff --git a/src/Build/BackEnd/Components/SdkResolution/SdkResolverManifest.cs b/src/Build/BackEnd/Components/SdkResolution/SdkResolverManifest.cs index 3e319d90adf..fc01468bac7 100644 --- a/src/Build/BackEnd/Components/SdkResolution/SdkResolverManifest.cs +++ b/src/Build/BackEnd/Components/SdkResolution/SdkResolverManifest.cs @@ -5,6 +5,7 @@ using System.IO; using System.Text.RegularExpressions; using System.Xml; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; #nullable disable @@ -79,7 +80,7 @@ internal static SdkResolverManifest Load(string filePath, string manifestFolder) { SdkResolverManifest manifest = ParseSdkResolverElement(reader, filePath); - manifest.Path = FileUtilities.FixFilePath(manifest.Path); + manifest.Path = FrameworkFileUtilities.FixFilePath(manifest.Path); if (!System.IO.Path.IsPathRooted(manifest.Path)) { manifest.Path = System.IO.Path.Combine(manifestFolder, manifest.Path); diff --git a/src/Build/Construction/ProjectImportElement.cs b/src/Build/Construction/ProjectImportElement.cs index 6bbc04a9e7d..852ab8e7d05 100644 --- a/src/Build/Construction/ProjectImportElement.cs +++ b/src/Build/Construction/ProjectImportElement.cs @@ -52,7 +52,7 @@ internal ProjectImportElement(XmlElementWithLocation xmlElement, ProjectRootElem /// public string Project { - get => FileUtilities.FixFilePath(GetAttributeValue(XMakeAttributes.project)); + get => FrameworkFileUtilities.FixFilePath(GetAttributeValue(XMakeAttributes.project)); set { ErrorUtilities.VerifyThrowArgumentLength(value, XMakeAttributes.project); @@ -71,7 +71,7 @@ public string Project /// public string Sdk { - get => FileUtilities.FixFilePath(GetAttributeValue(XMakeAttributes.sdk)); + get => FrameworkFileUtilities.FixFilePath(GetAttributeValue(XMakeAttributes.sdk)); set { ErrorUtilities.VerifyThrowArgumentLength(value, XMakeAttributes.sdk); diff --git a/src/Build/Construction/ProjectRootElement.cs b/src/Build/Construction/ProjectRootElement.cs index 57366d1349b..83a084eb685 100644 --- a/src/Build/Construction/ProjectRootElement.cs +++ b/src/Build/Construction/ProjectRootElement.cs @@ -1256,7 +1256,7 @@ public ProjectTargetElement AddTarget(string name) /// public ProjectUsingTaskElement AddUsingTask(string name, string assemblyFile, string assemblyName) { - ProjectUsingTaskElement usingTask = CreateUsingTaskElement(name, FileUtilities.FixFilePath(assemblyFile), assemblyName); + ProjectUsingTaskElement usingTask = CreateUsingTaskElement(name, FrameworkFileUtilities.FixFilePath(assemblyFile), assemblyName); AppendChild(usingTask); return usingTask; diff --git a/src/Build/Construction/ProjectUsingTaskElement.cs b/src/Build/Construction/ProjectUsingTaskElement.cs index 10e310e5550..cecae44497d 100644 --- a/src/Build/Construction/ProjectUsingTaskElement.cs +++ b/src/Build/Construction/ProjectUsingTaskElement.cs @@ -3,7 +3,7 @@ using System; using System.Diagnostics; - +using Microsoft.Build.Framework; using Microsoft.Build.ObjectModelRemoting; using Microsoft.Build.Shared; @@ -48,14 +48,14 @@ private ProjectUsingTaskElement(XmlElementWithLocation xmlElement, ProjectRootEl /// public string AssemblyFile { - get => FileUtilities.FixFilePath( + get => FrameworkFileUtilities.FixFilePath( GetAttributeValue(XMakeAttributes.assemblyFile)); set { ErrorUtilities.VerifyThrowArgumentLength(value, XMakeAttributes.assemblyName); ErrorUtilities.VerifyThrowInvalidOperation(String.IsNullOrEmpty(AssemblyName), "OM_EitherAttributeButNotBoth", ElementName, XMakeAttributes.assemblyFile, XMakeAttributes.assemblyName); - value = FileUtilities.FixFilePath(value); + value = FrameworkFileUtilities.FixFilePath(value); SetOrRemoveAttribute(XMakeAttributes.assemblyFile, value, "Set usingtask AssemblyFile {0}", value); } } @@ -249,7 +249,7 @@ internal static ProjectUsingTaskElement CreateDisconnected(string taskName, stri if (!String.IsNullOrEmpty(assemblyFile)) { - usingTask.AssemblyFile = FileUtilities.FixFilePath(assemblyFile); + usingTask.AssemblyFile = FrameworkFileUtilities.FixFilePath(assemblyFile); } else { diff --git a/src/Build/Construction/Solution/SolutionProjectGenerator.cs b/src/Build/Construction/Solution/SolutionProjectGenerator.cs index e51789bbb38..c40de4d8294 100644 --- a/src/Build/Construction/Solution/SolutionProjectGenerator.cs +++ b/src/Build/Construction/Solution/SolutionProjectGenerator.cs @@ -1308,7 +1308,7 @@ private string GetMetaprojectName(ProjectInSolution project) baseName = project.ProjectName; } - baseName = FileUtilities.EnsureNoTrailingSlash(baseName); + baseName = FrameworkFileUtilities.EnsureNoTrailingSlash(baseName); return GetMetaprojectName(baseName); } diff --git a/src/Build/Definition/Toolset.cs b/src/Build/Definition/Toolset.cs index 92c8f8320ed..13288066f2c 100644 --- a/src/Build/Definition/Toolset.cs +++ b/src/Build/Definition/Toolset.cs @@ -13,9 +13,8 @@ using Microsoft.Build.Collections; using Microsoft.Build.Construction; using Microsoft.Build.Execution; -#if NET using Microsoft.Build.Framework; -#endif + using Microsoft.Build.Internal; using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; @@ -367,7 +366,7 @@ private set // technically hurt anything, but it doesn't look nice.) string toolsPathToUse = value; - if (FileUtilities.EndsWithSlash(toolsPathToUse)) + if (FrameworkFileUtilities.EndsWithSlash(toolsPathToUse)) { string rootPath = Path.GetPathRoot(Path.GetFullPath(toolsPathToUse)); diff --git a/src/Build/Evaluation/Conditionals/FunctionCallExpressionNode.cs b/src/Build/Evaluation/Conditionals/FunctionCallExpressionNode.cs index 61769eb3da9..a28b263a3e6 100644 --- a/src/Build/Evaluation/Conditionals/FunctionCallExpressionNode.cs +++ b/src/Build/Evaluation/Conditionals/FunctionCallExpressionNode.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.IO; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using TaskItem = Microsoft.Build.Execution.ProjectItemInstance.TaskItem; @@ -119,7 +120,7 @@ private static string ExpandArgumentForScalarParameter(string function, GenericE // Fix path before expansion if (isFilePath) { - argument = FileUtilities.FixFilePath(argument); + argument = FrameworkFileUtilities.FixFilePath(argument); } IList items = state.ExpandIntoTaskItems(argument); @@ -153,7 +154,7 @@ private List ExpandArgumentAsFileList(GenericExpressionNode argumentNode // Fix path before expansion if (isFilePath) { - argument = FileUtilities.FixFilePath(argument); + argument = FrameworkFileUtilities.FixFilePath(argument); } IList expanded = state.ExpandIntoTaskItems(argument); diff --git a/src/Build/Evaluation/Expander.cs b/src/Build/Evaluation/Expander.cs index b40d997fb47..3cb76b64630 100644 --- a/src/Build/Evaluation/Expander.cs +++ b/src/Build/Evaluation/Expander.cs @@ -1713,7 +1713,7 @@ private static object ExpandMSBuildThisFileProperty(string propertyName, IElemen } else if (String.Equals(propertyName, ReservedPropertyNames.thisFileDirectory, StringComparison.OrdinalIgnoreCase)) { - value = FileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(elementLocation.File)); + value = FrameworkFileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(elementLocation.File)); } else if (String.Equals(propertyName, ReservedPropertyNames.thisFileDirectoryNoRoot, StringComparison.OrdinalIgnoreCase)) { @@ -4004,7 +4004,7 @@ internal object Execute(object objectInstance, IPropertyProvider properties, if (_receiverType == typeof(File) || _receiverType == typeof(Directory) || _receiverType == typeof(Path)) { - argumentValue = FileUtilities.FixFilePath(argumentValue); + argumentValue = FrameworkFileUtilities.FixFilePath(argumentValue); } args[n] = EscapingUtilities.UnescapeAll(argumentValue); diff --git a/src/Build/Evaluation/IntrinsicFunctions.cs b/src/Build/Evaluation/IntrinsicFunctions.cs index c464f1b2a05..f0417038f7b 100644 --- a/src/Build/Evaluation/IntrinsicFunctions.cs +++ b/src/Build/Evaluation/IntrinsicFunctions.cs @@ -525,7 +525,7 @@ internal static bool DoesTaskHostExist(string runtime, string architecture) /// The specified path with a trailing slash. internal static string EnsureTrailingSlash(string path) { - return FileUtilities.EnsureTrailingSlash(path); + return FrameworkFileUtilities.EnsureTrailingSlash(path); } /// diff --git a/src/Build/Instance/ProjectItemInstance.cs b/src/Build/Instance/ProjectItemInstance.cs index 696f135412f..2b14dc6b998 100644 --- a/src/Build/Instance/ProjectItemInstance.cs +++ b/src/Build/Instance/ProjectItemInstance.cs @@ -865,8 +865,8 @@ internal TaskItem( ErrorUtilities.VerifyThrowArgumentLength(includeEscaped); ErrorUtilities.VerifyThrowArgumentLength(includeBeforeWildcardExpansionEscaped); - _includeEscaped = FileUtilities.FixFilePath(includeEscaped); - _includeBeforeWildcardExpansionEscaped = FileUtilities.FixFilePath(includeBeforeWildcardExpansionEscaped); + _includeEscaped = FrameworkFileUtilities.FixFilePath(includeEscaped); + _includeBeforeWildcardExpansionEscaped = FrameworkFileUtilities.FixFilePath(includeBeforeWildcardExpansionEscaped); _directMetadata = (directMetadata == null || directMetadata.Count == 0) ? null : directMetadata; // If the metadata was all removed, toss the dictionary _itemDefinitions = itemDefinitions; _projectDirectory = projectDirectory; diff --git a/src/Build/Instance/TaskRegistry.cs b/src/Build/Instance/TaskRegistry.cs index 24d15831948..ccdc34b700f 100644 --- a/src/Build/Instance/TaskRegistry.cs +++ b/src/Build/Instance/TaskRegistry.cs @@ -353,7 +353,7 @@ private static void RegisterTasksFromUsingTaskElement // don't want paths from imported projects being interpreted relative to the main project file. try { - assemblyFile = FileUtilities.FixFilePath(assemblyFile); + assemblyFile = FrameworkFileUtilities.FixFilePath(assemblyFile); if (assemblyFile != null && !Path.IsPathRooted(assemblyFile)) { diff --git a/src/Build/Logging/FileLogger.cs b/src/Build/Logging/FileLogger.cs index a2d306a1341..60fca6f6868 100644 --- a/src/Build/Logging/FileLogger.cs +++ b/src/Build/Logging/FileLogger.cs @@ -198,7 +198,7 @@ private void ApplyFileLoggerParameter(string parameterName, string parameterValu switch (parameterName.ToUpperInvariant()) { case "LOGFILE": - _logFileName = FileUtilities.FixFilePath(parameterValue); + _logFileName = FrameworkFileUtilities.FixFilePath(parameterValue); break; case "APPEND": _append = true; diff --git a/src/Build/Utilities/FileSpecMatchTester.cs b/src/Build/Utilities/FileSpecMatchTester.cs index 15380c2d5a0..76b19b3d1a4 100644 --- a/src/Build/Utilities/FileSpecMatchTester.cs +++ b/src/Build/Utilities/FileSpecMatchTester.cs @@ -5,6 +5,7 @@ using System.Diagnostics; using System.IO; using System.Text.RegularExpressions; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; #nullable disable @@ -131,7 +132,7 @@ private static void CreateRegexOrFilenamePattern(string unescapedFileSpec, strin ? Directory.GetCurrentDirectory() : FileUtilities.GetFullPathNoThrow(absoluteFixedDirPart); - normalizedFixedDirPart = FileUtilities.EnsureTrailingSlash(normalizedFixedDirPart); + normalizedFixedDirPart = FrameworkFileUtilities.EnsureTrailingSlash(normalizedFixedDirPart); var recombinedFileSpec = string.Concat(normalizedFixedDirPart, wildcardDirectoryPart, filenamePart); diff --git a/src/MSBuild/CommandLine/CommandLineParser.cs b/src/MSBuild/CommandLine/CommandLineParser.cs index 913e2dff2f6..8405bf79fc6 100644 --- a/src/MSBuild/CommandLine/CommandLineParser.cs +++ b/src/MSBuild/CommandLine/CommandLineParser.cs @@ -339,7 +339,7 @@ private void GatherResponseFileSwitch(string unquotedCommandLineArg, CommandLine { try { - string responseFile = FileUtilities.FixFilePath(unquotedCommandLineArg.Substring(1)); + string responseFile = FrameworkFileUtilities.FixFilePath(unquotedCommandLineArg.Substring(1)); if (responseFile.Length == 0) { @@ -369,7 +369,7 @@ private void GatherResponseFileSwitch(string unquotedCommandLineArg, CommandLine if (!isRepeatedResponseFile) { - var responseFileDirectory = FileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(responseFile)); + var responseFileDirectory = FrameworkFileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(responseFile)); includedResponseFiles.Add(responseFile); List argsFromResponseFile; @@ -561,7 +561,7 @@ private static string GetProjectDirectory(string[] projectSwitchParameters) if (projectSwitchParameters.Length == 1) { - var projectFile = FileUtilities.FixFilePath(projectSwitchParameters[0]); + var projectFile = FrameworkFileUtilities.FixFilePath(projectSwitchParameters[0]); if (FileSystems.Default.DirectoryExists(projectFile)) { diff --git a/src/MSBuild/XMake.cs b/src/MSBuild/XMake.cs index f73781e4bf6..113f7f0602c 100644 --- a/src/MSBuild/XMake.cs +++ b/src/MSBuild/XMake.cs @@ -3022,7 +3022,7 @@ internal static string ProcessProjectSwitch( if (parameters.Length == 1) { - projectFile = FileUtilities.FixFilePath(parameters[0]); + projectFile = FrameworkFileUtilities.FixFilePath(parameters[0]); if (FileSystems.Default.DirectoryExists(projectFile)) { @@ -3608,7 +3608,7 @@ internal static void ProcessDistributedFileLogger( // Check to see if the logfile parameter has been set, if not set it to the current directory string logFileParameter = ExtractAnyLoggerParameter(fileParameters, "logfile"); - string logFileName = FileUtilities.FixFilePath(ExtractAnyParameterValue(logFileParameter)); + string logFileName = FrameworkFileUtilities.FixFilePath(ExtractAnyParameterValue(logFileParameter)); try { @@ -3872,7 +3872,7 @@ private static LoggerDescription ParseLoggingParameter(string parameter, string } // figure out whether the assembly's identity (strong/weak name), or its filename/path is provided - string testFile = FileUtilities.FixFilePath(loggerAssemblySpec); + string testFile = FrameworkFileUtilities.FixFilePath(loggerAssemblySpec); if (FileSystems.Default.FileExists(testFile)) { loggerAssemblyFile = testFile; @@ -4030,7 +4030,7 @@ private static string ProcessValidateSwitch(string[] parameters) foreach (string parameter in parameters) { InitializationException.VerifyThrow(schemaFile == null, "MultipleSchemasError", parameter); - string fileName = FileUtilities.FixFilePath(parameter); + string fileName = FrameworkFileUtilities.FixFilePath(parameter); InitializationException.VerifyThrow(FileSystems.Default.FileExists(fileName), "SchemaNotFoundError", fileName); schemaFile = Path.Combine(Directory.GetCurrentDirectory(), fileName); diff --git a/src/Shared/FileMatcher.cs b/src/Shared/FileMatcher.cs index 584d0b955d9..d08e6549791 100644 --- a/src/Shared/FileMatcher.cs +++ b/src/Shared/FileMatcher.cs @@ -46,7 +46,7 @@ internal class FileMatcher #endif // on OSX both System.IO.Path separators are '/', so we have to use the literals - internal static readonly char[] directorySeparatorCharacters = FileUtilities.Slashes; + internal static readonly char[] directorySeparatorCharacters = FrameworkFileUtilities.Slashes; // until Cloudbuild switches to EvaluationContext, we need to keep their dependence on global glob caching via an environment variable private static readonly Lazy>> s_cachedGlobExpansions = new Lazy>>(() => new ConcurrentDictionary>(StringComparer.OrdinalIgnoreCase)); @@ -233,7 +233,7 @@ internal static bool HasPropertyOrItemReferences(string filespec) /// private static IReadOnlyList GetAccessibleFileSystemEntries(IFileSystem fileSystem, FileSystemEntity entityType, string path, string pattern, string projectDirectory, bool stripProjectDirectory) { - path = FileUtilities.FixFilePath(path); + path = FrameworkFileUtilities.FixFilePath(path); switch (entityType) { case FileSystemEntity.Files: return GetAccessibleFiles(fileSystem, path, pattern, projectDirectory, stripProjectDirectory); @@ -592,7 +592,7 @@ private static void PreprocessFileSpecForSplitting( out string wildcardDirectoryPart, out string filenamePart) { - filespec = FileUtilities.FixFilePath(filespec); + filespec = FrameworkFileUtilities.FixFilePath(filespec); int indexOfLastDirectorySeparator = filespec.LastIndexOfAny(directorySeparatorCharacters); if (-1 == indexOfLastDirectorySeparator) { @@ -2145,7 +2145,7 @@ private SearchAction GetFileSearchData( wildcard[wildcardLength - 1] == '*') { // Check that there are no other slashes in the wildcard. - if (wildcard.IndexOfAny(FileUtilities.Slashes, 3, wildcardLength - 6) == -1) + if (wildcard.IndexOfAny(FrameworkFileUtilities.Slashes, 3, wildcardLength - 6) == -1) { directoryPattern = wildcard.Substring(3, wildcardLength - 6); } @@ -2679,7 +2679,7 @@ private static bool IsSubdirectoryOf(string possibleChild, string possibleParent /// True in case of a match (e.g. directoryPath = "dir/subdir" and pattern = "s*"), false otherwise. private static bool DirectoryEndsWithPattern(string directoryPath, string pattern) { - int index = directoryPath.LastIndexOfAny(FileUtilities.Slashes); + int index = directoryPath.LastIndexOfAny(FrameworkFileUtilities.Slashes); return (index != -1 && IsMatch(directoryPath.AsSpan(index + 1), pattern)); } diff --git a/src/Shared/FileUtilities.cs b/src/Shared/FileUtilities.cs index 91c5611fc18..0ca435b0137 100644 --- a/src/Shared/FileUtilities.cs +++ b/src/Shared/FileUtilities.cs @@ -143,8 +143,6 @@ public static bool GetIsFileSystemCaseSensitive() internal static char[] InvalidFileNameChars => InvalidFileNameCharsArray; #endif - internal static readonly char[] Slashes = FrameworkFileUtilities.Slashes; - internal static readonly string DirectorySeparatorString = Path.DirectorySeparatorChar.ToString(); private static readonly ConcurrentDictionary FileExistenceCache = new ConcurrentDictionary(StringComparer.OrdinalIgnoreCase); @@ -240,14 +238,6 @@ internal static void ClearCacheDirectory() } } - /// - /// If the given path doesn't have a trailing slash then add one. - /// If the path is an empty string, does not modify it. - /// - /// The path to check. - /// A path with a slash. - internal static string EnsureTrailingSlash(string fileSpec) => FrameworkFileUtilities.EnsureTrailingSlash(fileSpec); - /// /// Ensures the path does not have a leading or trailing slash after removing the first 'start' characters. /// @@ -286,11 +276,6 @@ internal static string EnsureTrailingNoLeadingSlash(string path, int start) #endif } - /// - /// Ensures the path does not have a trailing slash. - /// - internal static string EnsureNoTrailingSlash(string path) => FrameworkFileUtilities.EnsureNoTrailingSlash(path); - /// /// Ensures the path is enclosed within single quotes. /// @@ -319,7 +304,7 @@ internal static string EnsureDoubleQuotes(string path) /// The path enclosed by quotes. internal static string EnsureQuotes(string path, bool isSingleQuote = true) { - path = FixFilePath(path); + path = FrameworkFileUtilities.FixFilePath(path); const char singleQuote = '\''; const char doubleQuote = '\"'; @@ -347,20 +332,6 @@ internal static string EnsureQuotes(string path, bool isSingleQuote = true) return path; } - /// - /// Indicates if the given file-spec ends with a slash. - /// - /// The file spec. - /// true, if file-spec has trailing slash - internal static bool EndsWithSlash(string fileSpec) => FrameworkFileUtilities.EndsWithSlash(fileSpec); - - /// - /// Indicates if the given character is a slash. - /// - /// - /// true, if slash - internal static bool IsSlash(char c) => FrameworkFileUtilities.IsSlash(c); - /// /// Trims the string and removes any double quotes around it. /// @@ -393,7 +364,7 @@ internal static String GetDirectoryNameOfFullPath(String fullPath) ; } - return FixFilePath(fullPath.Substring(0, i)); + return FrameworkFileUtilities.FixFilePath(fullPath.Substring(0, i)); } return null; } @@ -404,7 +375,7 @@ internal static string TruncatePathToTrailingSegments(string path, int trailingS ErrorUtilities.VerifyThrowInternalLength(path, nameof(path)); ErrorUtilities.VerifyThrow(trailingSegmentsToKeep >= 0, "trailing segments must be positive"); - var segments = path.Split(Slashes, StringSplitOptions.RemoveEmptyEntries); + var segments = path.Split(FrameworkFileUtilities.Slashes, StringSplitOptions.RemoveEmptyEntries); var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep); @@ -475,7 +446,7 @@ internal static string NormalizePath(string path) { ErrorUtilities.VerifyThrowArgumentLength(path); string fullPath = GetFullPath(path); - return FixFilePath(fullPath); + return FrameworkFileUtilities.FixFilePath(fullPath); } internal static string NormalizePath(string directory, string file) @@ -552,11 +523,9 @@ From Path.cs in the CLR } #endif // FEATURE_LEGACY_GETFULLPATH - internal static string FixFilePath(string path) => FrameworkFileUtilities.FixFilePath(path); - /// /// Normalizes all path separators (both forward and back slashes) to forward slashes. - /// This is platform-independent, unlike FixFilePath which only normalizes on non-Windows platforms. + /// This is platform-independent, unlike FrameworkFileUtilities.FixFilePath which only normalizes on non-Windows platforms. /// Use this when you need consistent path comparison regardless of which separator style is used. /// /// The path to normalize @@ -713,7 +682,7 @@ internal static bool LooksLikeUnixFilePath(ReadOnlySpan value, string base /// directory path internal static string GetDirectory(string fileSpec) { - string directory = Path.GetDirectoryName(FixFilePath(fileSpec)); + string directory = Path.GetDirectoryName(FrameworkFileUtilities.FixFilePath(fileSpec)); // if file-spec is a root directory e.g. c:, c:\, \, \\server\share // NOTE: Path.GetDirectoryName also treats invalid UNC file-specs as root directories e.g. \\, \\server @@ -722,7 +691,7 @@ internal static string GetDirectory(string fileSpec) // just use the file-spec as-is directory = fileSpec; } - else if ((directory.Length > 0) && !EndsWithSlash(directory)) + else if ((directory.Length > 0) && !FrameworkFileUtilities.EndsWithSlash(directory)) { // restore trailing slash if Path.GetDirectoryName has removed it (this happens with non-root directories) directory += Path.DirectorySeparatorChar; @@ -807,7 +776,7 @@ internal static bool HasExtension(string fileName, string[] allowedExtensions) internal static string GetFullPath(string fileSpec, string currentDirectory, bool escape = true) { // Sending data out of the engine into the filesystem, so time to unescape. - fileSpec = FixFilePath(EscapingUtilities.UnescapeAll(fileSpec)); + fileSpec = FrameworkFileUtilities.FixFilePath(EscapingUtilities.UnescapeAll(fileSpec)); string fullPath = NormalizePath(Path.Combine(currentDirectory, fileSpec)); // In some cases we might want to NOT escape in order to preserve symbols like @, %, $ etc. @@ -817,7 +786,7 @@ internal static string GetFullPath(string fileSpec, string currentDirectory, boo fullPath = EscapingUtilities.Escape(fullPath); } - if (NativeMethodsShared.IsWindows && !EndsWithSlash(fullPath)) + if (NativeMethodsShared.IsWindows && !FrameworkFileUtilities.EndsWithSlash(fullPath)) { if (FileUtilitiesRegex.IsDrivePattern(fileSpec) || FileUtilitiesRegex.IsUncPattern(fullPath)) @@ -900,13 +869,13 @@ internal static bool PathIsInvalid(string path) #if NET if (!path.AsSpan().ContainsAny(InvalidPathChars)) { - int lastDirectorySeparator = path.LastIndexOfAny(Slashes); + int lastDirectorySeparator = path.LastIndexOfAny(FrameworkFileUtilities.Slashes); return path.AsSpan(lastDirectorySeparator >= 0 ? lastDirectorySeparator + 1 : 0).ContainsAny(InvalidFileNameChars); } #else if (path.IndexOfAny(InvalidPathChars) < 0) { - int lastDirectorySeparator = path.LastIndexOfAny(Slashes); + int lastDirectorySeparator = path.LastIndexOfAny(FrameworkFileUtilities.Slashes); return path.IndexOfAny(InvalidFileNameChars, lastDirectorySeparator >= 0 ? lastDirectorySeparator + 1 : 0) >= 0; } #endif @@ -920,7 +889,7 @@ internal static void DeleteNoThrow(string path) { try { - File.Delete(FixFilePath(path)); + File.Delete(FrameworkFileUtilities.FixFilePath(path)); } catch (Exception ex) when (ExceptionHandling.IsIoRelatedException(ex)) { @@ -947,7 +916,7 @@ internal static void DeleteDirectoryNoThrow(string path, bool recursive, int ret retryCount = retryCount < 1 ? 2 : retryCount; retryTimeOut = retryTimeOut < 1 ? 500 : retryTimeOut; - path = FixFilePath(path); + path = FrameworkFileUtilities.FixFilePath(path); for (int i = 0; i < retryCount; i++) { @@ -986,7 +955,7 @@ internal static void DeleteWithoutTrailingBackslash(string path, bool recursive { try { - Directory.Delete(EnsureNoTrailingSlash(path), recursive); + Directory.Delete(FrameworkFileUtilities.EnsureNoTrailingSlash(path), recursive); // If we got here, the directory was successfully deleted return; @@ -1214,7 +1183,7 @@ internal static string MakeRelative(string basePath, string path) if (path.IndexOf(splitPath[0]) != indexOfFirstNonSlashChar) { // path was already relative so just return it - return FixFilePath(path); + return FrameworkFileUtilities.FixFilePath(path); } int index = 0; @@ -1265,7 +1234,7 @@ internal static string AttemptToShortenPath(string path) // Attempt to make it shorter -- perhaps there are some \..\ elements path = GetFullPathNoThrow(path); } - return FixFilePath(path); + return FrameworkFileUtilities.FixFilePath(path); } public static bool IsPathTooLong(string path) @@ -1289,7 +1258,7 @@ private static bool IsRootedNoThrow(string path) { try { - return Path.IsPathRooted(FixFilePath(path)); + return Path.IsPathRooted(FrameworkFileUtilities.FixFilePath(path)); } catch (Exception ex) when (ExceptionHandling.IsIoRelatedException(ex)) { @@ -1340,7 +1309,7 @@ internal static string CombinePaths(string root, params string[] paths) internal static string TrimTrailingSlashes(this string s) { - return s.TrimEnd(Slashes); + return s.TrimEnd(FrameworkFileUtilities.Slashes); } /// @@ -1370,7 +1339,7 @@ internal static string ToPlatformSlash(this string s) internal static string WithTrailingSlash(this string s) { - return EnsureTrailingSlash(s); + return FrameworkFileUtilities.EnsureTrailingSlash(s); } internal static string NormalizeForPathComparison(this string s) => s.ToPlatformSlash().TrimTrailingSlashes(); diff --git a/src/Shared/FrameworkLocationHelper.cs b/src/Shared/FrameworkLocationHelper.cs index 951dcbb70d7..a7e5d74b727 100644 --- a/src/Shared/FrameworkLocationHelper.cs +++ b/src/Shared/FrameworkLocationHelper.cs @@ -7,6 +7,8 @@ using System.IO; using System.Linq; using System.Runtime.Versioning; +using Microsoft.Build.Framework; + #if FEATURE_WIN32_REGISTRY using Microsoft.Win32; #endif @@ -1572,7 +1574,7 @@ public virtual string GetPathToDotNetFrameworkReferenceAssemblies() string referencePath = GenerateReferenceAssemblyPath(FrameworkLocationHelper.programFilesReferenceAssemblyLocation, this.FrameworkName); if (FileSystems.Default.DirectoryExists(referencePath)) { - this._pathToDotNetFrameworkReferenceAssemblies = FileUtilities.EnsureTrailingSlash(referencePath); + this._pathToDotNetFrameworkReferenceAssemblies = FrameworkFileUtilities.EnsureTrailingSlash(referencePath); } } diff --git a/src/Shared/Modifiers.cs b/src/Shared/Modifiers.cs index 44786c43e21..5e17fc8b41d 100644 --- a/src/Shared/Modifiers.cs +++ b/src/Shared/Modifiers.cs @@ -9,6 +9,7 @@ #endif using System.Diagnostics.CodeAnalysis; using System.IO; +using Microsoft.Build.Framework; using Microsoft.Build.Shared.FileSystem; #nullable disable @@ -213,7 +214,7 @@ internal static string GetItemSpecModifier(string currentDirectory, string itemS modifiedItemSpec = Path.GetPathRoot(fullPath); - if (!EndsWithSlash(modifiedItemSpec)) + if (!FrameworkFileUtilities.EndsWithSlash(modifiedItemSpec)) { ErrorUtilities.VerifyThrow(FileUtilitiesRegex.StartsWithUncPattern(modifiedItemSpec), "Only UNC shares should be missing trailing slashes."); @@ -235,7 +236,7 @@ internal static string GetItemSpecModifier(string currentDirectory, string itemS else { // Fix path to avoid problem with Path.GetFileNameWithoutExtension when backslashes in itemSpec on Unix - modifiedItemSpec = Path.GetFileNameWithoutExtension(FixFilePath(itemSpec)); + modifiedItemSpec = Path.GetFileNameWithoutExtension(FrameworkFileUtilities.FixFilePath(itemSpec)); } } else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.Extension, StringComparison.OrdinalIgnoreCase)) @@ -276,7 +277,7 @@ internal static string GetItemSpecModifier(string currentDirectory, string itemS if (length != -1) { - ErrorUtilities.VerifyThrow((modifiedItemSpec.Length > length) && IsSlash(modifiedItemSpec[length]), + ErrorUtilities.VerifyThrow((modifiedItemSpec.Length > length) && FrameworkFileUtilities.IsSlash(modifiedItemSpec[length]), "Root directory must have a trailing slash."); modifiedItemSpec = modifiedItemSpec.Substring(length + 1); @@ -284,7 +285,7 @@ internal static string GetItemSpecModifier(string currentDirectory, string itemS } else { - ErrorUtilities.VerifyThrow(!string.IsNullOrEmpty(modifiedItemSpec) && IsSlash(modifiedItemSpec[0]), + ErrorUtilities.VerifyThrow(!string.IsNullOrEmpty(modifiedItemSpec) && FrameworkFileUtilities.IsSlash(modifiedItemSpec[0]), "Expected a full non-windows path rooted at '/'."); // A full unix path is always rooted at diff --git a/src/Shared/TempFileUtilities.cs b/src/Shared/TempFileUtilities.cs index 909b9863dc1..3533bf22763 100644 --- a/src/Shared/TempFileUtilities.cs +++ b/src/Shared/TempFileUtilities.cs @@ -5,6 +5,7 @@ using System.IO; using System.Runtime.CompilerServices; using System.Threading; +using Microsoft.Build.Framework; using Microsoft.Build.Shared.FileSystem; #nullable disable @@ -70,7 +71,7 @@ private static string CreateFolderUnderTemp() Directory.CreateDirectory(path); #endif - return FileUtilities.EnsureTrailingSlash(path); + return FrameworkFileUtilities.EnsureTrailingSlash(path); } /// diff --git a/src/Shared/UnitTests/FileMatcher_Tests.cs b/src/Shared/UnitTests/FileMatcher_Tests.cs index c0bea972965..dc90922a428 100644 --- a/src/Shared/UnitTests/FileMatcher_Tests.cs +++ b/src/Shared/UnitTests/FileMatcher_Tests.cs @@ -1873,8 +1873,8 @@ public void GetFileSpecInfoCommon( { if (NativeMethodsShared.IsUnixLike) { - expectedFixedDirectoryPart = FileUtilities.FixFilePath(expectedFixedDirectoryPart); - expectedWildcardDirectoryPart = FileUtilities.FixFilePath(expectedWildcardDirectoryPart); + expectedFixedDirectoryPart = FrameworkFileUtilities.FixFilePath(expectedFixedDirectoryPart); + expectedWildcardDirectoryPart = FrameworkFileUtilities.FixFilePath(expectedWildcardDirectoryPart); } TestGetFileSpecInfo( filespec, @@ -2299,11 +2299,11 @@ private bool IsMatchingDirectory(string path, string candidate) { if (String.Compare(normalizedPath, 0, normalizedCandidate, 0, normalizedPath.Length, StringComparison.OrdinalIgnoreCase) == 0) { - if (FileUtilities.EndsWithSlash(normalizedPath)) + if (FrameworkFileUtilities.EndsWithSlash(normalizedPath)) { return true; } - else if (FileUtilities.IsSlash(normalizedCandidate[normalizedPath.Length])) + else if (FrameworkFileUtilities.IsSlash(normalizedCandidate[normalizedPath.Length])) { return true; } @@ -2508,9 +2508,9 @@ private static void ValidateSplitFileSpec( out wildcardDirectoryPart, out filenamePart); - expectedFixedDirectoryPart = FileUtilities.FixFilePath(expectedFixedDirectoryPart); - expectedWildcardDirectoryPart = FileUtilities.FixFilePath(expectedWildcardDirectoryPart); - expectedFilenamePart = FileUtilities.FixFilePath(expectedFilenamePart); + expectedFixedDirectoryPart = FrameworkFileUtilities.FixFilePath(expectedFixedDirectoryPart); + expectedWildcardDirectoryPart = FrameworkFileUtilities.FixFilePath(expectedWildcardDirectoryPart); + expectedFilenamePart = FrameworkFileUtilities.FixFilePath(expectedFilenamePart); if ( diff --git a/src/Shared/UnitTests/FileUtilities_Tests.cs b/src/Shared/UnitTests/FileUtilities_Tests.cs index 92d25812ac4..b7e677e2e4a 100644 --- a/src/Shared/UnitTests/FileUtilities_Tests.cs +++ b/src/Shared/UnitTests/FileUtilities_Tests.cs @@ -6,6 +6,7 @@ using System.IO; using System.Linq; using System.Threading; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Shouldly; using Xunit; @@ -211,27 +212,27 @@ public void GetFileInfoNoThrowNonexistent() } /// - /// Exercises FileUtilities.EndsWithSlash + /// Exercises FrameworkFileUtilities.EndsWithSlash /// [Fact] [Trait("Category", "netcore-osx-failing")] [Trait("Category", "netcore-linux-failing")] public void EndsWithSlash() { - Assert.True(FileUtilities.EndsWithSlash(@"C:\foo\")); - Assert.True(FileUtilities.EndsWithSlash(@"C:\")); - Assert.True(FileUtilities.EndsWithSlash(@"\")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"C:\foo\")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"C:\")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"\")); - Assert.True(FileUtilities.EndsWithSlash(@"http://www.microsoft.com/")); - Assert.True(FileUtilities.EndsWithSlash(@"//server/share/")); - Assert.True(FileUtilities.EndsWithSlash(@"/")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"http://www.microsoft.com/")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"//server/share/")); + Assert.True(FrameworkFileUtilities.EndsWithSlash(@"/")); - Assert.False(FileUtilities.EndsWithSlash(@"C:\foo")); - Assert.False(FileUtilities.EndsWithSlash(@"C:")); - Assert.False(FileUtilities.EndsWithSlash(@"foo")); + Assert.False(FrameworkFileUtilities.EndsWithSlash(@"C:\foo")); + Assert.False(FrameworkFileUtilities.EndsWithSlash(@"C:")); + Assert.False(FrameworkFileUtilities.EndsWithSlash(@"foo")); // confirm that empty string doesn't barf - Assert.False(FileUtilities.EndsWithSlash(String.Empty)); + Assert.False(FrameworkFileUtilities.EndsWithSlash(String.Empty)); } /// @@ -245,16 +246,16 @@ public void GetDirectoryWithTrailingSlash() Assert.Equal(NativeMethodsShared.IsWindows ? @"c:\" : "/", FileUtilities.GetDirectory(NativeMethodsShared.IsWindows ? @"c:\" : "/")); Assert.Equal(NativeMethodsShared.IsWindows ? @"c:\" : "/", FileUtilities.GetDirectory(NativeMethodsShared.IsWindows ? @"c:\foo" : "/foo")); Assert.Equal(NativeMethodsShared.IsWindows ? @"c:" : "/", FileUtilities.GetDirectory(NativeMethodsShared.IsWindows ? @"c:" : "/")); - Assert.Equal(FileUtilities.FixFilePath(@"\"), FileUtilities.GetDirectory(@"\")); - Assert.Equal(FileUtilities.FixFilePath(@"\"), FileUtilities.GetDirectory(@"\foo")); - Assert.Equal(FileUtilities.FixFilePath(@"..\"), FileUtilities.GetDirectory(@"..\foo")); - Assert.Equal(FileUtilities.FixFilePath(@"\foo\"), FileUtilities.GetDirectory(@"\foo\")); - Assert.Equal(FileUtilities.FixFilePath(@"\\server\share"), FileUtilities.GetDirectory(@"\\server\share")); - Assert.Equal(FileUtilities.FixFilePath(@"\\server\share\"), FileUtilities.GetDirectory(@"\\server\share\")); - Assert.Equal(FileUtilities.FixFilePath(@"\\server\share\"), FileUtilities.GetDirectory(@"\\server\share\file")); - Assert.Equal(FileUtilities.FixFilePath(@"\\server\share\directory\"), FileUtilities.GetDirectory(@"\\server\share\directory\")); - Assert.Equal(FileUtilities.FixFilePath(@"foo\"), FileUtilities.GetDirectory(@"foo\bar")); - Assert.Equal(FileUtilities.FixFilePath(@"\foo\bar\"), FileUtilities.GetDirectory(@"\foo\bar\")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\"), FileUtilities.GetDirectory(@"\")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\"), FileUtilities.GetDirectory(@"\foo")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"..\"), FileUtilities.GetDirectory(@"..\foo")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\foo\"), FileUtilities.GetDirectory(@"\foo\")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\\server\share"), FileUtilities.GetDirectory(@"\\server\share")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\\server\share\"), FileUtilities.GetDirectory(@"\\server\share\")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\\server\share\"), FileUtilities.GetDirectory(@"\\server\share\file")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\\server\share\directory\"), FileUtilities.GetDirectory(@"\\server\share\directory\")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\"), FileUtilities.GetDirectory(@"foo\bar")); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"\foo\bar\"), FileUtilities.GetDirectory(@"\foo\bar\")); Assert.Equal(String.Empty, FileUtilities.GetDirectory("foo")); } @@ -315,20 +316,20 @@ public void HasExtension_UsesOrdinalIgnoreCase() } /// - /// Exercises FileUtilities.EnsureTrailingSlash + /// Exercises FrameworkFileUtilities.EnsureTrailingSlash /// [Fact] public void EnsureTrailingSlash() { // Doesn't have a trailing slash to start with. - Assert.Equal(FileUtilities.FixFilePath(@"foo\bar\"), FileUtilities.EnsureTrailingSlash(@"foo\bar")); // "test 1" - Assert.Equal(FileUtilities.FixFilePath(@"foo/bar\"), FileUtilities.EnsureTrailingSlash(@"foo/bar")); // "test 2" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\bar\"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo\bar")); // "test 1" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo/bar\"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo/bar")); // "test 2" // Already has a trailing slash to start with. - Assert.Equal(FileUtilities.FixFilePath(@"foo/bar/"), FileUtilities.EnsureTrailingSlash(@"foo/bar/")); // test 3" - Assert.Equal(FileUtilities.FixFilePath(@"foo\bar\"), FileUtilities.EnsureTrailingSlash(@"foo\bar\")); // test 4" - Assert.Equal(FileUtilities.FixFilePath(@"foo/bar\"), FileUtilities.EnsureTrailingSlash(@"foo/bar\")); // test 5" - Assert.Equal(FileUtilities.FixFilePath(@"foo\bar/"), FileUtilities.EnsureTrailingSlash(@"foo\bar/")); // "test 5" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo/bar/"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo/bar/")); // test 3" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\bar\"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo\bar\")); // test 4" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo/bar\"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo/bar\")); // test 5" + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\bar/"), FrameworkFileUtilities.EnsureTrailingSlash(@"foo\bar/")); // "test 5" } /// diff --git a/src/Tasks.UnitTests/CodeTaskFactoryTests.cs b/src/Tasks.UnitTests/CodeTaskFactoryTests.cs index 2ab31ff10f8..3b9b1740d64 100644 --- a/src/Tasks.UnitTests/CodeTaskFactoryTests.cs +++ b/src/Tasks.UnitTests/CodeTaskFactoryTests.cs @@ -1206,15 +1206,15 @@ public void BuildTaskSimpleCodeFactoryTempDirectoryDoesntExist() { // Ensure we're getting the right temp path (%TMP% == GetTempPath()) Assert.Equal( - FileUtilities.EnsureTrailingSlash(Path.GetTempPath()), - FileUtilities.EnsureTrailingSlash(Path.GetFullPath(oldTempPath))); + FrameworkFileUtilities.EnsureTrailingSlash(Path.GetTempPath()), + FrameworkFileUtilities.EnsureTrailingSlash(Path.GetFullPath(oldTempPath))); Assert.False(Directory.Exists(newTempPath)); Environment.SetEnvironmentVariable("TMP", newTempPath); Assert.Equal( - FileUtilities.EnsureTrailingSlash(newTempPath), - FileUtilities.EnsureTrailingSlash(Path.GetTempPath())); + FrameworkFileUtilities.EnsureTrailingSlash(newTempPath), + FrameworkFileUtilities.EnsureTrailingSlash(Path.GetTempPath())); MockLogger mockLogger = Helpers.BuildProjectWithNewOMExpectSuccess(projectFileContents); mockLogger.AssertLogContains("Hello, World!"); diff --git a/src/Tasks.UnitTests/Copy_Tests.cs b/src/Tasks.UnitTests/Copy_Tests.cs index c73787e160a..eb43a13be6a 100644 --- a/src/Tasks.UnitTests/Copy_Tests.cs +++ b/src/Tasks.UnitTests/Copy_Tests.cs @@ -2448,8 +2448,8 @@ public void SuccessAfterOneRetryContinueToNextFile(bool isUseHardLinks, bool isU engine.AssertLogDoesntContain("MSB3027"); // Copy calls to different destinations can come in any order when running in parallel. - Assert.Contains(copyFunctor.FilesCopiedSuccessfully, f => f.Name == FileUtilities.FixFilePath("c:\\source")); - Assert.Contains(copyFunctor.FilesCopiedSuccessfully, f => f.Name == FileUtilities.FixFilePath("c:\\source2")); + Assert.Contains(copyFunctor.FilesCopiedSuccessfully, f => f.Name == FrameworkFileUtilities.FixFilePath("c:\\source")); + Assert.Contains(copyFunctor.FilesCopiedSuccessfully, f => f.Name == FrameworkFileUtilities.FixFilePath("c:\\source2")); } /// diff --git a/src/Tasks.UnitTests/CreateCSharpManifestResourceName_Tests.cs b/src/Tasks.UnitTests/CreateCSharpManifestResourceName_Tests.cs index a29f5b938fc..c0b37c2f639 100644 --- a/src/Tasks.UnitTests/CreateCSharpManifestResourceName_Tests.cs +++ b/src/Tasks.UnitTests/CreateCSharpManifestResourceName_Tests.cs @@ -326,7 +326,7 @@ public void CulturedBitmapWithRootNamespace() binaryStream: null, log: null); - Assert.Equal(FileUtilities.FixFilePath(@"fr\RootNamespace.SubFolder.SplashScreen.bmp"), result); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"fr\RootNamespace.SubFolder.SplashScreen.bmp"), result); } /// diff --git a/src/Tasks.UnitTests/CreateVisualBasicManifestResourceName_Tests.cs b/src/Tasks.UnitTests/CreateVisualBasicManifestResourceName_Tests.cs index 567eea82ab6..d7ce809ecfa 100644 --- a/src/Tasks.UnitTests/CreateVisualBasicManifestResourceName_Tests.cs +++ b/src/Tasks.UnitTests/CreateVisualBasicManifestResourceName_Tests.cs @@ -217,7 +217,7 @@ public void RootnamespaceWithCulture() { string result = CreateVisualBasicManifestResourceName.CreateManifestNameImpl( - fileName: FileUtilities.FixFilePath(@"SubFolder\MyForm.en-GB.ResX"), + fileName: FrameworkFileUtilities.FixFilePath(@"SubFolder\MyForm.en-GB.ResX"), linkFileName: null, // Link file name prependCultureAsDirectory: @@ -283,7 +283,7 @@ public void BitmapWithRootNamespace() { string result = CreateVisualBasicManifestResourceName.CreateManifestNameImpl( - fileName: FileUtilities.FixFilePath(@"SubFolder\SplashScreen.bmp"), + fileName: FrameworkFileUtilities.FixFilePath(@"SubFolder\SplashScreen.bmp"), linkFileName: null, // Link file name prependCultureAsDirectory: true, rootNamespace: "RootNamespace", // Root namespace @@ -303,7 +303,7 @@ public void CulturedBitmapWithRootNamespace() { string result = CreateVisualBasicManifestResourceName.CreateManifestNameImpl( - fileName: FileUtilities.FixFilePath(@"SubFolder\SplashScreen.fr.bmp"), + fileName: FrameworkFileUtilities.FixFilePath(@"SubFolder\SplashScreen.fr.bmp"), linkFileName: null, // Link file name prependCultureAsDirectory: true, rootNamespace: "RootNamespace", // Root namespace @@ -312,7 +312,7 @@ public void CulturedBitmapWithRootNamespace() binaryStream: null, log: null); - Assert.Equal(FileUtilities.FixFilePath(@"fr\RootNamespace.SplashScreen.bmp"), result); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"fr\RootNamespace.SplashScreen.bmp"), result); } /// @@ -323,7 +323,7 @@ public void CulturedBitmapWithRootNamespaceNoDirectoryPrefix() { string result = CreateVisualBasicManifestResourceName.CreateManifestNameImpl( - fileName: FileUtilities.FixFilePath(@"SubFolder\SplashScreen.fr.bmp"), + fileName: FrameworkFileUtilities.FixFilePath(@"SubFolder\SplashScreen.fr.bmp"), linkFileName: null, // Link file name prependCultureAsDirectory: false, rootNamespace: "RootNamespace", // Root namespace @@ -614,7 +614,7 @@ public void CulturedResourcesFileWithRootNamespaceWithinSubfolder() { string result = CreateVisualBasicManifestResourceName.CreateManifestNameImpl( - fileName: FileUtilities.FixFilePath(@"SubFolder\MyResource.fr.resources"), + fileName: FrameworkFileUtilities.FixFilePath(@"SubFolder\MyResource.fr.resources"), linkFileName: null, // Link file name prependCultureAsDirectory: false, rootNamespace: "RootNamespace", // Root namespace diff --git a/src/Tasks.UnitTests/FindAppConfigFile_Tests.cs b/src/Tasks.UnitTests/FindAppConfigFile_Tests.cs index 0965bb7c461..7f6a1a10600 100644 --- a/src/Tasks.UnitTests/FindAppConfigFile_Tests.cs +++ b/src/Tasks.UnitTests/FindAppConfigFile_Tests.cs @@ -48,7 +48,7 @@ public void FoundInSecondBelowProjectDirectory() f.SecondaryList = new ITaskItem[] { new TaskItem("foo\\app.config"), new TaskItem("xxx") }; f.TargetPath = "targetpath"; Assert.True(f.Execute()); - Assert.Equal(FileUtilities.FixFilePath("foo\\app.config"), f.AppConfigFile.ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath("foo\\app.config"), f.AppConfigFile.ItemSpec); Assert.Equal("targetpath", f.AppConfigFile.GetMetadata("TargetPath")); } @@ -74,7 +74,7 @@ public void MatchFileNameOnlyWithAnInvalidPath() f.TargetPath = "targetpath"; Assert.True(f.Execute()); // Should ignore the invalid paths - Assert.Equal(FileUtilities.FixFilePath(@"foo\\app.config"), f.AppConfigFile.ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\\app.config"), f.AppConfigFile.ItemSpec); } // For historical reasons, we should return the last one in the list diff --git a/src/Tasks.UnitTests/FindInList_Tests.cs b/src/Tasks.UnitTests/FindInList_Tests.cs index c051964fdfa..6cdece8d848 100644 --- a/src/Tasks.UnitTests/FindInList_Tests.cs +++ b/src/Tasks.UnitTests/FindInList_Tests.cs @@ -117,7 +117,7 @@ public void MatchFileNameOnly() f.MatchFileNameOnly = true; f.List = new ITaskItem[] { new TaskItem(@"c:\foo\a.cs"), new TaskItem("b.cs") }; Assert.True(f.Execute()); - Assert.Equal(FileUtilities.FixFilePath(@"c:\foo\a.cs"), f.ItemFound.ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"c:\foo\a.cs"), f.ItemFound.ItemSpec); } [Fact] @@ -132,7 +132,7 @@ public void MatchFileNameOnlyWithAnInvalidPath() Assert.True(f.Execute()); Console.WriteLine(e.Log); // Should ignore the invalid paths - Assert.Equal(FileUtilities.FixFilePath(@"foo\a.cs"), f.ItemFound.ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"foo\a.cs"), f.ItemFound.ItemSpec); } } } diff --git a/src/Tasks.UnitTests/FindUnderPath_Tests.cs b/src/Tasks.UnitTests/FindUnderPath_Tests.cs index 5b38b678b58..614a83b2202 100644 --- a/src/Tasks.UnitTests/FindUnderPath_Tests.cs +++ b/src/Tasks.UnitTests/FindUnderPath_Tests.cs @@ -31,8 +31,8 @@ public void BasicFilter() Assert.True(success); Assert.Single(t.InPath); Assert.Single(t.OutOfPath); - Assert.Equal(FileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); - Assert.Equal(FileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); + Assert.Equal(FrameworkFileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); } [WindowsFullFrameworkOnlyFact(additionalMessage: ".NET Core 2.1+ no longer validates paths: https://github.com/dotnet/corefx/issues/27779#issuecomment-371253486. On Unix there is no invalid file name characters.")] diff --git a/src/Tasks/AssemblyDependency/ReferenceTable.cs b/src/Tasks/AssemblyDependency/ReferenceTable.cs index ea9ccab8e6c..1c68ec4d840 100644 --- a/src/Tasks/AssemblyDependency/ReferenceTable.cs +++ b/src/Tasks/AssemblyDependency/ReferenceTable.cs @@ -1720,7 +1720,7 @@ private bool FindAssociatedFiles() { // We don't look for associated files for FX assemblies. bool hasFrameworkPath = false; - string referenceDirectoryName = FileUtilities.EnsureTrailingSlash(reference.DirectoryName); + string referenceDirectoryName = FrameworkFileUtilities.EnsureTrailingSlash(reference.DirectoryName); foreach (string frameworkPath in _frameworkPaths) { @@ -2768,7 +2768,7 @@ private ITaskItem SetItemMetadata(List relatedItems, List // Set up the satellites. foreach (string satelliteFile in satellites) { - relatedItemBase.SetMetadata(ItemMetadataNames.destinationSubDirectory, FileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(satelliteFile))); + relatedItemBase.SetMetadata(ItemMetadataNames.destinationSubDirectory, FrameworkFileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(satelliteFile))); AddRelatedItem(satelliteItems, relatedItemBase, Path.Combine(reference.DirectoryName, satelliteFile)); } } diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs index 30d999a4ec4..9c685aa4bbb 100644 --- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs +++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs @@ -2246,7 +2246,7 @@ internal bool Execute( { for (int i = 0; i < _targetFrameworkDirectories.Length; i++) { - _targetFrameworkDirectories[i] = FileUtilities.EnsureTrailingSlash(_targetFrameworkDirectories[i]); + _targetFrameworkDirectories[i] = FrameworkFileUtilities.EnsureTrailingSlash(_targetFrameworkDirectories[i]); } } diff --git a/src/Tasks/AssignTargetPath.cs b/src/Tasks/AssignTargetPath.cs index 1c9ca3d5c38..5e3cda7c794 100644 --- a/src/Tasks/AssignTargetPath.cs +++ b/src/Tasks/AssignTargetPath.cs @@ -55,7 +55,7 @@ public override bool Execute() string fullRootPath = Path.GetFullPath(RootFolder); // Ensure trailing slash otherwise c:\bin appears to match part of c:\bin2\foo - fullRootPath = FileUtilities.EnsureTrailingSlash(fullRootPath); + fullRootPath = FrameworkFileUtilities.EnsureTrailingSlash(fullRootPath); string currentDirectory = Directory.GetCurrentDirectory(); diff --git a/src/Tasks/CreateCSharpManifestResourceName.cs b/src/Tasks/CreateCSharpManifestResourceName.cs index c7f838b16ef..85a5b1b1ec2 100644 --- a/src/Tasks/CreateCSharpManifestResourceName.cs +++ b/src/Tasks/CreateCSharpManifestResourceName.cs @@ -97,13 +97,13 @@ internal static string CreateManifestNameImpl( bool enableCustomCulture = false) { // Use the link file name if there is one, otherwise, fall back to file name. - string embeddedFileName = FileUtilities.FixFilePath(linkFileName); + string embeddedFileName = FrameworkFileUtilities.FixFilePath(linkFileName); if (string.IsNullOrEmpty(embeddedFileName)) { - embeddedFileName = FileUtilities.FixFilePath(fileName); + embeddedFileName = FrameworkFileUtilities.FixFilePath(fileName); } - dependentUponFileName = FileUtilities.FixFilePath(dependentUponFileName); + dependentUponFileName = FrameworkFileUtilities.FixFilePath(dependentUponFileName); Culture.ItemCultureInfo info; if (!string.IsNullOrEmpty(culture) && enableCustomCulture) diff --git a/src/Tasks/CreateVisualBasicManifestResourceName.cs b/src/Tasks/CreateVisualBasicManifestResourceName.cs index d2cf7f405ef..24c59241ee0 100644 --- a/src/Tasks/CreateVisualBasicManifestResourceName.cs +++ b/src/Tasks/CreateVisualBasicManifestResourceName.cs @@ -102,7 +102,7 @@ internal static string CreateManifestNameImpl( embeddedFileName = fileName; } - dependentUponFileName = FileUtilities.FixFilePath(dependentUponFileName); + dependentUponFileName = FrameworkFileUtilities.FixFilePath(dependentUponFileName); Culture.ItemCultureInfo info; if (!string.IsNullOrEmpty(culture) && enableCustomCulture) diff --git a/src/Tasks/DependencyFile.cs b/src/Tasks/DependencyFile.cs index a5a2c3ec528..0e591aa7f97 100644 --- a/src/Tasks/DependencyFile.cs +++ b/src/Tasks/DependencyFile.cs @@ -3,7 +3,7 @@ using System; using System.IO; - +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; @@ -61,7 +61,7 @@ internal bool Exists /// The file name. internal DependencyFile(string filename) { - this.filename = FileUtilities.FixFilePath(filename); + this.filename = FrameworkFileUtilities.FixFilePath(filename); if (FileSystems.Default.FileExists(FileName)) { diff --git a/src/Tasks/FindInList.cs b/src/Tasks/FindInList.cs index 84538f53b6e..493990ca1a9 100644 --- a/src/Tasks/FindInList.cs +++ b/src/Tasks/FindInList.cs @@ -105,7 +105,7 @@ private bool IsMatchingItem(StringComparison comparison, ITaskItem item) { try { - var path = FileUtilities.FixFilePath(item.ItemSpec); + var path = FrameworkFileUtilities.FixFilePath(item.ItemSpec); string filename = (MatchFileNameOnly ? Path.GetFileName(path) : path); if (String.Equals(filename, ItemSpecToFind, comparison)) diff --git a/src/Tasks/GetFrameworkSDKPath.cs b/src/Tasks/GetFrameworkSDKPath.cs index fb90e032392..05f35b77b96 100644 --- a/src/Tasks/GetFrameworkSDKPath.cs +++ b/src/Tasks/GetFrameworkSDKPath.cs @@ -4,7 +4,6 @@ #if NETFRAMEWORK using System; -using Microsoft.Build.Shared; using Microsoft.Build.Utilities; #endif @@ -56,7 +55,7 @@ public string Path } else { - s_path = FileUtilities.EnsureTrailingSlash(s_path); + s_path = FrameworkFileUtilities.EnsureTrailingSlash(s_path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_path); } } @@ -93,7 +92,7 @@ public string FrameworkSdkVersion20Path } else { - s_version20Path = FileUtilities.EnsureTrailingSlash(s_version20Path); + s_version20Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version20Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version20Path); } } @@ -126,7 +125,7 @@ public string FrameworkSdkVersion35Path } else { - s_version35Path = FileUtilities.EnsureTrailingSlash(s_version35Path); + s_version35Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version35Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version35Path); } } @@ -159,7 +158,7 @@ public string FrameworkSdkVersion40Path } else { - s_version40Path = FileUtilities.EnsureTrailingSlash(s_version40Path); + s_version40Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version40Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version40Path); } } @@ -192,7 +191,7 @@ public string FrameworkSdkVersion45Path } else { - s_version45Path = FileUtilities.EnsureTrailingSlash(s_version45Path); + s_version45Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version45Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version45Path); } } @@ -225,7 +224,7 @@ public string FrameworkSdkVersion451Path } else { - s_version451Path = FileUtilities.EnsureTrailingSlash(s_version451Path); + s_version451Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version451Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version451Path); } } @@ -258,7 +257,7 @@ public string FrameworkSdkVersion46Path } else { - s_version46Path = FileUtilities.EnsureTrailingSlash(s_version46Path); + s_version46Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version46Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version46Path); } } @@ -291,7 +290,7 @@ public string FrameworkSdkVersion461Path } else { - s_version461Path = FileUtilities.EnsureTrailingSlash(s_version461Path); + s_version461Path = FrameworkFileUtilities.EnsureTrailingSlash(s_version461Path); Log.LogMessageFromResources(MessageImportance.Low, "GetFrameworkSdkPath.FoundSDK", s_version461Path); } } diff --git a/src/Tasks/GetSDKReferenceFiles.cs b/src/Tasks/GetSDKReferenceFiles.cs index d1786ad7f1f..6099546f9af 100644 --- a/src/Tasks/GetSDKReferenceFiles.cs +++ b/src/Tasks/GetSDKReferenceFiles.cs @@ -567,7 +567,7 @@ private void GenerateOutputItems() /// private void GatherReferenceAssemblies(HashSet resolvedFiles, ITaskItem sdkReference, string path, SDKInfo info) { - if (info.DirectoryToFileList != null && info.DirectoryToFileList.TryGetValue(FileUtilities.EnsureNoTrailingSlash(path), out List referenceFiles) && referenceFiles != null) + if (info.DirectoryToFileList != null && info.DirectoryToFileList.TryGetValue(FrameworkFileUtilities.EnsureNoTrailingSlash(path), out List referenceFiles) && referenceFiles != null) { foreach (string file in referenceFiles) { @@ -619,7 +619,7 @@ private void GatherRedistFiles(HashSet resolvedRedistFiles, foreach (KeyValuePair> directoryToFileList in info.DirectoryToFileList) { // Add a trailing slash to ensure we don't match the start of a platform (e.g. ...\ARM matching ...\ARM64) - if (FileUtilities.EnsureTrailingSlash(directoryToFileList.Key).StartsWith(FileUtilities.EnsureTrailingSlash(redistFilePath), StringComparison.OrdinalIgnoreCase)) + if (FrameworkFileUtilities.EnsureTrailingSlash(directoryToFileList.Key).StartsWith(FrameworkFileUtilities.EnsureTrailingSlash(redistFilePath), StringComparison.OrdinalIgnoreCase)) { List redistFiles = directoryToFileList.Value; string targetPathRoot = sdkReference.GetMetadata("CopyRedistToSubDirectory"); diff --git a/src/Tasks/ListOperators/FindUnderPath.cs b/src/Tasks/ListOperators/FindUnderPath.cs index 836ec12b0f0..05646c412e4 100644 --- a/src/Tasks/ListOperators/FindUnderPath.cs +++ b/src/Tasks/ListOperators/FindUnderPath.cs @@ -59,8 +59,8 @@ public override bool Execute() { conePath = Strings.WeakIntern( - System.IO.Path.GetFullPath(FileUtilities.FixFilePath(Path.ItemSpec))); - conePath = FileUtilities.EnsureTrailingSlash(conePath); + System.IO.Path.GetFullPath(FrameworkFileUtilities.FixFilePath(Path.ItemSpec))); + conePath = FrameworkFileUtilities.EnsureTrailingSlash(conePath); } catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e)) { @@ -80,7 +80,7 @@ public override bool Execute() { fullPath = Strings.WeakIntern( - System.IO.Path.GetFullPath(FileUtilities.FixFilePath(item.ItemSpec))); + System.IO.Path.GetFullPath(FrameworkFileUtilities.FixFilePath(item.ItemSpec))); } catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e)) { diff --git a/src/Tasks/MakeDir.cs b/src/Tasks/MakeDir.cs index eb7d2ef3281..8bc552bfd82 100644 --- a/src/Tasks/MakeDir.cs +++ b/src/Tasks/MakeDir.cs @@ -70,7 +70,7 @@ public override bool Execute() // Do not log a fake command line as well, as it's superfluous, and also potentially expensive Log.LogMessageFromResources(MessageImportance.Normal, "MakeDir.Comment", directory.ItemSpec); - Directory.CreateDirectory(FileUtilities.FixFilePath(directory.ItemSpec)); + Directory.CreateDirectory(FrameworkFileUtilities.FixFilePath(directory.ItemSpec)); } } diff --git a/src/Tasks/ResGenDependencies.cs b/src/Tasks/ResGenDependencies.cs index 72713bb21ce..a593be6cffe 100644 --- a/src/Tasks/ResGenDependencies.cs +++ b/src/Tasks/ResGenDependencies.cs @@ -8,13 +8,14 @@ #if FEATURE_RESXREADER_LIVEDESERIALIZATION using System.Collections; using System.Resources; +using Microsoft.Build.Shared; #endif using System.Xml; using Microsoft.Build.BackEnd; -using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; using Microsoft.Build.Tasks.ResourceHandling; using Microsoft.Build.Utilities; +using Microsoft.Build.Framework; #nullable disable @@ -370,7 +371,7 @@ internal bool AllOutputFilesAreUpToDate() Debug.Assert(outputFiles != null, "OutputFiles hasn't been set"); foreach (string outputFileName in outputFiles) { - var outputFile = new FileInfo(FileUtilities.FixFilePath(outputFileName)); + var outputFile = new FileInfo(FrameworkFileUtilities.FixFilePath(outputFileName)); if (!outputFile.Exists || outputFile.LastWriteTime < LastModified) { return false; diff --git a/src/Tasks/ResolveSDKReference.cs b/src/Tasks/ResolveSDKReference.cs index 9d2c288a93e..7b759a91a79 100644 --- a/src/Tasks/ResolveSDKReference.cs +++ b/src/Tasks/ResolveSDKReference.cs @@ -916,7 +916,7 @@ public void Resolve(Dictionary sdks, string targetConfigurati _prefer32BitFromProject = prefer32Bit; // There must be a trailing slash or else the ExpandSDKReferenceAssemblies will not work. - ResolvedPath = FileUtilities.EnsureTrailingSlash(sdk.ItemSpec); + ResolvedPath = FrameworkFileUtilities.EnsureTrailingSlash(sdk.ItemSpec); System.Version.TryParse(sdk.GetMetadata(SDKPlatformVersion), out Version targetPlatformVersionFromItem); diff --git a/src/Tasks/ResourceHandling/MSBuildResXReader.cs b/src/Tasks/ResourceHandling/MSBuildResXReader.cs index 9186ac7b382..90e0f34cbad 100644 --- a/src/Tasks/ResourceHandling/MSBuildResXReader.cs +++ b/src/Tasks/ResourceHandling/MSBuildResXReader.cs @@ -8,6 +8,7 @@ using System.Text; using System.Xml; using System.Xml.Linq; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; using Microsoft.Build.Utilities; @@ -228,7 +229,7 @@ private static void AddLinkedResource(string resxFilename, bool pathsRelativeToB { string[] fileRefInfo = ParseResxFileRefString(value); - string fileName = FileUtilities.FixFilePath(fileRefInfo[0]); + string fileName = FrameworkFileUtilities.FixFilePath(fileRefInfo[0]); string fileRefType = fileRefInfo[1]; if (pathsRelativeToBasePath) diff --git a/src/Tasks/Touch.cs b/src/Tasks/Touch.cs index 6b66ec1e769..8d157d48493 100644 --- a/src/Tasks/Touch.cs +++ b/src/Tasks/Touch.cs @@ -91,7 +91,7 @@ internal bool ExecuteImpl( foreach (ITaskItem file in Files) { - string path = FileUtilities.FixFilePath(file.ItemSpec); + string path = FrameworkFileUtilities.FixFilePath(file.ItemSpec); // For speed, eliminate duplicates caused by poor targets authoring if (touchedFilesSet.Contains(path)) { diff --git a/src/Tasks/Unzip.cs b/src/Tasks/Unzip.cs index f04f84d3eb3..6492508e130 100644 --- a/src/Tasks/Unzip.cs +++ b/src/Tasks/Unzip.cs @@ -160,7 +160,7 @@ public override bool Execute() /// The to extract files to. private void Extract(ZipArchive sourceArchive, DirectoryInfo destinationDirectory) { - string fullDestinationDirectoryPath = Path.GetFullPath(FileUtilities.EnsureTrailingSlash(destinationDirectory.FullName)); + string fullDestinationDirectoryPath = Path.GetFullPath(FrameworkFileUtilities.EnsureTrailingSlash(destinationDirectory.FullName)); foreach (ZipArchiveEntry zipArchiveEntry in sourceArchive.Entries.TakeWhile(i => !_cancellationToken.IsCancellationRequested)) { diff --git a/src/Utilities.UnitTests/CommandLineBuilder_Tests.cs b/src/Utilities.UnitTests/CommandLineBuilder_Tests.cs index 6946d9e2323..7f07523a3dc 100644 --- a/src/Utilities.UnitTests/CommandLineBuilder_Tests.cs +++ b/src/Utilities.UnitTests/CommandLineBuilder_Tests.cs @@ -5,6 +5,7 @@ using System.Globalization; using System.IO; using System.Threading; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Microsoft.Build.Utilities; using Shouldly; @@ -107,11 +108,11 @@ public void AppendLiteralSwitchWithSpacesInParameter() public void AppendTwoStringsEnsureNoSpace() { CommandLineBuilder c = new CommandLineBuilder(); - c.AppendFileNamesIfNotNull(new[] { "Form1.resx", FileUtilities.FixFilePath("built\\Form1.resources") }, ","); + c.AppendFileNamesIfNotNull(new[] { "Form1.resx", FrameworkFileUtilities.FixFilePath("built\\Form1.resources") }, ","); // There shouldn't be a space before or after the comma // Tools like resgen require comma-delimited lists to be bumped up next to each other. - c.ShouldBe(FileUtilities.FixFilePath(@"Form1.resx,built\Form1.resources")); + c.ShouldBe(FrameworkFileUtilities.FixFilePath(@"Form1.resx,built\Form1.resources")); } /* diff --git a/src/Utilities.UnitTests/ToolLocationHelper_Tests.cs b/src/Utilities.UnitTests/ToolLocationHelper_Tests.cs index a14605728ea..4104fc438d5 100644 --- a/src/Utilities.UnitTests/ToolLocationHelper_Tests.cs +++ b/src/Utilities.UnitTests/ToolLocationHelper_Tests.cs @@ -2204,7 +2204,7 @@ public void GetPathToStandardLibraries64Bit40() } string pathToFramework = ToolLocationHelper.GetPathToStandardLibraries(".NetFramework", "v4.0", string.Empty, "x86"); - string dotNet40Path = FileUtilities.EnsureNoTrailingSlash(referencePaths[0]); + string dotNet40Path = FrameworkFileUtilities.EnsureNoTrailingSlash(referencePaths[0]); pathToFramework.ShouldBe(dotNet40Path, StringCompareShould.IgnoreCase); pathToFramework = ToolLocationHelper.GetPathToStandardLibraries(".NetFramework", "v4.0", string.Empty, "x64"); @@ -2287,7 +2287,7 @@ public void GetPathToStandardLibraries32Bit40() } string pathToFramework = ToolLocationHelper.GetPathToStandardLibraries(".NetFramework", "v4.0", string.Empty, "x86"); - string dotNet40Path = FileUtilities.EnsureNoTrailingSlash(referencePaths[0]); + string dotNet40Path = FrameworkFileUtilities.EnsureNoTrailingSlash(referencePaths[0]); pathToFramework.ShouldBe(dotNet40Path, StringCompareShould.IgnoreCase); pathToFramework = ToolLocationHelper.GetPathToStandardLibraries(".NetFramework", "v4.0", string.Empty, "x64"); diff --git a/src/Utilities.UnitTests/TrackedDependencies/FileTrackerTests.cs b/src/Utilities.UnitTests/TrackedDependencies/FileTrackerTests.cs index d41e3cbf049..f5cdd7f1e79 100644 --- a/src/Utilities.UnitTests/TrackedDependencies/FileTrackerTests.cs +++ b/src/Utilities.UnitTests/TrackedDependencies/FileTrackerTests.cs @@ -338,8 +338,8 @@ static void Main(string[] args) Assert.Equal(0, exit); // Should track directories when '/e' is passed - FileTrackerTestHelper.AssertFoundStringInTLog("GetFileAttributesExW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); - FileTrackerTestHelper.AssertFoundStringInTLog("GetFileAttributesW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertFoundStringInTLog("GetFileAttributesExW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertFoundStringInTLog("GetFileAttributesW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); File.Delete("directoryattributes.read.1.tlog"); File.Delete("directoryattributes.write.1.tlog"); @@ -351,8 +351,8 @@ static void Main(string[] args) Assert.Equal(0, exit); // With '/a', should *not* track GetFileAttributes on directories, even though we do so on files. - FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesExW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); - FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesExW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); File.Delete("directoryattributes.read.1.tlog"); File.Delete("directoryattributes.write.1.tlog"); @@ -364,8 +364,8 @@ static void Main(string[] args) Assert.Equal(0, exit); // With neither '/a' nor '/e', should not do any directory tracking whatsoever - FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesExW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); - FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesW:" + FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesExW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog("GetFileAttributesW:" + FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); File.Delete("directoryattributes.read.1.tlog"); File.Delete("directoryattributes.write.1.tlog"); @@ -377,7 +377,7 @@ static void Main(string[] args) Assert.Equal(0, exit); // Should track directories when '/e' is passed - FileTrackerTestHelper.AssertFoundStringInTLog(FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertFoundStringInTLog(FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); File.Delete("directoryattributes.read.1.tlog"); File.Delete("directoryattributes.write.1.tlog"); @@ -389,7 +389,7 @@ static void Main(string[] args) Assert.Equal(0, exit); // With '/a', should *not* track GetFileAttributes on directories, even though we do so on files. - FileTrackerTestHelper.AssertDidntFindStringInTLog(FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog(FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); File.Delete("directoryattributes.read.1.tlog"); File.Delete("directoryattributes.write.1.tlog"); @@ -401,7 +401,7 @@ static void Main(string[] args) Assert.Equal(0, exit); // With neither '/a' nor '/e', should not do any directory tracking whatsoever - FileTrackerTestHelper.AssertDidntFindStringInTLog(FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); + FileTrackerTestHelper.AssertDidntFindStringInTLog(FrameworkFileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory()).ToUpperInvariant(), "directoryattributes.read.1.tlog"); } finally { @@ -900,12 +900,12 @@ public void FileTrackerFileIsExcludedFromDependencies() // The short path to temp string tempShortPath = NativeMethodsShared.IsUnixLike ? tempPath - : FileUtilities.EnsureTrailingSlash( + : FrameworkFileUtilities.EnsureTrailingSlash( NativeMethodsShared.GetShortFilePath(tempPath).ToUpperInvariant()); // The long path to temp string tempLongPath = NativeMethodsShared.IsUnixLike ? tempPath - : FileUtilities.EnsureTrailingSlash( + : FrameworkFileUtilities.EnsureTrailingSlash( NativeMethodsShared.GetLongFilePath(tempPath).ToUpperInvariant()); // We don't want to be including these as dependencies or outputs: diff --git a/src/Utilities/CommandLineBuilder.cs b/src/Utilities/CommandLineBuilder.cs index 07ac12544e9..481dc35c62e 100644 --- a/src/Utilities/CommandLineBuilder.cs +++ b/src/Utilities/CommandLineBuilder.cs @@ -336,7 +336,7 @@ protected void AppendFileNameWithQuoting(string fileName) // their own quotes. Quotes are illegal. VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileName); - fileName = FileUtilities.FixFilePath(fileName); + fileName = FrameworkFileUtilities.FixFilePath(fileName); if (fileName.Length != 0 && fileName[0] == '-') { AppendTextWithQuoting("." + Path.DirectorySeparatorChar + fileName); diff --git a/src/Utilities/TargetPlatformSDK.cs b/src/Utilities/TargetPlatformSDK.cs index 64ef39b0ed5..ea7b3408cd7 100644 --- a/src/Utilities/TargetPlatformSDK.cs +++ b/src/Utilities/TargetPlatformSDK.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; #nullable disable @@ -104,7 +105,7 @@ public Version MinOSVersion public string Path { get => _path; - set => _path = value != null ? FileUtilities.EnsureTrailingSlash(value) : null; + set => _path = value != null ? FrameworkFileUtilities.EnsureTrailingSlash(value) : null; } /// diff --git a/src/Utilities/TaskItem.cs b/src/Utilities/TaskItem.cs index 506e233a0a6..2fa8a3789a1 100644 --- a/src/Utilities/TaskItem.cs +++ b/src/Utilities/TaskItem.cs @@ -103,7 +103,7 @@ public TaskItem( { ErrorUtilities.VerifyThrowArgumentNull(itemSpec); - _itemSpec = treatAsFilePath ? FileUtilities.FixFilePath(itemSpec) : itemSpec; + _itemSpec = treatAsFilePath ? FrameworkFileUtilities.FixFilePath(itemSpec) : itemSpec; } /// @@ -185,7 +185,7 @@ public string ItemSpec { ErrorUtilities.VerifyThrowArgumentNull(value, nameof(ItemSpec)); - _itemSpec = FileUtilities.FixFilePath(value); + _itemSpec = FrameworkFileUtilities.FixFilePath(value); _fullPath = null; } } @@ -204,7 +204,7 @@ string ITaskItem2.EvaluatedIncludeEscaped set { - _itemSpec = FileUtilities.FixFilePath(value); + _itemSpec = FrameworkFileUtilities.FixFilePath(value); _fullPath = null; } } diff --git a/src/Utilities/ToolLocationHelper.cs b/src/Utilities/ToolLocationHelper.cs index 673ba0eb6b0..9e7ebbf82cd 100644 --- a/src/Utilities/ToolLocationHelper.cs +++ b/src/Utilities/ToolLocationHelper.cs @@ -9,6 +9,7 @@ using System.Runtime.Versioning; using System.Text; using System.Xml; +using Microsoft.Build.Framework; using Microsoft.Build.Shared; using Microsoft.Build.Shared.FileSystem; using Microsoft.Build.Tasks.AssemblyFoldersFromConfig; @@ -663,7 +664,7 @@ public static IList GetSDKReferenceFolders(string sdkRoot, string target string legacyWindowsMetadataLocation = Path.Combine(sdkRoot, "Windows Metadata"); if (FileUtilities.DirectoryExistsNoThrow(legacyWindowsMetadataLocation)) { - legacyWindowsMetadataLocation = FileUtilities.EnsureTrailingSlash(legacyWindowsMetadataLocation); + legacyWindowsMetadataLocation = FrameworkFileUtilities.EnsureTrailingSlash(legacyWindowsMetadataLocation); referenceDirectories.Add(legacyWindowsMetadataLocation); } @@ -1766,7 +1767,7 @@ public static string GetPathToStandardLibraries(string targetFrameworkIdentifier { // We found the framework reference assembly directory with mscorlib in it // that's our standard lib path, so return it, with no trailing slash. - return FileUtilities.EnsureNoTrailingSlash(referenceAssemblyDirectory); + return FrameworkFileUtilities.EnsureNoTrailingSlash(referenceAssemblyDirectory); } } @@ -1840,7 +1841,7 @@ public static string GetPathToStandardLibraries(string targetFrameworkIdentifier { // We found the framework reference assembly directory with mscorlib in it // that's our standard lib path, so return it, with no trailing slash. - return FileUtilities.EnsureNoTrailingSlash(legacyMsCorlib20Path); + return FrameworkFileUtilities.EnsureNoTrailingSlash(legacyMsCorlib20Path); } // If for some reason the 2.0 framework is not installed in its default location then maybe someone is using the ".net 4.0" reference assembly @@ -1857,7 +1858,7 @@ public static string GetPathToStandardLibraries(string targetFrameworkIdentifier { // We found the framework reference assembly directory with mscorlib in it // that's our standard lib path, so return it, with no trailing slash. - return FileUtilities.EnsureNoTrailingSlash(referenceAssemblyDirectory); + return FrameworkFileUtilities.EnsureNoTrailingSlash(referenceAssemblyDirectory); } } @@ -2426,7 +2427,7 @@ private static void AddSDKPath(string sdkRoot, string contentFolderName, string if (FileUtilities.DirectoryExistsNoThrow(referenceAssemblyPath)) { - referenceAssemblyPath = FileUtilities.EnsureTrailingSlash(referenceAssemblyPath); + referenceAssemblyPath = FrameworkFileUtilities.EnsureTrailingSlash(referenceAssemblyPath); contentDirectories.Add(referenceAssemblyPath); } } @@ -2552,7 +2553,7 @@ internal static void GatherExtensionSDKs(DirectoryInfo extensionSdksDirectory, T string pathToSDKManifest = Path.Combine(sdkVersionDirectory.FullName, "SDKManifest.xml"); if (FileUtilities.FileExistsNoThrow(pathToSDKManifest)) { - targetPlatformSDK.ExtensionSDKs.Add(SDKKey, FileUtilities.EnsureTrailingSlash(sdkVersionDirectory.FullName)); + targetPlatformSDK.ExtensionSDKs.Add(SDKKey, FrameworkFileUtilities.EnsureTrailingSlash(sdkVersionDirectory.FullName)); } else { @@ -2825,7 +2826,7 @@ internal static void GatherSDKsFromRegistryImpl(Dictionary - private static readonly string s_tempPath = FileUtilities.EnsureTrailingSlash(Path.GetTempPath()); + private static readonly string s_tempPath = FrameworkFileUtilities.EnsureTrailingSlash(Path.GetTempPath()); // The short path to temp - private static readonly string s_tempShortPath = FileUtilities.EnsureTrailingSlash(NativeMethodsShared.GetShortFilePath(s_tempPath).ToUpperInvariant()); + private static readonly string s_tempShortPath = FrameworkFileUtilities.EnsureTrailingSlash(NativeMethodsShared.GetShortFilePath(s_tempPath).ToUpperInvariant()); // The long path to temp - private static readonly string s_tempLongPath = FileUtilities.EnsureTrailingSlash(NativeMethodsShared.GetLongFilePath(s_tempPath).ToUpperInvariant()); + private static readonly string s_tempLongPath = FrameworkFileUtilities.EnsureTrailingSlash(NativeMethodsShared.GetLongFilePath(s_tempPath).ToUpperInvariant()); // The path to ApplicationData (is equal to %USERPROFILE%\Application Data folder in Windows XP and %USERPROFILE%\AppData\Roaming in Vista and later) - private static readonly string s_applicationDataPath = FileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData).ToUpperInvariant()); + private static readonly string s_applicationDataPath = FrameworkFileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData).ToUpperInvariant()); // The path to LocalApplicationData (is equal to %USERPROFILE%\Local Settings\Application Data folder in Windows XP and %USERPROFILE%\AppData\Local in Vista and later). - private static readonly string s_localApplicationDataPath = FileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData).ToUpperInvariant()); + private static readonly string s_localApplicationDataPath = FrameworkFileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData).ToUpperInvariant()); // The path to the LocalLow folder. In Vista and later, user application data is organized across %USERPROFILE%\AppData\LocalLow, %USERPROFILE%\AppData\Local (%LOCALAPPDATA%) // and %USERPROFILE%\AppData\Roaming (%APPDATA%). The LocalLow folder is not present in XP. - private static readonly string s_localLowApplicationDataPath = FileUtilities.EnsureTrailingSlash(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData\\LocalLow").ToUpperInvariant()); + private static readonly string s_localLowApplicationDataPath = FrameworkFileUtilities.EnsureTrailingSlash(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData\\LocalLow").ToUpperInvariant()); // The path to the common Application Data, which is also used by some programs (e.g. antivirus) that we wish to ignore. // Is equal to C:\Documents and Settings\All Users\Application Data on XP, and C:\ProgramData on Vista+. @@ -127,18 +127,18 @@ private static List InitializeCommonApplicationDataPaths() { List commonApplicationDataPaths = new(); - string defaultCommonApplicationDataPath = FileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData).ToUpperInvariant()); + string defaultCommonApplicationDataPath = FrameworkFileUtilities.EnsureTrailingSlash(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData).ToUpperInvariant()); commonApplicationDataPaths.Add(defaultCommonApplicationDataPath); string defaultRootDirectory = Path.GetPathRoot(defaultCommonApplicationDataPath); - string alternativeCommonApplicationDataPath1 = FileUtilities.EnsureTrailingSlash(Path.Combine(defaultRootDirectory, @"Documents and Settings\All Users\Application Data").ToUpperInvariant()); + string alternativeCommonApplicationDataPath1 = FrameworkFileUtilities.EnsureTrailingSlash(Path.Combine(defaultRootDirectory, @"Documents and Settings\All Users\Application Data").ToUpperInvariant()); if (!alternativeCommonApplicationDataPath1.Equals(defaultCommonApplicationDataPath, StringComparison.Ordinal)) { commonApplicationDataPaths.Add(alternativeCommonApplicationDataPath1); } - string alternativeCommonApplicationDataPath2 = FileUtilities.EnsureTrailingSlash(Path.Combine(defaultRootDirectory, @"Users\All Users\Application Data").ToUpperInvariant()); + string alternativeCommonApplicationDataPath2 = FrameworkFileUtilities.EnsureTrailingSlash(Path.Combine(defaultRootDirectory, @"Users\All Users\Application Data").ToUpperInvariant()); if (!alternativeCommonApplicationDataPath2.Equals(defaultCommonApplicationDataPath, StringComparison.Ordinal)) { @@ -281,7 +281,7 @@ public static bool FileIsUnderPath(string fileName, string path) // Ensure that the path has a trailing slash that we are checking under // By default the paths that we check for most often will have, so this will // return fast and not allocate memory in the process - return FileIsUnderNormalizedPath(fileName, FileUtilities.EnsureTrailingSlash(path)); + return FileIsUnderNormalizedPath(fileName, FrameworkFileUtilities.EnsureTrailingSlash(path)); } internal static bool FileIsUnderNormalizedPath(string fileName, string path) @@ -615,7 +615,7 @@ public static string TrackerResponseFileArguments(string dllName, string interme { intermediateDirectory = FileUtilities.NormalizePath(intermediateDirectory); // If the intermediate directory ends up with a trailing slash, then be rid of it! - if (FileUtilities.EndsWithSlash(intermediateDirectory)) + if (FrameworkFileUtilities.EndsWithSlash(intermediateDirectory)) { intermediateDirectory = Path.GetDirectoryName(intermediateDirectory); } diff --git a/src/Utilities/TrackedDependencies/FlatTrackingData.cs b/src/Utilities/TrackedDependencies/FlatTrackingData.cs index 633dc4c02ac..e12cee660ff 100644 --- a/src/Utilities/TrackedDependencies/FlatTrackingData.cs +++ b/src/Utilities/TrackedDependencies/FlatTrackingData.cs @@ -323,7 +323,7 @@ private void InternalConstruct(ITask ownerTask, ITaskItem[] tlogFilesLocal, ITas // our "starts with" comparison doesn't pick up incomplete matches, such as C:\Foo matching C:\FooFile.txt foreach (string excludePath in excludedInputPaths) { - string fullexcludePath = FileUtilities.EnsureTrailingSlash(FileUtilities.NormalizePath(excludePath)).ToUpperInvariant(); + string fullexcludePath = FrameworkFileUtilities.EnsureTrailingSlash(FileUtilities.NormalizePath(excludePath)).ToUpperInvariant(); _excludedInputPaths.Add(fullexcludePath); } }