PathUtilities

CodeActions\SyncNamespace\CSharpSyncNamespaceTestsBase.cs (8)

35=> PathUtilities.IsUnixLikePlatform 40=> PathUtilities.CombineAbsoluteAndRelativePaths(ProjectRootPath, "ProjectA.csproj"); 46return (string.Empty, PathUtilities.CombineAbsoluteAndRelativePaths(ProjectRootPath, fileName)); 51var relativePath = PathUtilities.CombinePossiblyRelativeAndRelativePaths(folderPath, fileName); 52return (folderPath, PathUtilities.CombineAbsoluteAndRelativePaths(ProjectRootPath, relativePath)); 57=> string.Join(PathUtilities.DirectorySeparatorStr, folders); 66var expectedFolderPaths = expectedFolders.Select(f => string.Join(PathUtilities.DirectorySeparatorStr, f)); 85actualFolderPaths.Add(string.Join(PathUtilities.DirectorySeparatorStr, newDocument.Folders));

CodeActions\SyncNamespace\SyncNamespaceTests_NoAction.cs (2)

266var filePath = PathUtilities.CombineAbsoluteAndRelativePaths(PathUtilities.GetPathRoot(ProjectFilePath), "Foo.cs");

Completion\CompletionProviders\ReferenceDirectiveCompletionProviderTests.cs (1)

51var commitCharacters = PathUtilities.IsUnixLikePlatform ? new[] { '"', '/' } : ['"', '\\', '/', ','];

Workspaces\WorkspaceTests_EditorFeatures.cs (2)

1147var analyzerConfigPath = PathUtilities.CombineAbsoluteAndRelativePaths(Temp.CreateDirectory().Path, ".editorconfig"); 1392var analyzerConfigDocFilePath = PathUtilities.CombineAbsoluteAndRelativePaths(Temp.CreateDirectory().Path, ".editorconfig");

Completion\TestFileSystemCompletionHelper.cs (6)

33Assert.True(drives.All(d => d.EndsWith(PathUtilities.DirectorySeparatorStr))); 34Assert.True(directories.All(d => !d.EndsWith(PathUtilities.DirectorySeparatorStr))); 48=> _directories.Contains(fullPath.TrimEnd(PathUtilities.DirectorySeparatorChar)); 58var withTrailingSeparator = fullDirectoryPath.TrimEnd(PathUtilities.DirectorySeparatorChar) + PathUtilities.DirectorySeparatorChar; 61let nextSeparator = d.IndexOf(PathUtilities.DirectorySeparatorChar, withTrailingSeparator.Length)

AddImport\AbstractAddImportFeatureService.cs (1)

415return PathUtilities.ContainsPathComponent(reference.FilePath, pathComponent, ignoreCase: true);

CodeFixes\Configuration\ConfigurationUpdater.cs (5)

303var analyzerConfigDirectory = PathUtilities.GetDirectoryName(analyzerConfigPath) ?? throw ExceptionUtilities.Unreachable(); 421var editorConfigDirectory = PathUtilities.GetDirectoryName(editorConfigDocument.FilePath); 436relativePath = PathUtilities.GetRelativePath(editorConfigDirectory.ToLowerInvariant(), diagnosticFilePath); 437relativePath = PathUtilities.NormalizeWithForwardSlash(relativePath); 606if (matchWithoutExtension.Contains(PathUtilities.GetFileName(diagnosticFilePath, false)))

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.AbstractGlobalSuppressMessageCodeAction.cs (2)

52var directory = PathUtilities.GetDirectoryName(fullPath); 55var suppressionsFilePath = PathUtilities.CombinePossiblyRelativeAndRelativePaths(directory, suppressionsFileName);

CodeRefactorings\MoveType\AbstractMoveTypeService.Editor.cs (2)

56=> PathUtilities.GetDirectoryName(SemanticDocument.Document.FilePath) is { } dir 57? PathUtilities.CombinePaths(dir, FileName)

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)

