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\CompletionProviders\FileBasedPrograms\IncludeAppDirectiveCompletionProvider.cs (4)

50var documentDirectory = PathUtilities.GetDirectoryName(context.Document.FilePath); 51var baseDirectory = PathUtilities.IsAbsolute(documentDirectory) ? documentDirectory : null; 63var contentDirectory = PathUtilities.GetDirectoryName(contentPrefix.ToString()); 66if (baseDirectory != null || PathUtilities.IsAbsolute(contentDirectory))

Completion\CompletionProviders\FileBasedPrograms\ProjectAppDirectiveCompletionProvider.cs (3)

48var documentDirectory = PathUtilities.GetDirectoryName(context.Document.FilePath); 53baseDirectory: PathUtilities.IsAbsolute(documentDirectory) ? documentDirectory : null, 57var contentDirectory = PathUtilities.GetDirectoryName(contentPrefix.ToString());

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)

417return 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)

1617PathUtilities.GetFileName(oldCompilationOutputs.AssemblyDisplayPath) ?? oldProject.Name + ".dll", 1624PathUtilities.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 (2)

77if (!PathUtilities.IsAbsolute(project.FilePath)) 122if (!PathUtilities.IsAbsolute(textDocumentState.FilePath))

Emit\CompilationOutputFilesWithImplicitPdbPath.cs (1)

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

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (1)

172if (PathUtilities.IsAbsolute(sourceDocument.FilePath) && File.Exists(sourceDocument.FilePath))

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\MiscellaneousFileUtilities.cs (3)

21&& PathUtilities.GetExtension(filePath) == languageInformation.ScriptExtension; 35var fileName = PathUtilities.GetFileName(filePath); 115var baseDirectory = PathUtilities.GetDirectoryName(filePath);

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (2)

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

EditAndContinue\Extensions.cs (2)

109var name = PathUtilities.GetFileName(path); 115if (!PathUtilities.IsAbsolute(path))

FileBasedPrograms\CsprojInConeChecker.cs (4)

48if (!PathUtilities.IsAbsolute(csFilePath)) 53var directoryName = PathUtilities.GetDirectoryName(csFilePath); 54while (PathUtilities.IsSameDirectoryOrChildOf(child: directoryName, parent: workspaceFolder)) 60directoryName = PathUtilities.GetDirectoryName(directoryName);

FileBasedPrograms\FileBasedProgramsProjectSystem.cs (2)

142if (!PathUtilities.IsAbsolute(filePath)) 221Contract.ThrowIfFalse(PathUtilities.IsAbsolute(documentFilePath));

FileBasedPrograms\VirtualProjectXmlProvider.cs (1)

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

HostWorkspace\LanguageServerProjectLoader.cs (1)

369FilePath = PathUtilities.IsAbsolute(projectPath) && File.Exists(projectPath) ? projectPath : null,

HostWorkspace\LanguageServerProjectSystem.cs (1)

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

HostWorkspace\LanguageServerWorkspace.cs (1)

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

HostWorkspace\LoadedProject.cs (2)

184if (PathUtilities.IsAbsolute(document.FilePath)) 194Contract.ThrowIfFalse(PathUtilities.IsAbsolute(document.FilePath), "We do not expect to remove a file which is not on disk from the project.");

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) 559if (PathUtilities.IsAbsolute(mappedSpan.FilePath))

ProtocolConversionsTests.cs (3)

42if (c == '?' && PathUtilities.IsUnixLikePlatform) 45var filePath = PathUtilities.IsUnixLikePlatform ? $"/_{c}/" : $"C:\\_{c}\\"; 46var uriPrefix = PathUtilities.IsUnixLikePlatform ? "_" : "C:/_";

Diagnostics\DiagnosticDataLocation.cs (2)

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

Diagnostics\DocumentAnalysisScope.cs (1)

54return 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)

926=> 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)

42var diagnosticFilePath = PathUtilities.GetDirectoryName(diagnostic?.Location.SourceTree?.FilePath ?? project.FilePath); 43if (!PathUtilities.IsAbsolute(diagnosticFilePath)) 58var analyzerConfigDirectory = PathUtilities.GetDirectoryName(analyzerConfigDocument.FilePath)!; 76if (!PathUtilities.IsAbsolute(solutionOrProjectFilePath)) 81var solutionOrProjectDirectoryPath = PathUtilities.GetDirectoryName(solutionOrProjectFilePath); 83return PathUtilities.CombineAbsoluteAndRelativePaths(solutionOrProjectDirectoryPath!, ".editorconfig"); 89Debug.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)

156Debug.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 (6)

360if (!PathUtilities.IsAbsolute(ProjectInfo.FilePath)) 371var projectDirectory = PathUtilities.GetDirectoryName(ProjectInfo.FilePath); 374var sourceFilePath = PathUtilities.CombinePathsUnchecked(projectDirectory, "\0" + extension); 400var projectPath = PathUtilities.GetDirectoryName(projectFilePath); 403PathUtilities.GetDirectoryName(projectFilePath) is string directory) 405return PathUtilities.CombinePathsUnchecked(directory, documentState.Name);

MSBuild\MSBuildProjectLoader.cs (3)

134var solutionDirectory = PathUtilities.GetDirectoryName(solutionFilePath) + PathUtilities.DirectorySeparatorChar; 294Debug.Assert(projectFilePaths.All(PathUtilities.IsAbsolute));

MSBuild\MSBuildProjectLoader.Worker.cs (4)

92_pathToDiscoveredProjectInfosMap = new Dictionary<string, ImmutableArray<ProjectInfo>>(PathUtilities.Comparer); 99var processedPaths = new HashSet<string>(PathUtilities.Comparer); 332if (PathUtilities.IsAbsolute(path)) 391var paths = new HashSet<string>(PathUtilities.Comparer);

MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (2)

69var builder = ImmutableDictionary.CreateBuilder<string, HashSet<int>>(PathUtilities.Comparer); 191var projectDirectory = PathUtilities.GetDirectoryName(projectFileInfo.FilePath);

MSBuild\MSBuildWorkspace.cs (3)

556return GlobalAssemblyCacheLocation.RootLocations.Any(static (gloc, filePath) => PathUtilities.IsChildPath(gloc, filePath), filePath); 576return PathUtilities.IsChildPath(FrameworkRoot, filePath); 606var 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)

370var 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); 722var 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))

ProjectSystem\CPS\CPSProject_IWorkspaceProjectContext.cs (2)

118if (!PathUtilities.IsAbsolute(value)) 192if (PathUtilities.IsAbsolute(value))

ProjectSystem\CPS\CPSProjectFactory.cs (3)

167if (!PathUtilities.IsAbsolute(path)) 169path = Path.Combine(PathUtilities.GetDirectoryName(projectFilePath), path); 172if (!PathUtilities.IsAbsolute(path))

SolutionExplorer\AnalyzersCommandHandler.cs (1)

518var ruleSetFileRelativePath = PathUtilities.GetRelativePath(projectDirectoryFullPath, ruleSetFileFullPath);

Services\SolutionServiceTests.cs (1)

100var dirName = PathUtilities.GetDirectoryName(filePath);