6 types derived from PortableExecutableReference
Microsoft.CodeAnalysis (1)
MetadataReference\MetadataImageReference.cs (1)
16internal sealed class MetadataImageReference : PortableExecutableReference
Microsoft.CodeAnalysis.Workspaces (3)
Serialization\SerializedPortableExecutableReference.cs (1)
19private sealed class SerializedPortableExecutableReference : PortableExecutableReference, ISupportTemporaryStorage
Serialization\SerializerService_Reference.cs (1)
560private sealed class MissingMetadataReference : PortableExecutableReference
Workspace\Host\Metadata\MetadataServiceFactory.cs (1)
41: PortableExecutableReference(properties, resolvedPath)
rzc (1)
CachingMetadataReference.cs (1)
10internal sealed class CachingMetadataReference : PortableExecutableReference
VBCSCompiler (1)
src\roslyn\src\Compilers\Server\VBCSCompiler\MetadataCache.cs (1)
112internal sealed class CachingMetadataReference : PortableExecutableReference
227 references to PortableExecutableReference
ConfigurationSchemaGenerator (2)
ConfigSchemaGenerator.cs (2)
18var inputReference = CreateMetadataReference(inputAssembly); 45internal static PortableExecutableReference CreateMetadataReference(string path)
Microsoft.CodeAnalysis (49)
CommandLine\CommandLineArguments.cs (5)
436internal static ImmutableArray<PortableExecutableReference> ResolveMetadataReference(CommandLineReference cmdReference, MetadataReferenceResolver metadataResolver, List<DiagnosticInfo>? diagnosticsOpt, CommonMessageProvider? messageProviderOpt) 441ImmutableArray<PortableExecutableReference> references; 448var diagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProviderOpt!, Location.None, cmdReference.Reference, cmdReference.Properties.Kind); 450return ImmutableArray<PortableExecutableReference>.Empty; 457return ImmutableArray<PortableExecutableReference>.Empty;
CommandLine\CommonCompiler.cs (1)
197internal virtual Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()
CommandLine\CommonCompiler.ExistingReferencesResolver.cs (3)
44public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties) 52var peReference = metadataReference as PortableExecutableReference;
CommandLine\CommonCompiler.LoggingMetadataFileReferenceResolver.cs (4)
17private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _provider; 19public LoggingMetadataFileReferenceResolver(RelativePathResolver pathResolver, Func<string, MetadataReferenceProperties, PortableExecutableReference> provider, TouchedFileLogger? logger) 29public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties) 39return ImmutableArray<PortableExecutableReference>.Empty;
Compilation\Compilation.cs (2)
701var peReference = reference as PortableExecutableReference;
Compilation\DeterministicKeyBuilder.cs (1)
369if (reference is PortableExecutableReference peReference)
MetadataReference\AssemblyMetadata.cs (1)
447public PortableExecutableReference GetReference(
MetadataReference\MetadataImageReference.cs (1)
39protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)
MetadataReference\MetadataReference.cs (4)
119public static PortableExecutableReference CreateFromImage( 157public static PortableExecutableReference CreateFromImage( 199public static PortableExecutableReference CreateFromStream( 241public static PortableExecutableReference CreateFromFile(
MetadataReference\MetadataReferenceResolver.cs (2)
17public abstract ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties); 31public virtual PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) => null;
MetadataReference\ModuleMetadata.cs (1)
376public PortableExecutableReference GetReference(DocumentationProvider? documentation = null, string? filePath = null, string? display = null)
MetadataReference\PortableExecutableReference.cs (6)
79public new PortableExecutableReference WithAliases(IEnumerable<string> aliases) 89public new PortableExecutableReference WithAliases(ImmutableArray<string> aliases) 99public new PortableExecutableReference WithEmbedInteropTypes(bool value) 109public new PortableExecutableReference WithProperties(MetadataReferenceProperties properties) 130protected abstract PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties); 162/// Returns a copy of the <see cref="Metadata"/> object this <see cref="PortableExecutableReference"/>
PEWriter\MetadataWriter.PortablePdb.cs (1)
965if (referenceManager.GetMetadataReference(pair.AssemblySymbol) is PortableExecutableReference { FilePath: { } } portableReference)
ReferenceManager\CommonReferenceManager.Binding.cs (6)
105ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 222ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 274out PortableExecutableReference? resolvedReference)) 527ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 532[NotNullWhen(true)] out PortableExecutableReference? resolvedReference) 576PortableExecutableReference peReference,
ReferenceManager\CommonReferenceManager.Resolution.cs (7)
321var peReference = (PortableExecutableReference)boundReference; 476private Metadata? GetMetadata(PortableExecutableReference peReference, CommonMessageProvider messageProvider, Location location, DiagnosticBag diagnostics) 506newDiagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProvider, location, peReference.Display ?? "", peReference.Properties.Kind); 527private bool TryGetObservedMetadata(PortableExecutableReference peReference, DiagnosticBag diagnostics, out Metadata? metadata) 546internal AssemblyMetadata? GetAssemblyMetadata(PortableExecutableReference peReference, DiagnosticBag diagnostics) 869private static PortableExecutableReference? ResolveReferenceDirective(string reference, Location location, TCompilation compilation)
ReferenceManager\CommonReferenceManager.State.cs (4)
48internal abstract ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> ImplicitReferenceResolutions { get; } 132private ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>? _lazyImplicitReferenceResolutions; 259internal override ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> ImplicitReferenceResolutions 414ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions,
Microsoft.CodeAnalysis.CSharp (5)
Symbols\ReferenceManager.cs (1)
379ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>.Empty;
Symbols\Source\SourceAssemblySymbol.cs (2)
973var fileRef = pair.Key as PortableExecutableReference;
Symbols\SymbolDistinguisher.cs (2)
180PortableExecutableReference? metadataReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;
Microsoft.CodeAnalysis.Features (49)
AddImport\AbstractAddImportFeatureService.cs (21)
32: IAddImportFeatureService, IEqualityComparer<PortableExecutableReference> 36/// Cache of information about whether a <see cref="PortableExecutableReference"/> is likely contained within a 39private static readonly ConditionalWeakTable<PortableExecutableReference, StrongBox<bool>> s_isInPackagesDirectory = new(); 148var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count)); 173ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation, 262ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation, 274var seenReferences = new HashSet<PortableExecutableReference>(comparer: this); 275seenReferences.AddAll(project.MetadataReferences.OfType<PortableExecutableReference>()); 323private static ImmutableArray<(Project, PortableExecutableReference)> GetUnreferencedMetadataReferences( 324Project project, HashSet<PortableExecutableReference> seenReferences) 326using var _ = ArrayBuilder<(Project, PortableExecutableReference)>.GetInstance(out var result); 338if (reference is PortableExecutableReference peReference && 401private static bool IsInPackagesDirectory(PortableExecutableReference reference) 407static bool ComputeIsInPackagesDirectory(PortableExecutableReference reference) 415static bool ContainsPathComponent(PortableExecutableReference reference, string pathComponent) 430private static Compilation CreateCompilation(Project project, PortableExecutableReference reference) 437bool IEqualityComparer<PortableExecutableReference>.Equals(PortableExecutableReference? x, PortableExecutableReference? y) 450int IEqualityComparer<PortableExecutableReference>.GetHashCode(PortableExecutableReference obj)
AddImport\AddImportFixData.cs (3)
75/// is the id for the <see cref="Project"/> we can find that <see cref="PortableExecutableReference"/> 82/// If we want to add a <see cref="PortableExecutableReference"/> metadata reference, this 83/// is the <see cref="PortableExecutableReference.FilePath"/> for it.
AddImport\CodeActions\AssemblyReferenceCodeAction.cs (1)
98var reference = service.GetReference(resolvedPath, MetadataReferenceProperties.Assembly);
AddImport\CodeActions\MetadataSymbolReferenceCodeAction.cs (2)
30var reference = projectWithReference.MetadataReferences 31.OfType<PortableExecutableReference>()
AddImport\References\MetadataSymbolReference.cs (2)
25PortableExecutableReference reference) : SymbolReference(provider, symbolResult) 28private readonly PortableExecutableReference _reference = reference;
AddImport\SearchScopes\MetadataSymbolsSearchScope.cs (2)
19PortableExecutableReference metadataReference, 24private readonly PortableExecutableReference _metadataReference = metadataReference;
AddImport\SymbolReferenceFinder.cs (1)
100internal Task<ImmutableArray<SymbolReference>> FindInMetadataSymbolsAsync(IAssemblySymbol assembly, Project assemblyProject, PortableExecutableReference metadataReference, bool exact, CancellationToken cancellationToken)
Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionService.cs (4)
72private static MetadataId? GetMetadataId(PortableExecutableReference reference) 124foreach (var peReference in currentProject.MetadataReferences.OfType<PortableExecutableReference>()) 202PortableExecutableReference peReference,
Completion\Providers\ImportCompletionProvider\ExtensionMemberImportCompletionHelper.SymbolComputer.cs (4)
80foreach (var peReference in GetAllRelevantPeReferences(project)) 167private static ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences(Project project) 168=> [.. project.MetadataReferences.OfType<PortableExecutableReference>()]; 216PortableExecutableReference peReference,
DesignerAttribute\DesignerAttributeDiscoveryService.cs (3)
68if (reference is PortableExecutableReference peReference) 83PortableExecutableReference peReference, 106PortableExecutableReference peReference,
MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (3)
241var assemblyLocation = (metadataReference as PortableExecutableReference)?.FilePath; 397var peMetadataReference = compilation.GetMetadataReference(topLevelNamedType.ContainingAssembly) as PortableExecutableReference;
PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)
102if (compilation.GetMetadataReference(symbol.ContainingAssembly) is not PortableExecutableReference { FilePath: not null and var dllPath }) 138var dllReference = IOUtilities.PerformIO(() => MetadataReference.CreateFromFile(dllPath, documentation: documentationProvider.GetDocumentationProvider(dllPath)));
UnusedReferences\UnusedReferencesRemover.cs (1)
49.OfType<PortableExecutableReference>()
Microsoft.CodeAnalysis.Scripting (17)
Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (14)
40private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _createFromFileFunc; 54Func<string, MetadataReferenceProperties, PortableExecutableReference>? createFromFileFunc = null) 71Func<string, MetadataReferenceProperties, PortableExecutableReference>? createFromFileFunc = null) 85Func<string, MetadataReferenceProperties, PortableExecutableReference>? createFromfileFunc = null) 96public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 111var result = ResolveTrustedPlatformAssembly(referenceIdentity.Name, s_resolvedMissingAssemblyReferenceProperties); 119var definitionDirectory = PathUtilities.GetDirectoryName((definition as PortableExecutableReference)?.FilePath); 136private PortableExecutableReference CreateFromFile(string filePath, MetadataReferenceProperties properties) => 139private PortableExecutableReference CreateResolvedMissingReference(string fullPath) => 142public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties) 157var result = ResolveTrustedPlatformAssembly(PathUtilities.GetFileName(reference, includeExtension: false), properties); 186var result = ResolveTrustedPlatformAssembly(identity.Name, properties); 194return ImmutableArray<PortableExecutableReference>.Empty; 197private PortableExecutableReference? ResolveTrustedPlatformAssembly(string name, MetadataReferenceProperties properties)
ScriptBuilder.cs (1)
144var path = (referencedAssembly.Key as PortableExecutableReference)?.FilePath;
ScriptMetadataResolver.cs (2)
67public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 70public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties)
Microsoft.CodeAnalysis.VisualBasic (3)
CommandLine\VisualBasicCommandLineArguments.vb (1)
88Dim assemblyMetadata = TryCast(DirectCast(reference, PortableExecutableReference).GetMetadataNoCopy(), AssemblyMetadata)
Symbols\ReferenceManager.vb (1)
328ImmutableDictionary(Of AssemblyIdentity, PortableExecutableReference).Empty)
Symbols\Source\SourceAssemblySymbol.vb (1)
1347Dim fileRef = TryCast(pair.Key, PortableExecutableReference)
Microsoft.CodeAnalysis.Workspaces (82)
FindSymbols\Declarations\DeclarationFinder.cs (1)
70PortableExecutableReference reference,
FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (2)
115foreach (var peReference in project.MetadataReferences.OfType<PortableExecutableReference>())
FindSymbols\FindReferences\DependentProjectsFinder.cs (3)
27/// Cache from the <see cref="MetadataId"/> for a particular <see cref="PortableExecutableReference"/> to the 341using var _ = ArrayBuilder<(PortableExecutableReference reference, MetadataId metadataId)>.GetInstance(out var uncomputedReferences); 347if (reference is not PortableExecutableReference peReference)
FindSymbols\FindReferences\DependentTypeFinder.cs (4)
119using var _4 = PooledHashSet<PortableExecutableReference>.GetInstance(out var seenPEReferences); 311if (reference is not PortableExecutableReference peReference) 329seenPEReferences.AddRange(compilation.References.OfType<PortableExecutableReference>()); 336PortableExecutableReference reference,
FindSymbols\SymbolTree\ISymbolTreeInfoCacheService.cs (2)
13/// for metadata symbols in <see cref="PortableExecutableReference"/>s. 18ValueTask<SymbolTreeInfo?> TryGetPotentiallyStaleMetadataSymbolTreeInfoAsync(Project project, PortableExecutableReference reference, CancellationToken cancellationToken);
FindSymbols\SymbolTree\SymbolTreeInfo.cs (1)
21/// cref="Project"/> or <see cref="PortableExecutableReference"/>. This tree can be used to quickly determine if
FindSymbols\SymbolTree\SymbolTreeInfo_Metadata.cs (17)
32/// cref="PortableExecutableReference"/>. Generating symbol trees for metadata can be expensive (in large 40private static readonly ConditionalWeakTable<PortableExecutableReference, AsyncLazy<SymbolTreeInfo>> s_peReferenceToInfo = new(); 45/// cref="PortableExecutableReference"/>s, while having different checksums. For example, if the aliases of a 46/// <see cref="PortableExecutableReference"/> are changed (see <see 47/// cref="PortableExecutableReference.WithAliases(IEnumerable{string})"/>, then it will have a different 70public static MetadataId? GetMetadataIdNoThrow(PortableExecutableReference reference) 82private static Metadata? GetMetadataNoThrow(PortableExecutableReference reference) 95/// Produces a <see cref="SymbolTreeInfo"/> for a given <see cref="PortableExecutableReference"/>. 104PortableExecutableReference reference, 117/// Produces a <see cref="SymbolTreeInfo"/> for a given <see cref="PortableExecutableReference"/>. 127PortableExecutableReference reference, 146PortableExecutableReference reference, 171PortableExecutableReference reference, 201public static async Task<SymbolTreeInfo?> TryGetCachedInfoForMetadataReferenceIgnoreChecksumAsync(PortableExecutableReference reference, CancellationToken cancellationToken) 211SolutionServices services, PortableExecutableReference reference, CancellationToken cancellationToken) 228private static string GetMetadataKeySuffix(PortableExecutableReference reference) 238PortableExecutableReference reference,
FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (5)
31private readonly ConcurrentDictionary<PortableExecutableReference, MetadataInfo> _peReferenceToInfo = []; 70PortableExecutableReference reference, 153foreach (var reference in project.MetadataReferences.OfType<PortableExecutableReference>().Distinct()) 192PortableExecutableReference reference,
Serialization\SerializedPortableExecutableReference.cs (2)
51protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 60{nameof(PortableExecutableReference)}
Serialization\SerializerService_Reference.cs (12)
52if (reference is PortableExecutableReference portable) 102if (reference is PortableExecutableReference portable) 120if (type == nameof(PortableExecutableReference)) 192PortableExecutableReference reference, SerializationKinds kind, ObjectWriter writer) 194writer.WriteString(nameof(PortableExecutableReference)); 200private static void WritePortableExecutableReferencePropertiesTo(PortableExecutableReference reference, ObjectWriter writer) 206private static Checksum CreatePortableExecutableReferenceChecksum(PortableExecutableReference reference) 280PortableExecutableReference reference, ObjectWriter writer) 288private PortableExecutableReference ReadPortableExecutableReferenceFrom(ObjectReader reader) 367PortableExecutableReference reference, 546private static Metadata? TryGetMetadata(PortableExecutableReference reference) 589protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)
Workspace\Host\Metadata\IMetadataService.cs (2)
13/// Returns a <see cref="PortableExecutableReference"/> reference backed by the file at <paramref name="resolvedPath"/>. 16PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties);
Workspace\Host\Metadata\MetadataServiceFactory.cs (3)
37public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties) 38=> (PortableExecutableReference)_metadataCache.GetReference(resolvedPath, properties); 49protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)
Workspace\Host\Metadata\WorkspaceMetadataFileReferenceResolver.cs (1)
28public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
Workspace\ProjectSystem\ProjectSystemProject.cs (7)
680using var _1 = ArrayBuilder<PortableExecutableReference>.GetInstance(out var peReferencesRemoved); 681using var _2 = ArrayBuilder<PortableExecutableReference>.GetInstance(out var peReferencesAdded); 697var metadataReference = projectBeforeMutation.MetadataReferences 698.OfType<PortableExecutableReference>() 727var metadataReference = CreateMetadataReference_NoLock(path, properties, solutionChanges.Solution.Services); 1427foreach (var reference in remainingMetadataReferences.OfType<PortableExecutableReference>())
Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (8)
46public FileWatchedReferenceFactory<PortableExecutableReference> FileWatchedPortableExecutableReferenceFactory { get; } 436foreach (var reference in projectUpdateState.AddedMetadataReferences) 440foreach (var reference in projectUpdateState.RemovedMetadataReferences) 579if (reference is PortableExecutableReference peReference 674var metadataReference = CreateMetadataReference_NoLock( 830public static PortableExecutableReference CreateMetadataReference_NoLock( 839getReferences: static project => project.MetadataReferences.OfType<PortableExecutableReference>(), 902/// cref="PortableExecutableReference"/> or <see cref="AnalyzerFileReference"/>.
Workspace\ProjectSystem\ProjectSystemProjectFactory.ProjectUpdateState.cs (6)
55ImmutableArray<PortableExecutableReference> RemovedMetadataReferences, 56ImmutableArray<PortableExecutableReference> AddedMetadataReferences, 118public ProjectUpdateState WithIncrementalMetadataReferenceRemoved(PortableExecutableReference reference) 121public ProjectUpdateState WithIncrementalMetadataReferencesRemoved(ArrayBuilder<PortableExecutableReference> references) 124public ProjectUpdateState WithIncrementalMetadataReferenceAdded(PortableExecutableReference reference) 127public ProjectUpdateState WithIncrementalMetadataReferencesAdded(ArrayBuilder<PortableExecutableReference> references)
Workspace\Solution\SolutionCompilationState.RegularCompilationTracker.cs (1)
533var metadataReference = metadataService.GetReference(outputPath, new MetadataReferenceProperties(MetadataImageKind.Assembly, projectReference.Aliases, projectReference.EmbedInteropTypes));
Workspace\Solution\SolutionCompilationState.RootedSymbolSet.cs (1)
19=> new(reference.Properties, (reference as PortableExecutableReference)?.FilePath);
Workspace\Solution\SolutionCompilationState.SkeletonReferenceSet.cs (3)
32private readonly Dictionary<MetadataReferenceProperties, PortableExecutableReference> _referenceMap = []; 36public PortableExecutableReference GetOrCreateMetadataReference(MetadataReferenceProperties properties) 40if (!_referenceMap.TryGetValue(properties, out var value))
Workspace\Workspace.cs (1)
1468if (meta is PortableExecutableReference pemeta)
Microsoft.CodeAnalysis.Workspaces.MSBuild (3)
MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (1)
87PortableExecutableReference portableExecutableReference => portableExecutableReference.FilePath,
MSBuild\MSBuildWorkspace.cs (2)
590if (metadataReference is PortableExecutableReference peRef && peRef.FilePath != null) 626if (metadataReference is PortableExecutableReference peRef && peRef.FilePath != null)
Microsoft.Maui.Controls.SourceGen (2)
CodeBehindGenerator.cs (2)
785 return x.ExternalReferences.OfType<PortableExecutableReference>().SequenceEqual(y.ExternalReferences.OfType<PortableExecutableReference>());
rzc (4)
Application.cs (2)
18Func<string, MetadataReferenceProperties, PortableExecutableReference> assemblyReferenceProvider, 48public Func<string, MetadataReferenceProperties, PortableExecutableReference> AssemblyReferenceProvider { get; }
CachingMetadataReference.cs (1)
29protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)
CompilerHost.cs (1)
36public Func<string, MetadataReferenceProperties, PortableExecutableReference> AssemblyReferenceProvider { get; }
VBCSCompiler (11)
src\roslyn\src\Compilers\Server\VBCSCompiler\CompilerRequestHandler.cs (2)
46public static Func<string, MetadataReferenceProperties, PortableExecutableReference> SharedAssemblyReferenceProvider { get; } = (path, properties) => new CachingMetadataReference(path, properties); 51private Func<string, MetadataReferenceProperties, PortableExecutableReference> AssemblyReferenceProvider { get; } = SharedAssemblyReferenceProvider;
src\roslyn\src\Compilers\Server\VBCSCompiler\CSharpCompilerServer.cs (4)
17private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider; 21internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache, ICompilerServerLogger? logger = null) 26internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache, ICompilerServerLogger? logger = null) 34internal override Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()
src\roslyn\src\Compilers\Server\VBCSCompiler\MetadataCache.cs (1)
134protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)
src\roslyn\src\Compilers\Server\VBCSCompiler\VisualBasicCompilerServer.cs (4)
17private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider; 21internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache, ICompilerServerLogger? logger = null) 26internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache, ICompilerServerLogger? logger = null) 34internal override Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()