357!PathUtilities.PathsEqual(arg.solution.GetRequiredDocument(id).Project.FilePath!, arg.document.Project.FilePath!), (solution, document))) 464Debug.Assert(!PathUtilities.PathsEqual(refLocation.Document.FilePath, document.FilePath));

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (4)

33? string.Format(FeaturesResources.Move_file_to_0, string.Join(PathUtilities.DirectorySeparatorStr, _newfolders)) 93.ToImmutableDictionary(t => t.foldername, t => t.index, PathUtilities.Comparer); 116if (builder.All(folders => !folders.SequenceEqual(defaultPathBasedOnCurrentFolder, PathUtilities.Comparer))) 167if (handledFolders.Add(string.Join(PathUtilities.DirectorySeparatorStr, folders)))

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.State.cs (4)

153var absoluteDirectoryPath = PathUtilities.GetDirectoryName(document.FilePath); 157var projectRoot = PathUtilities.GetDirectoryName(document.Project.FilePath); 162var logicalDirectoryPath = PathUtilities.CombineAbsoluteAndRelativePaths(projectRoot, folderPath); 166return PathUtilities.PathsEqual(absoluteDirectoryPath, logicalDirectoryPath);

Common\AbstractProjectExtensionProvider.cs (1)

106Array.IndexOf(extensionInfo.DocumentExtensions, PathUtilities.GetExtension(document.FilePath)) < 0)

Completion\FileSystemCompletionHelper.cs (15)

43Debug.Assert(searchPaths.All(PathUtilities.IsAbsolute)); 44Debug.Assert(baseDirectory == null || PathUtilities.IsAbsolute(baseDirectory)); 61Debug.Assert(PathUtilities.IsAbsolute(fullPath)); 68Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath)); 75Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath)); 82Debug.Assert(PathUtilities.IsAbsolute(fullPath)); 104PathUtilities.GetFileName(fullPath), 123if (!PathUtilities.IsUnixLikePlatform && directoryPath == "\\") 131var pathKind = PathUtilities.GetPathKind(directoryPath); 142if (PathUtilities.IsUnixLikePlatform) 186result.AddRange(GetItemsInDirectory(PathUtilities.CombineAbsoluteAndRelativePaths(_baseDirectory, directoryPath)!, cancellationToken)); 192result.AddRange(GetItemsInDirectory(PathUtilities.CombineAbsoluteAndRelativePaths(searchPath, directoryPath)!, cancellationToken)); 216Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath)); 241PathUtilities.GetExtension(file), 242PathUtilities.IsUnixLikePlatform ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase))

Completion\Providers\Scripting\AbstractDirectivePathCompletionProvider.cs (5)

22=> ch == '/' || (ch == '\\' && !PathUtilities.IsUnixLikePlatform); 149!PathUtilities.IsUnixLikePlatform && (index = text.LastIndexOf('\\', position)) >= 0) 189var result = PathUtilities.GetDirectoryName(document.FilePath); 190if (!PathUtilities.IsAbsolute(result)) 193Debug.Assert(result == null || PathUtilities.IsAbsolute(result));

Completion\Providers\Scripting\AbstractLoadDirectiveCompletionProvider.cs (1)

25if (PathUtilities.IsUnixLikePlatform)

Completion\Providers\Scripting\AbstractReferenceDirectiveCompletionProvider.cs (2)

32if (PathUtilities.IsUnixLikePlatform) 57context.AddItem(CommonCompletionItem.Create(PathUtilities.GetFileName(path, includeExtension: true), displayTextSuffix: "", glyph: Glyph.Assembly, rules: s_rules));

EditAndContinue\EditSession.cs (2)

1284PathUtilities.GetFileName(oldCompilationOutputs.AssemblyDisplayPath) ?? oldProject.Name + ".dll", 1291PathUtilities.GetFileName(oldCompilationOutputs.PdbDisplayPath) ?? oldProject.Name + ".pdb",

EditAndContinue\TraceLog.cs (6)

