Support relative paths in interceptors

docs/features/interceptors.md

@@ -68,20 +68,13 @@ File-local declarations of this type (`file class InterceptsLocationAttribute`)
 
 #### File paths
 
-File paths used in `[InterceptsLocation]` are expected to have `/pathmap` substitution already applied. Generators should accomplish this by locally recreating the file path transformation performed by the compiler:
+The *referenced syntax tree* of an `[InterceptsLocationAttribute]` is determined using the following rules:
+1. A *mapped path* of each syntax tree is determined by applying [`/pathmap`](https://learn.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.commandlinearguments.pathmap?view=roslyn-dotnet-4.7.0) substitution to `SyntaxTree.FilePath`.
+2. For a given `[InterceptsLocation]` usage, the `filePath` argument value is compared to the *mapped path* of each syntax tree using ordinal string comparison. If exactly one syntax tree matches under this comparison, that is the *referenced syntax tree*.
+3. If no syntax tree matched by the above comparison, then the `filePath` argument value is resolved relative to path of the containing syntax tree of the `[InterceptsLocation]` usage. Pathmap substitution is applied to the result of this relative resolution. If exactly one syntax tree matches this resolved and mapped path, that is the *referenced syntax tree*.
+4. If neither of the above methods of comparison matched exactly one syntax tree, an error occurs.
 
-```cs
-using Microsoft.CodeAnalysis;
-
-string GetInterceptorFilePath(SyntaxTree tree, Compilation compilation)
-{
-    return compilation.Options.SourceReferenceResolver?.NormalizePath(tree.FilePath, baseFilePath: null) ?? tree.FilePath;
-}
-```
-
-The file path given in the attribute must be equal by ordinal comparison to the value given by the above function.
-
-The compiler does not map `#line` directives when determining if an `[InterceptsLocation]` attribute intercepts a particular call in syntax.
+Note that `#line` directives are not considered when determining the call referenced by an `[InterceptsLocation]` attribute.
 
 #### Position
 

src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs

@@ -373,9 +373,9 @@ protected override void ResolveEmbeddedFilesFromExternalSourceDirectives(
             }
         }
 
-        private protected override GeneratorDriver CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts)
+        private protected override GeneratorDriver CreateGeneratorDriver(string baseDirectory, ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts)
         {
-            return CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, analyzerConfigOptionsProvider);
+            return CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, analyzerConfigOptionsProvider, driverOptions: new GeneratorDriverOptions() { BaseDirectory = baseDirectory });
         }
 
         private protected override void DiagnoseBadAccesses(TextWriter consoleOutput, ErrorLogger? errorLogger, Compilation compilation, ImmutableArray<Diagnostic> diagnostics)

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -1057,10 +1057,10 @@ internal OneOrMany<SyntaxTree> GetSyntaxTreesByMappedPath(string mappedPath)
             ImmutableSegmentedDictionary<string, OneOrMany<SyntaxTree>> computeMappedPathToSyntaxTree()
             {
                 var builder = ImmutableSegmentedDictionary.CreateBuilder<string, OneOrMany<SyntaxTree>>();
-                var resolver = Options.SourceReferenceResolver;
+                var resolver = Options.SourceReferenceResolver ?? SourceFileResolver.Default;
                 foreach (var tree in SyntaxTrees)
                 {
-                    var path = resolver?.NormalizePath(tree.FilePath, baseFilePath: null) ?? tree.FilePath;
+                    var path = resolver.NormalizePath(tree.FilePath, baseFilePath: null) ?? tree.FilePath;
                     builder[path] = builder.ContainsKey(path) ? builder[path].Add(tree) : OneOrMany.Create(tree);
                 }
                 return builder.ToImmutable();

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2202,7 +2202,7 @@ internal enum ErrorCode
         ERR_InterceptorLineOutOfRange = 9142,
         ERR_InterceptorCharacterOutOfRange = 9143,
         ERR_InterceptorSignatureMismatch = 9144,
-        ERR_InterceptorPathNotInCompilationWithUnmappedCandidate = 9145,
+        // ERR_InterceptorPathNotInCompilationWithUnmappedCandidate = 9145,
         ERR_InterceptorMethodMustBeOrdinary = 9146,
         ERR_InterceptorMustReferToStartOfTokenPosition = 9147,
         ERR_InterceptorMustHaveMatchingThisParameter = 9148,

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2348,7 +2348,6 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_InterceptorContainingTypeCannotBeGeneric:
                 case ErrorCode.ERR_InterceptorPathNotInCompilation:
                 case ErrorCode.ERR_InterceptorPathNotInCompilationWithCandidate:
-                case ErrorCode.ERR_InterceptorPathNotInCompilationWithUnmappedCandidate:
                 case ErrorCode.ERR_InterceptorPositionBadToken:
                 case ErrorCode.ERR_InterceptorLineOutOfRange:
                 case ErrorCode.ERR_InterceptorCharacterOutOfRange:

src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs

@@ -1000,29 +1000,31 @@ private void DecodeInterceptsLocationAttribute(DecodeWellKnownAttributeArguments
                 return;
             }
 
-            var syntaxTrees = DeclaringCompilation.SyntaxTrees;
+            var referenceResolver = DeclaringCompilation.Options.SourceReferenceResolver ?? SourceFileResolver.Default;
+
+            // First, the attributeFilePath might be a mapped path of one of the trees in the compilation.
+            // In this case, it's not intended to be resolved relative to anything, and we won't know if this is the case until we look it up.
             var matchingTrees = DeclaringCompilation.GetSyntaxTreesByMappedPath(attributeFilePath);
+            if (matchingTrees.Count == 0
+                && referenceResolver.NormalizePath(attributeFilePath, baseFilePath: SyntaxTree.FilePath) is { } normalizedFilePath)
+            {
+                // Try again but normalize the given file path relative to the containing file of the attribute application
+                matchingTrees = DeclaringCompilation.GetSyntaxTreesByMappedPath(normalizedFilePath);
+
+                // Use the normalized path in the following diagnostic messages so the user has a hint of where we are searching.
+                // Relative paths are the happy path so we want them to know how the compiler has resolved the path they gave us.
+                attributeFilePath = normalizedFilePath;
+            }
+
             if (matchingTrees.Count == 0)
             {
-                var referenceResolver = DeclaringCompilation.Options.SourceReferenceResolver;
                 // if we expect '/_/Program.cs':
 
-                // we might get: 'C:\Project\Program.cs' <-- path not mapped
-                var unmappedMatch = syntaxTrees.FirstOrDefault(static (tree, filePath) => tree.FilePath == filePath, attributeFilePath);
-                if (unmappedMatch != null)
-                {
-                    diagnostics.Add(
-                        ErrorCode.ERR_InterceptorPathNotInCompilationWithUnmappedCandidate,
-                        attributeData.GetAttributeArgumentLocation(filePathParameterIndex),
-                        attributeFilePath,
-                        mapPath(referenceResolver, unmappedMatch));
-                    return;
-                }
-
                 // we might get: '\_\Program.cs' <-- slashes not normalized
                 // we might get: '\_/Program.cs' <-- slashes don't match
                 // we might get: 'Program.cs' <-- suffix match
                 // Force normalization of all '\' to '/', but when we recommend a path in the diagnostic message, ensure it will match what we expect if the user decides to use it.
+                var syntaxTrees = DeclaringCompilation.SyntaxTrees;
                 var suffixMatch = syntaxTrees.FirstOrDefault(static (tree, pair)
                     => mapPath(pair.referenceResolver, tree)
                         .Replace('\\', '/')