66var projectDir = PathUtilities.GetDirectoryName(document.Project.FilePath)!; 67var documentDir = PathUtilities.GetDirectoryName(document.FilePath)!; 68var extension = PathUtilities.GetExtension(document.FilePath); 69var fileName = PathUtilities.GetFileName(document.FilePath, includeExtension: false); 71var relativeDir = PathUtilities.IsSameDirectoryOrChildOf(documentDir, projectDir) ? PathUtilities.GetRelativePath(projectDir, documentDir) : documentDir;

EditAndContinue\Utilities\Extensions.cs (1)

87if (!PathUtilities.IsAbsolute(textDocumentState.FilePath))

Emit\CompilationOutputFilesWithImplicitPdbPath.cs (1)

75TryOpenFileStream(Path.Combine(Path.GetDirectoryName(AssemblyFilePath)!, PathUtilities.GetFileName(pdbPath)));

Shared\Utilities\ExtractTypeHelpers.cs (2)

61var newDocumentPath = PathUtilities.CombinePaths(PathUtilities.GetDirectoryName(hintDocument.FilePath), fileName);

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (3)

141if (!PathUtilities.IsChildPath(projectDir, namespaceDeclaration.SyntaxTree.FilePath)) 148var relativeDirectoryPath = PathUtilities.GetRelativePath( 150PathUtilities.GetDirectoryName(namespaceDeclaration.SyntaxTree.FilePath)!);

Workspace\CompileTimeSolutionProvider.cs (2)

190var designTimeProjectDirectoryName = PathUtilities.GetDirectoryName(designTimeDocument.Project.FilePath)!; 221=> PathUtilities.GetRelativePath(projectDirectory, designTimeDocumentFilePath)[..^".g.cs".Length];

Workspace\MiscellaneousFileUtilities.cs (3)

27var fileExtension = PathUtilities.GetExtension(filePath); 28var fileName = PathUtilities.GetFileName(filePath); 97var baseDirectory = PathUtilities.GetDirectoryName(filePath);

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (2)

530var fileName = PathUtilities.GetFileName(syntaxTree.FilePath); 542Generate(additionalFile.GetText()!.ToString(), PathUtilities.GetFileName(additionalFile.Path));

EditAndContinue\Extensions.cs (2)

90name: PathUtilities.GetFileName(path), 92filePath: PathUtilities.IsAbsolute(path)

FileBasedPrograms\VirtualProjectXmlProvider.cs (1)

149Contract.ThrowIfFalse(PathUtilities.IsAbsolute(documentFilePath));

HostWorkspace\LanguageServerProjectLoader.cs (1)

189Contract.ThrowIfFalse(PathUtilities.IsAbsolute(projectPath));

HostWorkspace\LanguageServerWorkspace.cs (1)

114if (document is not null && (document.DocumentState.Attributes.DesignTimeOnly || !PathUtilities.IsAbsolute(filePath)))

LanguageServer\Handler\DebugConfiguration\WorkspaceDebugConfigurationHandler.cs (1)

44return PathUtilities.IsSameDirectoryOrChildOf(project.FilePath!, workspacePath.GetRequiredParsedUri().LocalPath);

Extensions\ProtocolConversions.cs (5)

42private static readonly char[] s_dirSeparators = [PathUtilities.DirectorySeparatorChar, PathUtilities.AltDirectorySeparatorChar]; 249if (!PathUtilities.IsAbsolute(absolutePath)) 256if (PathUtilities.IsUnixLikePlatform) 486if (PathUtilities.IsAbsolute(mappedSpan.FilePath))

ProtocolConversionsTests.cs (2)

40var filePath = PathUtilities.IsUnixLikePlatform ? $"/_{c}/" : $"C:\\_{c}\\"; 41var uriPrefix = PathUtilities.IsUnixLikePlatform ? "" : "C:/_";

Diagnostics\DiagnosticDataLocation.cs (2)

87var combined = PathUtilities.CombinePaths(PathUtilities.GetDirectoryName(original), mapped);

Diagnostics\DocumentAnalysisScope.cs (1)

59return TextDocument.Project.AnalyzerOptions.AdditionalFiles.First(a => PathUtilities.Comparer.Equals(a.Path, filePath));

Serialization\SerializationExtensions.cs (6)

49if (!PathUtilities.IsAbsolute(filePath)) 56return new XmlFileResolver(PathUtilities.GetDirectoryName(filePath)); 74if (PathUtilities.IsAbsolute(info.FilePath)) 77builder.Add(PathUtilities.GetDirectoryName(info.FilePath)!); 80if (PathUtilities.IsAbsolute(info.OutputFilePath)) 83builder.Add(PathUtilities.GetDirectoryName(info.OutputFilePath)!);

src\Compilers\Core\Portable\AssemblyUtilitiesCore.cs (1)

29RoslynDebug.Assert(PathUtilities.IsAbsolute(filePath));

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

157var simpleName = PathUtilities.GetFileName(originalPath, includeExtension: false);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (26)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (1)

904=> PathUtilities.GetDirectoryName(path, isUnixLike);

src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (3)

29Debug.Assert(searchPaths.All(PathUtilities.IsAbsolute)); 30Debug.Assert(baseDirectory == null || PathUtilities.GetPathKind(baseDirectory) == PathKind.Absolute); 50Debug.Assert(PathUtilities.IsAbsolute(fullPath));

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (3)

65var fileName = PathUtilities.GetFileName(filePath); 71var extension = PathUtilities.GetExtension(fileName); 74var fileNameWithoutExtension = PathUtilities.GetFileName(filePath, includeExtension: false);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

159var relativePath = PathUtilities.GetRelativePath(directoryContainingEditorconfig, codeFilePath);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CompilerUtilities\CompilerPathUtilities.cs (1)

19if (!PathUtilities.IsAbsolute(path))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (7)

57var diagnosticFilePath = PathUtilities.GetDirectoryName(diagnostic?.Location.SourceTree?.FilePath ?? project.FilePath); 58if (!PathUtilities.IsAbsolute(diagnosticFilePath)) 73var analyzerConfigDirectory = PathUtilities.GetDirectoryName(analyzerConfigDocument.FilePath)!; 91if (!PathUtilities.IsAbsolute(solutionOrProjectFilePath)) 96var solutionOrProjectDirectoryPath = PathUtilities.GetDirectoryName(solutionOrProjectFilePath); 98return PathUtilities.CombineAbsoluteAndRelativePaths(solutionOrProjectDirectoryPath!, ".editorconfig"); 104Debug.Assert(PathUtilities.IsAbsolute(analyzerConfigPath));

Storage\SQLite\v2\SQLitePersistentStorage.cs (1)

102_solutionDirectory = PathUtilities.GetDirectoryName(solutionKey.FilePath);

Storage\SQLite\v2\SQLitePersistentStorage_DocumentIds.cs (2)

34documentKey.FilePath != null && PathUtilities.GetDirectoryName(PathUtilities.GetRelativePath(_solutionDirectory, documentKey.FilePath)) is { Length: > 0 } directoryName

Storage\SQLite\v2\SQLitePersistentStorage_ProjectIds.cs (1)

34projectKey.FilePath != null && PathUtilities.GetRelativePath(_solutionDirectory, projectKey.FilePath) is { Length: > 0 } relativePath

Utilities\Documentation\XmlDocumentationProvider.cs (1)

154Debug.Assert(PathUtilities.IsAbsolute(filePath));

Workspace\CommandLineProject.cs (2)

155var relativePath = PathUtilities.GetRelativePath(projectDirectory, absolutePath); 156var isWithinProject = PathUtilities.IsChildPath(projectDirectory, absolutePath);

Workspace\Solution\CompilationOutputInfo.cs (3)

41if (path != null && !PathUtilities.IsAbsolute(path)) 56=> PathUtilities.IsAbsolute(GeneratedFilesOutputDirectory ?? AssemblyPath); 62=> HasEffectiveGeneratedFilesOutputDirectory ? GeneratedFilesOutputDirectory ?? PathUtilities.GetDirectoryName(AssemblyPath) : null;

Workspace\Solution\FileTextLoader.cs (1)

249m["Ext"] = PathUtilities.GetExtension(path);

Workspace\Solution\ProjectState.cs (9)

360if (!PathUtilities.IsAbsolute(ProjectInfo.FilePath)) 371var projectDirectory = PathUtilities.GetDirectoryName(ProjectInfo.FilePath); 374var sourceFilePath = PathUtilities.CombinePathsUnchecked(projectDirectory, "\0" + extension); 436var projectPath = PathUtilities.GetDirectoryName(projectFilePath); 439PathUtilities.GetDirectoryName(projectFilePath) is string directory) 441return PathUtilities.CombinePathsUnchecked(directory, documentState.Name); 515var projectPath = PathUtilities.GetDirectoryName(projectFilePath); 518PathUtilities.GetDirectoryName(projectFilePath) is string directory) 520return PathUtilities.CombinePathsUnchecked(directory, documentState.Name);

MSBuild\MSBuildProjectLoader.cs (2)

133var solutionDirectory = PathUtilities.GetDirectoryName(solutionFilePath) + PathUtilities.DirectorySeparatorChar;

MSBuild\MSBuildProjectLoader.Worker.cs (4)

95_pathToDiscoveredProjectInfosMap = new Dictionary<string, ImmutableArray<ProjectInfo>>(PathUtilities.Comparer); 125var processedPaths = new HashSet<string>(PathUtilities.Comparer); 415if (PathUtilities.IsAbsolute(path)) 474var paths = new HashSet<string>(PathUtilities.Comparer);

MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (1)

69var builder = ImmutableDictionary.CreateBuilder<string, HashSet<int>>(PathUtilities.Comparer);

MSBuild\MSBuildWorkspace.cs (3)

549return GlobalAssemblyCacheLocation.RootLocations.Any(static (gloc, filePath) => PathUtilities.IsChildPath(gloc, filePath), filePath); 569return PathUtilities.IsChildPath(FrameworkRoot, filePath); 599var relativePath = PathUtilities.GetRelativePath(Path.GetDirectoryName(CurrentSolution.GetRequiredProject(projectId).FilePath)!, peRef.FilePath);

MSBuild\ProjectMap.cs (3)

44_projectPathToProjectIdsMap = new Dictionary<string, HashSet<ProjectId>>(PathUtilities.Comparer); 45_projectPathToProjectInfosMap = new Dictionary<string, ImmutableArray<ProjectInfo>>(PathUtilities.Comparer); 174if (PathUtilities.Comparer.Equals(p, path))

NetCoreTests.cs (1)

343var fileName = PathUtilities.GetFileName(project.FilePath);

Workspaces\TestHostDocument.cs (1)

103Contract.ThrowIfFalse(generator == null || PathUtilities.IsAbsolute(filePath));

Workspaces\TestWorkspace_XmlConsumption.cs (2)

151projectFilePath = PathUtilities.CombinePaths(TestWorkspace.RootDirectory, projectFilePath); 721var folderContainers = folderAttribute.Value.Split([PathUtilities.DirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries);

UtilityTest\FilePathUtilitiesTests.cs (10)

WorkspaceTests\AdhocWorkspaceTests.cs (1)

283var analyzerConfigDocFilePath = PathUtilities.CombineAbsoluteAndRelativePaths(Temp.CreateDirectory().Path, ".editorconfig");

ProjectSystemShim\CSharpProjectShim.ICSInputSet.cs (1)

46if (PathUtilities.IsAbsolute(filename))

Services\SolutionServiceTests.cs (1)

100var dirName = PathUtilities.GetDirectoryName(filePath);