16internal sealed class MetadataImageReference : PortableExecutableReference

2168private sealed class EvolvingTestReference : PortableExecutableReference

15private sealed class ShadowCopyReference : PortableExecutableReference

47private sealed class ThrowingExecutableReference : PortableExecutableReference

14public class TestMetadataReference : PortableExecutableReference 55public class TestImageReference : PortableExecutableReference

462private class MyReference : PortableExecutableReference 493private class MyReference2 : PortableExecutableReference

19private sealed class SerializedPortableExecutableReference : PortableExecutableReference, ISupportTemporaryStorage

506private sealed class MissingMetadataReference : PortableExecutableReference

31private sealed class VisualStudioPortableExecutableReference : PortableExecutableReference, ISupportTemporaryStorage

716private sealed class MissingMetadataReference : PortableExecutableReference

112internal sealed class CachingMetadataReference : PortableExecutableReference

18var inputReference = CreateMetadataReference(inputAssembly); 45internal static PortableExecutableReference CreateMetadataReference(string path)

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;

209internal virtual Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()

44public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties) 52var peReference = metadataReference as PortableExecutableReference;

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;

681var peReference = reference as PortableExecutableReference;

293if (reference is PortableExecutableReference peReference)

447public PortableExecutableReference GetReference(

39protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

119public static PortableExecutableReference CreateFromImage( 157public static PortableExecutableReference CreateFromImage( 199public static PortableExecutableReference CreateFromStream( 241public static PortableExecutableReference CreateFromFile(

17public abstract ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties); 31public virtual PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) => null;

376public PortableExecutableReference GetReference(DocumentationProvider? documentation = null, string? filePath = null, string? display = null)

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"/>

965if (referenceManager.GetMetadataReference(pair.AssemblySymbol) is PortableExecutableReference { FilePath: { } } portableReference)

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,

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)

48internal abstract ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> ImplicitReferenceResolutions { get; } 132private ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>? _lazyImplicitReferenceResolutions; 259internal override ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> ImplicitReferenceResolutions 414ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions,

379ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>.Empty;

973var fileRef = pair.Key as PortableExecutableReference;

180PortableExecutableReference? metadataReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;

2153var resolver = new TestMetadataReferenceResolver(assemblyNames: new Dictionary<string, PortableExecutableReference>()

3473var reference = MetadataReference.CreateFromImage(compilation.EmitToArray()); 3519var libRef = MetadataReference.CreateFromImage(libComp.EmitToArray());

298var funcRef = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.InvalidFuncDelegateName.AsImmutableOrNull()); 11849var ilRef = MetadataReference.CreateFromImage(TestResources.MetadataTests.Interop.IndexerWithByRefParam.AsImmutableOrNull());

251var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 252var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses01; 368var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01;

4071var invalidAttributeReference = MetadataReference.CreateFromStream(peStream);

284var mscorlib17626 = MetadataReference.CreateFromImage(Net461.Resources.mscorlib);

356var asmRef = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01;

248var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream()); 282var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream()); 319var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream()); 357var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream()); 416var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream()); 478var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream());

2825var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 2826var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses01; 2918var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 2919var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses01; 2979var asm01 = TestReferences.MetadataTests.InterfaceAndClass.CSInterfaces01; 2980var asm02 = TestReferences.MetadataTests.InterfaceAndClass.CSClasses01; 3156var asm01 = TestReferences.MetadataTests.InterfaceAndClass.CSInterfaces01; 3157var asm02 = TestReferences.MetadataTests.InterfaceAndClass.CSClasses01; 3216var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 3217var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses02; 3368var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 3369var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses01; 3473var asmfile = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01;

15134var testReference = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.Metadata.BadDefaultParameterValue).GetReference();

23500var libCompRef = AssemblyMetadata.CreateFromImage(libComp.EmitToArray()).GetReference(); 23899var libCompRef = AssemblyMetadata.CreateFromImage(libComp.EmitToArray()).GetReference();

619var ilAssemblyReference = TestReferences.SymbolsTests.Events; 647var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream());

895var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference(); 1313var reference = ModuleMetadata.CreateFromImage(moduleComp.EmitToArray()).GetReference(); 2681var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 2741var libAssemblyReference = MetadataReference.CreateFromImage(dllImage.AsImmutableOrNull()); 4622var metadataRef = ModuleMetadata.CreateFromStream(comp.EmitToStream()).GetReference();

24var mscorlibRef = Net40.References.mscorlib; 99var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 158var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 210var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 281var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 374var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 456var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 508var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 551var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll;

184var metadataTestLib1 = TestReferences.SymbolsTests.MDTestLib1; 185var metadataTestLib2 = TestReferences.SymbolsTests.MDTestLib2; 237var netModule1 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule1).GetReference(filePath: Path.GetFullPath("netModule1.netmodule")); 238var netModule2 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule2).GetReference(filePath: Path.GetFullPath("netModule2.netmodule")); 3765var reference = AssemblyMetadata.CreateFromStream(stream).GetReference(); 3807var reference = AssemblyMetadata.CreateFromStream(stream).GetReference(); 3841var reference = AssemblyMetadata.CreateFromStream(metadataStream).GetReference();

378var netModule1 = TestReferences.SymbolsTests.netModule.netModule1;

4886var ref1 = MetadataReference.CreateFromStream(metadataStream1); 4896var ref2 = MetadataReference.CreateFromStream(metadataStream2);

578var hash_module = TestReferences.SymbolsTests.netModule.hash_module;

109var reference = ModuleMetadata.CreateFromImage(module.EmitToArray()).GetReference();

1521var reference = ModuleMetadata.CreateFromImage(referenceComp.EmitToArray()).GetReference(); 1562var reference = ModuleMetadata.CreateFromImage(referenceComp.EmitToArray()).GetReference(); 1623var moduleReference = ModuleMetadata.CreateFromImage(compilation.EmitToArray()).GetReference();

6230var peReference = MetadataReference.CreateFromStream(CreateCompilation(peSource).EmitToStream());

545var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 605var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 638var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 683var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream());

3566var lib = CreateCompilation([source1, CallerArgumentExpressionAttributeDefinition])

163files: new Dictionary<string, PortableExecutableReference> { { @"C:\dir\x.dll", (PortableExecutableReference)SystemCoreRef } })); 461var badTypeRef = MetadataReference.CreateFromImage(badTypeBytes.AsImmutableOrNull()); 568var libRef = MetadataImageReference.CreateFromImage(libImage); 644Assert.Equal(fileBase1.Path, ((PortableExecutableReference)libBaseRefAndSymbol.Key).FilePath); 702Assert.Equal(fileBase1.Path, ((PortableExecutableReference)libBaseRefAndSymbol.Key).FilePath);

86var libDRef = MetadataReference.CreateFromFile(libDFile.Path); 131var libBRef = MetadataReference.CreateFromFile(libBFile.Path);

952var r1 = AssemblyMetadata.CreateFromImage(TestResources.General.C1).GetReference(filePath: @"c:\temp\a.dll", display: "R1"); 953var r2 = AssemblyMetadata.CreateFromImage(TestResources.General.C1).GetReference(filePath: @"c:\temp\a.dll", display: "R2"); 1088var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1114var reference2 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1161var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1172var reference2 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1198var referenceA = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1210var referenceB = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1240var referenceA = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 1251var referenceB = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData);

338var asm = TestReferences.SymbolsTests.CustomModifiers.ModoptTests; 361var asm = TestReferences.SymbolsTests.CustomModifiers.ModoptTests; 382var asm = TestReferences.SymbolsTests.CustomModifiers.ModoptTests; 407var asm = TestReferences.SymbolsTests.CustomModifiers.ModoptTests; 445var asm = MetadataReference.CreateFromImage(TestResources.SymbolsTests.CustomModifiers.ModoptTests.AsImmutableOrNull()); 472var asm = TestReferences.SymbolsTests.CustomModifiers.ModoptTests;

1581var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1622var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1660var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1701var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream());

3071var reference1 = MetadataReference.CreateFromStream(compilation1.EmitToStream());

30var mscorlibRef = AssemblyMetadata.CreateFromImage(Net461.Resources.mscorlib).GetReference(display: "mscorlib");

6829var libRef = TestReferences.SymbolsTests.BigVisitor;

4556var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 7804var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 12902var systemRef = NetFramework.System;

374var oldMsCorLib = Net40.References.mscorlib;

31var referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream()); 153var referenceA = MetadataReference.CreateFromStream(compilationA.EmitToStream());

935var delegatesWithoutInvokeReference = TestReferences.SymbolsTests.DelegateImplementation.DelegatesWithoutInvoke; 995var csharpAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.CSharp; 996var ilAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.IL; 1168var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1169var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 1182var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1183var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 1196var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1197var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 2280var unavailableAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 2281var csharpAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.CSharp; 2282var ilAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.IL;

3353PortableExecutableReference[] metadataRefs = 3382var modifiedRef = metadataRefs[0].WithAliases(new[] { "Alias " });

27var cl2 = TestReferences.SymbolsTests.MissingTypes.CL2; 28var cl3 = TestReferences.SymbolsTests.MissingTypes.CL3; 737var cl2 = TestReferences.SymbolsTests.MissingTypes.CL2; 738var cl3 = TestReferences.SymbolsTests.MissingTypes.CL3;

489var ref1 = NetFramework.mscorlib; 490var ref2 = NetFramework.System; 589new TestMetadataReferenceResolver(files: new Dictionary<string, PortableExecutableReference>() 964var ref1 = NetFramework.mscorlib; 1184var ref1 = NetFramework.mscorlib; 1185var ref2 = NetFramework.System; 1215var modRef1 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 1352var modRef1 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 1409var ref1 = NetFramework.mscorlib; 1410var ref2 = NetFramework.System; 1411var ref3 = NetFramework.SystemData; 1412var ref4 = NetFramework.SystemXml; 1450var ref1 = NetFramework.mscorlib; 1471var ref1 = NetFramework.mscorlib; 1472var ref2 = NetFramework.SystemXml; 1893var alias = NetFramework.System.WithAliases(new[] { "alias" }); 2191protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 2298var mdRef = MetadataReference.CreateFromImage(refData); 2349var metadata = NetFramework.mscorlib; 3100var moduleReference = MetadataReference.CreateFromStream(moduleStream, MetadataReferenceProperties.Module); 3119var moduleReference = MetadataReference.CreateFromStream(moduleStream, MetadataReferenceProperties.Module); 3140var moduleReference = MetadataReference.CreateFromStream(moduleStream, MetadataReferenceProperties.Assembly);

433public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)

41var wimpl = AssemblyMetadata.CreateFromImage(TestResources.WinRt.WImpl).GetReference(display: "WImpl"); 61var v1 = AssemblyMetadata.CreateFromImage(TestResources.General.C1).GetReference(display: "C, V1"); 64var v2 = AssemblyMetadata.CreateFromImage(TestResources.General.C2).GetReference(display: "C, V2"); 105var v1 = MetadataReference.CreateFromImage(TestResources.General.C1); 106var v2 = MetadataReference.CreateFromImage(TestResources.General.C2); 741var r1 = AssemblyMetadata.CreateFromImage(Net461.Resources.SystemCore).GetReference(filePath: @"c:\temp\aa.dll", display: "System.Core.v4_0_30319.dll"); 742var r2 = AssemblyMetadata.CreateFromImage(Net461.Resources.SystemCore).GetReference(filePath: @"c:\temp\aa.dll", display: "System.Core.v4_0_30319.dll"); 743var r2_SysCore = r2.WithAliases(new[] { "SysCore" }); 756var r1 = AssemblyMetadata.CreateFromImage(TestResources.General.C1).GetReference(filePath: @"c:\temp\a.dll", display: "R1"); 757var r2 = AssemblyMetadata.CreateFromImage(TestResources.General.C1).GetReference(filePath: @"c:\temp\a.dll", display: "R2"); 758var rGoo = r2.WithAliases(new[] { "goo" }); 759var rBar = r2.WithAliases(new[] { "bar" }); 760var rEmbed = r1.WithEmbedInteropTypes(true); 856var r1 = MetadataReference.CreateFromFile(p1); 857var r2 = MetadataReference.CreateFromFile(p2); 858var r3 = MetadataReference.CreateFromFile(p3); 871assemblyNames: new Dictionary<string, PortableExecutableReference> { { "Lib", r3 } }, 872files: new Dictionary<string, PortableExecutableReference> { { p2, r2 }, { p3, r3 } })) 898var dr1 = compilation.GetDirectiveReference(rd1) as PortableExecutableReference; 899var dr2 = compilation.GetDirectiveReference(rd2) as PortableExecutableReference; 900var dr3 = compilation.GetDirectiveReference(rd3) as PortableExecutableReference; 927var m1 = MetadataReference.CreateFromFile(p1, new MetadataReferenceProperties(MetadataImageKind.Module)); 928var m2 = MetadataReference.CreateFromFile(p2, new MetadataReferenceProperties(MetadataImageKind.Module)); 959var ref1 = AssemblyMetadata.CreateFromImage(TestResources.General.C2).GetReference(embedInteropTypes: true, filePath: @"R:\A\MTTestLib1.dll"); 960var ref2 = AssemblyMetadata.CreateFromImage(TestResources.General.C2).GetReference(embedInteropTypes: false, filePath: @"R:\B\MTTestLib1.dll"); 996var r1 = MetadataReference.CreateFromFile(p1); 997var r2 = MetadataReference.CreateFromFile(p2); 1043var ref1 = AssemblyMetadata.CreateFromFile(exe1.Path).GetReference(aliases: ImmutableArray.Create("A1")); 1044var ref2 = AssemblyMetadata.CreateFromFile(exe2.Path).GetReference(aliases: ImmutableArray.Create("A2")); 1129var mdRefLib1 = metadataLib1.GetReference(filePath: @"C:\W1.dll"); 1130var mdRefLib2 = metadataLib2.GetReference(filePath: @"C:\W2.dll"); 1164var mdRefLib1 = metadataLib1.GetReference(filePath: @"C:\W1.dll"); 1165var mdRefLib2 = metadataLib2.GetReference(filePath: @"C:\WB.dll"); 1194var mdRefLib1 = metadataLib1.GetReference(filePath: @"C:\WB.dll"); 1195var mdRefLib2 = metadataLib2.GetReference(filePath: @"C:\WB_Version1.dll"); 1214var arSA = TestReferences.SymbolsTests.Versioning.AR_SA; 1215var enUS = TestReferences.SymbolsTests.Versioning.EN_US; 1246public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 1259return ImmutableArray<PortableExecutableReference>.Empty; 1305public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 1368files: new Dictionary<string, PortableExecutableReference>() 1394var refB = MetadataReference.CreateFromImage(b.EmitToArray()); 1404var refA2 = MetadataReference.CreateFromImage(a2.EmitToArray()); 1441var refB = MetadataReference.CreateFromImage(b.EmitToArray()); 1445var refA2 = MetadataReference.CreateFromImage(a2.EmitToArray()); 1646var oldRef = oldMetadata.GetReference(); 1733var refLib = ((MetadataImageReference)lib.EmitToImageReference()).WithEmbedInteropTypes(true); 1763var assemblyRef = assemblyMetadata.GetReference(); 2328new TestMetadataReferenceResolver(assemblyNames: new Dictionary<string, PortableExecutableReference>() 2330{ "a", (PortableExecutableReference)aRef.WithProperties(MetadataReferenceProperties.Assembly.WithRecursiveAliases(true)) } 2357new TestMetadataReferenceResolver(assemblyNames: new Dictionary<string, PortableExecutableReference>() 2359{ "a", (PortableExecutableReference)aRef.WithProperties(MetadataReferenceProperties.Assembly) }

7987var reference = TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(false); 7997var reference = TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(true);

198var csharpAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.CSharp; 199var ilAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.IL;

3139var hostReference = MetadataReference.CreateFromFile(typeof(ScriptGlobals).Assembly.Location); 4851var mtref = MetadataReference.CreateFromImage(mtdata);

822var asm01 = TestReferences.MetadataTests.InterfaceAndClass.VBInterfaces01; 823var asm02 = TestReferences.MetadataTests.InterfaceAndClass.VBClasses01; 872var mtref = MetadataReference.CreateFromImage(mtdata);

373var aliasedCorlib = NetFramework.mscorlib.WithAliases(ImmutableArray.Create("Goo"));

70var mdTestLib1 = TestReferences.SymbolsTests.MDTestLib1; 109var mscorlibRef = NetFramework.mscorlib; 110var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 128var varV1MTTestLib2Ref = TestReferences.SymbolsTests.V1.MTTestLib2.dll; 172var varV2MTTestLib3Ref = TestReferences.SymbolsTests.V2.MTTestLib3.dll; 229var varV3MTTestLib4Ref = TestReferences.SymbolsTests.V3.MTTestLib4.dll; 2614var mscorlibRef = NetFramework.mscorlib; 2615var systemCoreRef = NetFramework.SystemCore; 2616var systemRef = NetFramework.System; 2647public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 2666return ImmutableArray<PortableExecutableReference>.Empty; 2761public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 2859var r = TestReferences.SymbolsTests.Metadata.InvalidCharactersInAssemblyName;

26var mscorlibRef = Net40.References.mscorlib; 227var mscorlibRef = Net40.References.mscorlib; 299var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll;

62579private static string BuildAssemblyExternClause(PortableExecutableReference reference) 62624var windowsRuntimeRef = CompilationExtensions.CreateWindowsRuntimeMetadataReference(TargetFramework.Net50);

31var reference1 = MetadataReference.CreateFromImage(compilation1.EmitToArray(options: new EmitOptions(metadataOnly: true))); 45var reference2 = MetadataReference.CreateFromImage(compilation2.EmitToArray(options: new EmitOptions(metadataOnly: true)));

3298var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 3311var reference2 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData);

1691var reference2 = MetadataReference.CreateFromImage(compilation2.EmittedAssemblyData);

1052var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 1106var ilAssemblyReference = TestReferences.SymbolsTests.Interface.StaticMethodInInterface; 1124var ilAssemblyReference = TestReferences.SymbolsTests.Interface.StaticMethodInInterface;

347var modRef = TestReferences.MetadataTests.NetModule01.ModuleCS00;

309var mscorlibRef = Net40.References.mscorlib; 315var localMTTestLib1Ref = TestReferences.SymbolsTests.V1.MTTestLib1.dll; 333var crossRefModule1 = TestReferences.SymbolsTests.netModule.CrossRefModule1; 334var crossRefModule2 = TestReferences.SymbolsTests.netModule.CrossRefModule2; 335var crossRefLib = TestReferences.SymbolsTests.netModule.CrossRefLib;

437var dll = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.InvalidDynamicAttributeArgs.AsImmutableOrNull());

197var mdRef = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.InvalidGenericType.AsImmutableOrNull());

1263var longFormRef = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.LongTypeFormInSignature); 1287var lib = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.Signatures.SignatureCycle2); 1307var lib = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.Signatures.TypeSpecInWrongPlace);

365var mscorlibRef = Net40.References.mscorlib; 366var pia1CopyLink = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(true); 367var pia1CopyRef = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(false); 687var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 688var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 689var piaRef = TestReferences.SymbolsTests.NoPia.Pia1; 690var localTypes1Ref = TestReferences.SymbolsTests.NoPia.LocalTypes1; 747var mscorlibRef = Net40.References.mscorlib; 748var pia5Link = TestReferences.SymbolsTests.NoPia.Pia5.WithEmbedInteropTypes(true); 749var pia5Ref = TestReferences.SymbolsTests.NoPia.Pia5.WithEmbedInteropTypes(false); 750var library2Ref = TestReferences.SymbolsTests.NoPia.Library2.WithEmbedInteropTypes(false); 751var library2Link = TestReferences.SymbolsTests.NoPia.Library2.WithEmbedInteropTypes(true); 752var pia1Link = TestReferences.SymbolsTests.NoPia.Pia1.WithEmbedInteropTypes(true); 753var pia1Ref = TestReferences.SymbolsTests.NoPia.Pia1.WithEmbedInteropTypes(false); 872var varmscorlibRef = Net40.References.mscorlib; 873var varALink = TestReferences.SymbolsTests.NoPia.A.WithEmbedInteropTypes(true); 874var varARef = TestReferences.SymbolsTests.NoPia.A.WithEmbedInteropTypes(false); 875var varBLink = TestReferences.SymbolsTests.NoPia.B.WithEmbedInteropTypes(true); 876var varBRef = TestReferences.SymbolsTests.NoPia.B.WithEmbedInteropTypes(false); 877var varCLink = TestReferences.SymbolsTests.NoPia.C.WithEmbedInteropTypes(true); 878var varCRef = TestReferences.SymbolsTests.NoPia.C.WithEmbedInteropTypes(false); 879var varDLink = TestReferences.SymbolsTests.NoPia.D.WithEmbedInteropTypes(true); 880var varDRef = TestReferences.SymbolsTests.NoPia.D.WithEmbedInteropTypes(false); 1004var mscorlibRef = Net40.References.mscorlib; 1005var pia1CopyLink = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(true); 1006var pia1CopyRef = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(false); 1103var mscorlibRef = Net40.References.mscorlib; 1265var mscorlibRef = Net40.References.mscorlib;

1487var ref1 = MetadataReference.CreateFromImage(verifier1.EmittedAssemblyData); 1561var refA = MetadataReference.CreateFromImage(bitsA); 1568var ref0 = ModuleMetadata.CreateFromImage(bits0).GetReference(); 1572var ref1 = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(bits1), ModuleMetadata.CreateFromImage(bits0)).GetReference(); 1752var ref0 = asm0.GetReference(); 1759var ref1 = assembly1.GetReference();

895var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll;

1254var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1255var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 1256var piaRef = TestReferences.SymbolsTests.NoPia.Pia1; 1279var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1280var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 1281var piaRef = TestReferences.SymbolsTests.NoPia.Pia1; 1305var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1306var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 2018var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2044var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2143var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2169var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2268var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2294var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2406var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2476var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2502var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray());

26var oldMsCorLib = Net40.References.mscorlib; 27var newMsCorLib = NetFramework.mscorlib; 133var oldMsCorLib = Net40.References.mscorlib; 134var newMsCorLib = NetFramework.mscorlib;

70var C1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 71var C2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 987var C1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 988var C2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 1008var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1026var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1061var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1062var ClassBv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassB.netmodule; 1082var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1122var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1151var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1177var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1178var ClassBv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassB.netmodule; 1208var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll;

47var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 90var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 141var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 190var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 252var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 317var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 353var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 407var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 516var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 585var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 688var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 721var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 762var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll;

216var goo1 = outputMetadata.GetReference(); 217var goo1Alias = outputMetadata.GetReference(aliases: ImmutableArray.Create("Baz")); 231var goo2 = MetadataReference.CreateFromImage(comp.EmitToArray());

2611var mdRef = refData.GetReference(embedInteropTypes: false);

190var ref2 = TestReferences.SymbolsTests.InheritIComparable; 206var ref2 = TestReferences.SymbolsTests.InheritIComparable; 234var ref2 = TestReferences.SymbolsTests.InheritIComparable; 271var C = MetadataReference.CreateFromImage(comp1.EmitToArray()); 277var B = MetadataReference.CreateFromImage(comp2.EmitToArray());

98var libRef = MetadataReference.CreateFromImage(libComp.EmitToArray(), filePath: "Metadata.dll"); 138var libRef = MetadataReference.CreateFromImage(libComp.EmitToArray(), filePath: "Metadata.dll");

142var ref2 = TestReferences.SymbolsTests.MDTestLib2; 3935var ref1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 3936var ref2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 5488var ref1 = TestReferences.SymbolsTests.V1.MTTestLib1.dll; 5491var ref2 = TestReferences.SymbolsTests.MultiModule.Assembly; 5549var ref1 = TestReferences.DiagnosticTests.ErrTestLib11.dll; 5550var ref2 = TestReferences.DiagnosticTests.ErrTestLib02.dll; 7134var moduleRef = ModuleMetadata.CreateFromImage(ilBytes).GetReference(); 7203var moduleRef1 = ModuleMetadata.CreateFromImage(ilBytes).GetReference(); 15095var ref1 = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule1).GetReference(display: "NetModule.mod"); 15238var ref1 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.CorLibrary.NoMsCorLibRef).GetReference(display: "NoMsCorLibRef.mod"); 16232var ref1 = TestReferences.SymbolsTests.NoPia.Microsoft.VisualStudio.MissingPIAAttributes.WithEmbedInteropTypes(true); 17699var ref1 = TestReferences.SymbolsTests.Fields.CSFields.dll; 17736var ref1 = TestReferences.SymbolsTests.V1.MTTestLib1.dll; 17976var cs00 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 17977var cs01 = TestReferences.MetadataTests.NetModule01.ModuleCS01; 17978var vb01 = TestReferences.MetadataTests.NetModule01.ModuleVB01; 17979var ref1 = TestReferences.MetadataTests.NetModule01.AppCS;

894var module1Ref = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule1).GetReference(display: "netModule1.netmodule"); 1437var r = MetadataReference.CreateFromImage(TestResources.SymbolsTests.Methods.CSMethods.AsImmutableOrNull());

31public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties)

625var serializationRef = Net461.References.SystemRuntimeSerialization;

476var winmd = MetadataReference.CreateFromImage(TestResources.WinRt.WinMDPrefixing.AsImmutableOrNull());

2657var reference = compilation.EmitToPortableExecutableReference();

24var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 25var reference2 = reference1.WithAliases(["Alias"]); 45var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 46var reference2 = reference1.WithAliases(["Alias"]); 68var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 69var reference2 = reference1.WithAliases(["Alias"]); 90var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 91var reference2 = reference1.WithAliases(["Alias"]);

118if (reference is PortableExecutableReference portableExecutable)

29public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 43return (PortableExecutableReference?)result.Reference; 46public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties)

132var reference = MakeAssemblyReference(metadata, modulesByName); 184var reference = MakeAssemblyReference(metadata, modulesByName); 327private static PortableExecutableReference MakeAssemblyReference(ModuleMetadata metadata, Dictionary<string, ModuleMetadata?>? modulesByName) 407private static PortableExecutableReference MakeCompileTimeWinMdAssemblyMetadata(ArrayBuilder<ModuleMetadata> runtimeModules)

412var refA = AssemblyMetadata.CreateFromImage(imageA).GetReference(); 1203var refA = AssemblyMetadata.CreateFromImage(bytesA).GetReference(); 1544var refA = AssemblyMetadata.CreateFromImage(bytesA).GetReference();

36public static PortableExecutableReference GetMetadataReference(SolutionServices services, string resolvedPath, MetadataReferenceProperties properties)

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)

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.

98var reference = service.GetReference(resolvedPath, MetadataReferenceProperties.Assembly);

30var reference = projectWithReference.MetadataReferences 31.OfType<PortableExecutableReference>()

25PortableExecutableReference reference) : SymbolReference(provider, symbolResult) 28private readonly PortableExecutableReference _reference = reference;

19PortableExecutableReference metadataReference, 24private readonly PortableExecutableReference _metadataReference = metadataReference;

101internal Task<ImmutableArray<SymbolReference>> FindInMetadataSymbolsAsync(IAssemblySymbol assembly, Project assemblyProject, PortableExecutableReference metadataReference, bool exact, CancellationToken cancellationToken)

71private static MetadataId? GetMetadataId(PortableExecutableReference reference) 122foreach (var peReference in currentProject.MetadataReferences.OfType<PortableExecutableReference>()) 199PortableExecutableReference peReference,

77foreach (var peReference in GetAllRelevantPeReferences(project)) 132private static ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences(Project project) 133=> [.. project.MetadataReferences.OfType<PortableExecutableReference>()]; 181PortableExecutableReference peReference,

68if (reference is PortableExecutableReference peReference) 83PortableExecutableReference peReference, 106PortableExecutableReference peReference,

229var assemblyLocation = (metadataReference as PortableExecutableReference)?.FilePath; 380var peMetadataReference = compilation.GetMetadataReference(topLevelNamedType.ContainingAssembly) as PortableExecutableReference;

101if (compilation.GetMetadataReference(symbol.ContainingAssembly) is not PortableExecutableReference { FilePath: not null and var dllPath }) 137var dllReference = IOUtilities.PerformIO(() => MetadataReference.CreateFromFile(dllPath, documentation: documentationProvider.GetDocumentationProvider(dllPath)));

49.OfType<PortableExecutableReference>()

550var metadataReferences = new List<PortableExecutableReference>();

12/// Specialize <see cref="PortableExecutableReference"/> with path being the original path of the copy. 36protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

35public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties) 39return (PortableExecutableReference)_metadataCache.GetReference(resolvedPath, properties); 66protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

591var mscorlib = NetCoreApp.mscorlib; 621var mscorlib = NetCoreApp.mscorlib.WithAliases(new[] { "alias1", "alias2" }); 655var mscorlib = NetCoreApp.mscorlib.WithEmbedInteropTypes(embedInteropTypes); 685var reference = TestReferences.SymbolsTests.MultiModule.Assembly;

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)

144var path = (referencedAssembly.Key as PortableExecutableReference)?.FilePath;

67public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 70public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties)

25public override PortableExecutableReference ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 47public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 56return default(ImmutableArray<PortableExecutableReference>);

38var moduleRef = ModuleMetadata.CreateFromImage(TestResources.MetadataTests.NetModule01.ModuleCS00).GetReference(); 71var assemblyRef = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.Methods.CSMethods).GetReference(); 80var moduleRef = ModuleMetadata.CreateFromImage(TestResources.MetadataTests.NetModule01.ModuleCS00).GetReference();

194var delta1Reference = MetadataReference.CreateFromFile(Delta1); 225var delta2Reference = MetadataReference.CreateFromFile(Delta2); 247var gammaReference = MetadataReference.CreateFromFile(Gamma); 342var compilerReference = MetadataReference.CreateFromFile(typeof(Microsoft.CodeAnalysis.SyntaxNode).Assembly.Location); 361var userSystemCollectionsImmutableReference = MetadataReference.CreateFromFile(UserSystemCollectionsImmutable); 416var realSciReference = MetadataReference.CreateFromFile(typeof(ImmutableArray).Assembly.Location); 478var fakeCompilerReference = MetadataReference.CreateFromFile(fakeCompilerAssembly); 506var laterCompilerReference = MetadataReference.CreateFromFile(laterFakeCompilerAssembly);

165var reference = emittedMetadata.Kind == MetadataImageKind.Assembly

123public static PortableExecutableReference EmitToPortableExecutableReference( 467public static PortableExecutableReference CreateWindowsRuntimeMetadataReference(TargetFramework targetFramework = TargetFramework.NetCoreApp)

24=> reference is PortableExecutableReference peReference 28public static ModuleMetadata GetManifestModuleMetadata(this PortableExecutableReference peReference)

896var peRef = (PortableExecutableReference)metadataReference;

25public static PortableExecutableReference Build(IEnumerable<MetadataReference> references)

49protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 90protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

18private readonly Dictionary<string, PortableExecutableReference> _assemblyNames; 19private readonly Dictionary<string, PortableExecutableReference> _files; 23Dictionary<string, PortableExecutableReference> assemblyNames = null, 24Dictionary<string, PortableExecutableReference> files = null) 27_assemblyNames = assemblyNames ?? new Dictionary<string, PortableExecutableReference>(); 28_files = files ?? new Dictionary<string, PortableExecutableReference>(); 31public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 33Dictionary<string, PortableExecutableReference> map; 42return ImmutableArray<PortableExecutableReference>.Empty; 53return map.TryGetValue(reference, out var result) ? ImmutableArray.Create(result) : ImmutableArray<PortableExecutableReference>.Empty;

42public override PortableExecutableReference ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 47return _map.TryGetValue(nameAndVersion, out var reference) ? (PortableExecutableReference)reference : null; 53public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) => default(ImmutableArray<PortableExecutableReference>);

21private static readonly Lazy<PortableExecutableReference> s_appCS = new Lazy<PortableExecutableReference>( 24public static PortableExecutableReference AppCS => s_appCS.Value; 26private static readonly Lazy<PortableExecutableReference> s_moduleCS00 = new Lazy<PortableExecutableReference>( 29public static PortableExecutableReference ModuleCS00 => s_moduleCS00.Value; 31private static readonly Lazy<PortableExecutableReference> s_moduleCS01 = new Lazy<PortableExecutableReference>( 34public static PortableExecutableReference ModuleCS01 => s_moduleCS01.Value; 36private static readonly Lazy<PortableExecutableReference> s_moduleVB01 = new Lazy<PortableExecutableReference>( 39public static PortableExecutableReference ModuleVB01 => s_moduleVB01.Value; 44private static readonly Lazy<PortableExecutableReference> s_CSClasses01 = new Lazy<PortableExecutableReference>( 47public static PortableExecutableReference CSClasses01 => s_CSClasses01.Value; 49private static readonly Lazy<PortableExecutableReference> s_CSInterfaces01 = new Lazy<PortableExecutableReference>( 52public static PortableExecutableReference CSInterfaces01 => s_CSInterfaces01.Value; 54private static readonly Lazy<PortableExecutableReference> s_VBClasses01 = new Lazy<PortableExecutableReference>( 57public static PortableExecutableReference VBClasses01 => s_VBClasses01.Value; 59private static readonly Lazy<PortableExecutableReference> s_VBClasses02 = new Lazy<PortableExecutableReference>( 62public static PortableExecutableReference VBClasses02 => s_VBClasses02.Value; 64private static readonly Lazy<PortableExecutableReference> s_VBInterfaces01 = new Lazy<PortableExecutableReference>( 67public static PortableExecutableReference VBInterfaces01 => s_VBInterfaces01.Value; 75private static readonly Lazy<PortableExecutableReference> s_mincorlib = new Lazy<PortableExecutableReference>( 78public static PortableExecutableReference mincorlib => s_mincorlib.Value; 80private static readonly Lazy<PortableExecutableReference> s_minasync = new Lazy<PortableExecutableReference>( 83public static PortableExecutableReference minasync => s_minasync.Value; 85private static readonly Lazy<PortableExecutableReference> s_minasynccorlib = new Lazy<PortableExecutableReference>( 88public static PortableExecutableReference minasynccorlib => s_minasynccorlib.Value; 93private static readonly Lazy<PortableExecutableReference> s_tuplelib = new Lazy<PortableExecutableReference>( 96public static PortableExecutableReference tuplelib => s_tuplelib.Value; 101private static readonly Lazy<PortableExecutableReference> s_system = new Lazy<PortableExecutableReference>( 104public static PortableExecutableReference System => s_system.Value; 112private static readonly Lazy<PortableExecutableReference> s_errTestLib01 = new Lazy<PortableExecutableReference>( 115public static PortableExecutableReference dll => s_errTestLib01.Value; 120private static readonly Lazy<PortableExecutableReference> s_errTestLib02 = new Lazy<PortableExecutableReference>( 123public static PortableExecutableReference dll => s_errTestLib02.Value; 128private static readonly Lazy<PortableExecutableReference> s_errTestLib11 = new Lazy<PortableExecutableReference>( 131public static PortableExecutableReference dll => s_errTestLib11.Value; 136private static readonly Lazy<PortableExecutableReference> s_errTestMod01 = new Lazy<PortableExecutableReference>( 139public static PortableExecutableReference dll => s_errTestMod01.Value; 144private static readonly Lazy<PortableExecutableReference> s_errTestMod02 = new Lazy<PortableExecutableReference>( 147public static PortableExecutableReference dll => s_errTestMod02.Value; 152private static readonly Lazy<PortableExecutableReference> s_badresfile = new Lazy<PortableExecutableReference>( 155public static PortableExecutableReference res => s_badresfile.Value; 161private static readonly Lazy<PortableExecutableReference> s_mdTestLib1 = new Lazy<PortableExecutableReference>( 164public static PortableExecutableReference MDTestLib1 => s_mdTestLib1.Value; 166private static readonly Lazy<PortableExecutableReference> s_mdTestLib2 = new Lazy<PortableExecutableReference>( 169public static PortableExecutableReference MDTestLib2 => s_mdTestLib2.Value; 171private static readonly Lazy<PortableExecutableReference> s_VBConversions = new Lazy<PortableExecutableReference>( 174public static PortableExecutableReference VBConversions => s_VBConversions.Value; 176private static readonly Lazy<PortableExecutableReference> s_withSpaces = new Lazy<PortableExecutableReference>( 179public static PortableExecutableReference WithSpaces => s_withSpaces.Value; 181private static readonly Lazy<PortableExecutableReference> s_withSpacesModule = new Lazy<PortableExecutableReference>( 184public static PortableExecutableReference WithSpacesModule => s_withSpacesModule.Value; 186private static readonly Lazy<PortableExecutableReference> s_inheritIComparable = new Lazy<PortableExecutableReference>( 189public static PortableExecutableReference InheritIComparable => s_inheritIComparable.Value; 191private static readonly Lazy<PortableExecutableReference> s_bigVisitor = new Lazy<PortableExecutableReference>( 194public static PortableExecutableReference BigVisitor => s_bigVisitor.Value; 196private static readonly Lazy<PortableExecutableReference> s_properties = new Lazy<PortableExecutableReference>( 199public static PortableExecutableReference Properties => s_properties.Value; 201private static readonly Lazy<PortableExecutableReference> s_propertiesWithByRef = new Lazy<PortableExecutableReference>( 204public static PortableExecutableReference PropertiesWithByRef => s_propertiesWithByRef.Value; 206private static readonly Lazy<PortableExecutableReference> s_indexers = new Lazy<PortableExecutableReference>( 209public static PortableExecutableReference Indexers => s_indexers.Value; 211private static readonly Lazy<PortableExecutableReference> s_events = new Lazy<PortableExecutableReference>( 214public static PortableExecutableReference Events => s_events.Value; 218private static readonly Lazy<PortableExecutableReference> s_netModule1 = new Lazy<PortableExecutableReference>( 221public static PortableExecutableReference netModule1 => s_netModule1.Value; 223private static readonly Lazy<PortableExecutableReference> s_netModule2 = new Lazy<PortableExecutableReference>( 226public static PortableExecutableReference netModule2 => s_netModule2.Value; 228private static readonly Lazy<PortableExecutableReference> s_crossRefModule1 = new Lazy<PortableExecutableReference>( 231public static PortableExecutableReference CrossRefModule1 => s_crossRefModule1.Value; 233private static readonly Lazy<PortableExecutableReference> s_crossRefModule2 = new Lazy<PortableExecutableReference>( 236public static PortableExecutableReference CrossRefModule2 => s_crossRefModule2.Value; 238private static readonly Lazy<PortableExecutableReference> s_crossRefLib = new Lazy<PortableExecutableReference>( 244public static PortableExecutableReference CrossRefLib => s_crossRefLib.Value; 246private static readonly Lazy<PortableExecutableReference> s_hash_module = new Lazy<PortableExecutableReference>( 249public static PortableExecutableReference hash_module => s_hash_module.Value; 251private static readonly Lazy<PortableExecutableReference> s_x64COFF = new Lazy<PortableExecutableReference>( 254public static PortableExecutableReference x64COFF => s_x64COFF.Value; 261private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 264public static PortableExecutableReference dll => s_v1MTTestLib1.Value; 269private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 272public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 277private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib2 = new Lazy<PortableExecutableReference>( 280public static PortableExecutableReference dll => s_v1MTTestLib2.Value; 285private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 288public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 296private static readonly Lazy<PortableExecutableReference> s_v2MTTestLib1 = new Lazy<PortableExecutableReference>( 299public static PortableExecutableReference dll => s_v2MTTestLib1.Value; 304private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 307public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 312private static readonly Lazy<PortableExecutableReference> s_v2MTTestLib3 = new Lazy<PortableExecutableReference>( 315public static PortableExecutableReference dll => s_v2MTTestLib3.Value; 320private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 323public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 331private static readonly Lazy<PortableExecutableReference> s_v3MTTestLib1 = new Lazy<PortableExecutableReference>( 334public static PortableExecutableReference dll => s_v3MTTestLib1.Value; 339private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 342public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 347private static readonly Lazy<PortableExecutableReference> s_v3MTTestLib4 = new Lazy<PortableExecutableReference>( 350public static PortableExecutableReference dll => s_v3MTTestLib4.Value; 355private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 358public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 364private static readonly Lazy<PortableExecutableReference> s_assembly = new Lazy<PortableExecutableReference>( 370public static PortableExecutableReference Assembly => s_assembly.Value; 372private static readonly Lazy<PortableExecutableReference> s_mod2 = new Lazy<PortableExecutableReference>( 375public static PortableExecutableReference mod2 => s_mod2.Value; 377private static readonly Lazy<PortableExecutableReference> s_mod3 = new Lazy<PortableExecutableReference>( 380public static PortableExecutableReference mod3 => s_mod3.Value; 382private static readonly Lazy<PortableExecutableReference> s_consumer = new Lazy<PortableExecutableReference>( 385public static PortableExecutableReference Consumer => s_consumer.Value; 390private static readonly Lazy<PortableExecutableReference> s_typeAndNamespaceDifferByCase = new Lazy<PortableExecutableReference>( 393public static PortableExecutableReference TypeAndNamespaceDifferByCase => s_typeAndNamespaceDifferByCase.Value; 395private static readonly Lazy<PortableExecutableReference> s_differByCaseConsumer = new Lazy<PortableExecutableReference>( 398public static PortableExecutableReference Consumer => s_differByCaseConsumer.Value; 400private static readonly Lazy<PortableExecutableReference> s_csharpCaseSen = new Lazy<PortableExecutableReference>( 403public static PortableExecutableReference CsharpCaseSen => s_csharpCaseSen.Value; 405private static readonly Lazy<PortableExecutableReference> s_csharpDifferCaseOverloads = new Lazy<PortableExecutableReference>( 408public static PortableExecutableReference CsharpDifferCaseOverloads => s_csharpDifferCaseOverloads.Value; 415private static readonly Lazy<PortableExecutableReference> s_exe = new Lazy<PortableExecutableReference>( 418public static PortableExecutableReference exe => s_exe.Value; 421private static readonly Lazy<PortableExecutableReference> s_noMsCorLibRef = new Lazy<PortableExecutableReference>( 424public static PortableExecutableReference NoMsCorLibRef => s_noMsCorLibRef.Value; 428private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 431public static PortableExecutableReference dll => s_dll.Value; 439private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 442public static PortableExecutableReference dll => s_dll.Value; 444private static readonly Lazy<PortableExecutableReference> s_module = new Lazy<PortableExecutableReference>( 447public static PortableExecutableReference netmodule => s_module.Value; 450private static readonly Lazy<PortableExecutableReference> s_modoptTests = new Lazy<PortableExecutableReference>( 453public static PortableExecutableReference ModoptTests => s_modoptTests.Value; 457private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 460public static PortableExecutableReference dll => s_dll.Value; 465private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 468public static PortableExecutableReference dll => s_dll.Value; 476private static readonly Lazy<PortableExecutableReference> s_cyclic1 = new Lazy<PortableExecutableReference>( 479public static PortableExecutableReference dll => s_cyclic1.Value; 484private static readonly Lazy<PortableExecutableReference> s_cyclic2 = new Lazy<PortableExecutableReference>( 487public static PortableExecutableReference dll => s_cyclic2.Value; 493private static readonly Lazy<PortableExecutableReference> s_class1 = new Lazy<PortableExecutableReference>( 496public static PortableExecutableReference Class1 => s_class1.Value; 498private static readonly Lazy<PortableExecutableReference> s_class2 = new Lazy<PortableExecutableReference>( 501public static PortableExecutableReference Class2 => s_class2.Value; 503private static readonly Lazy<PortableExecutableReference> s_class3 = new Lazy<PortableExecutableReference>( 506public static PortableExecutableReference Class3 => s_class3.Value; 509private static readonly Lazy<PortableExecutableReference> s_cycledStructs = new Lazy<PortableExecutableReference>( 512public static PortableExecutableReference CycledStructs => s_cycledStructs.Value; 520private static readonly Lazy<PortableExecutableReference> s_classA = new Lazy<PortableExecutableReference>( 523public static PortableExecutableReference dll => s_classA.Value; 528private static readonly Lazy<PortableExecutableReference> s_classB = new Lazy<PortableExecutableReference>( 531public static PortableExecutableReference netmodule => s_classB.Value; 539private static readonly Lazy<PortableExecutableReference> s_classA = new Lazy<PortableExecutableReference>( 542public static PortableExecutableReference dll => s_classA.Value; 547private static readonly Lazy<PortableExecutableReference> s_classB = new Lazy<PortableExecutableReference>( 550public static PortableExecutableReference dll => s_classB.Value; 557private static readonly Lazy<PortableExecutableReference> s_CSMethods = new Lazy<PortableExecutableReference>( 560public static PortableExecutableReference CSMethods => s_CSMethods.Value; 562private static readonly Lazy<PortableExecutableReference> s_VBMethods = new Lazy<PortableExecutableReference>( 565public static PortableExecutableReference VBMethods => s_VBMethods.Value; 567private static readonly Lazy<PortableExecutableReference> s_ILMethods = new Lazy<PortableExecutableReference>( 570public static PortableExecutableReference ILMethods => s_ILMethods.Value; 572private static readonly Lazy<PortableExecutableReference> s_byRefReturn = new Lazy<PortableExecutableReference>( 575public static PortableExecutableReference ByRefReturn => s_byRefReturn.Value; 582private static readonly Lazy<PortableExecutableReference> s_CSFields = new Lazy<PortableExecutableReference>( 585public static PortableExecutableReference dll => s_CSFields.Value; 590private static readonly Lazy<PortableExecutableReference> s_VBFields = new Lazy<PortableExecutableReference>( 593public static PortableExecutableReference dll => s_VBFields.Value; 596private static readonly Lazy<PortableExecutableReference> s_constantFields = new Lazy<PortableExecutableReference>( 599public static PortableExecutableReference ConstantFields => s_constantFields.Value; 604private static readonly Lazy<PortableExecutableReference> s_MDMissingType = new Lazy<PortableExecutableReference>( 607public static PortableExecutableReference MDMissingType => s_MDMissingType.Value; 609private static readonly Lazy<PortableExecutableReference> s_MDMissingTypeLib = new Lazy<PortableExecutableReference>( 612public static PortableExecutableReference MDMissingTypeLib => s_MDMissingTypeLib.Value; 614private static readonly Lazy<PortableExecutableReference> s_missingTypesEquality1 = new Lazy<PortableExecutableReference>( 617public static PortableExecutableReference MissingTypesEquality1 => s_missingTypesEquality1.Value; 619private static readonly Lazy<PortableExecutableReference> s_missingTypesEquality2 = new Lazy<PortableExecutableReference>( 622public static PortableExecutableReference MissingTypesEquality2 => s_missingTypesEquality2.Value; 624private static readonly Lazy<PortableExecutableReference> s_CL2 = new Lazy<PortableExecutableReference>( 627public static PortableExecutableReference CL2 => s_CL2.Value; 629private static readonly Lazy<PortableExecutableReference> s_CL3 = new Lazy<PortableExecutableReference>( 632public static PortableExecutableReference CL3 => s_CL3.Value; 639private static readonly Lazy<PortableExecutableReference> s_typeForwarder2 = new Lazy<PortableExecutableReference>( 642public static PortableExecutableReference dll => s_typeForwarder2.Value; 647private static readonly Lazy<PortableExecutableReference> s_typeForwarderLib2 = new Lazy<PortableExecutableReference>( 650public static PortableExecutableReference dll => s_typeForwarderLib2.Value; 655private static readonly Lazy<PortableExecutableReference> s_typeForwarderBase2 = new Lazy<PortableExecutableReference>( 658public static PortableExecutableReference dll => s_typeForwarderBase2.Value; 664private static readonly Lazy<PortableExecutableReference> s_source1Module = new Lazy<PortableExecutableReference>( 667public static PortableExecutableReference Source1Module => s_source1Module.Value; 669private static readonly Lazy<PortableExecutableReference> s_source3Module = new Lazy<PortableExecutableReference>( 672public static PortableExecutableReference Source3Module => s_source3Module.Value; 674private static readonly Lazy<PortableExecutableReference> s_source4Module = new Lazy<PortableExecutableReference>( 677public static PortableExecutableReference Source4Module => s_source4Module.Value; 679private static readonly Lazy<PortableExecutableReference> s_source5Module = new Lazy<PortableExecutableReference>( 682public static PortableExecutableReference Source5Module => s_source5Module.Value; 684private static readonly Lazy<PortableExecutableReference> s_source7Module = new Lazy<PortableExecutableReference>( 687public static PortableExecutableReference Source7Module => s_source7Module.Value; 692private static readonly Lazy<PortableExecutableReference> s_stdOleNetFramework = new Lazy<PortableExecutableReference>( 694public static PortableExecutableReference StdOleNetFramework => s_stdOleNetFramework.Value; 696private static readonly Lazy<PortableExecutableReference> s_stdOleNet40 = new Lazy<PortableExecutableReference>( 698public static PortableExecutableReference StdOleNet40 => s_stdOleNet40.Value; 700private static readonly Lazy<PortableExecutableReference> s_pia1 = new Lazy<PortableExecutableReference>( 703public static PortableExecutableReference Pia1 => s_pia1.Value; 705private static readonly Lazy<PortableExecutableReference> s_pia1Copy = new Lazy<PortableExecutableReference>( 708public static PortableExecutableReference Pia1Copy => s_pia1Copy.Value; 710private static readonly Lazy<PortableExecutableReference> s_pia2 = new Lazy<PortableExecutableReference>( 713public static PortableExecutableReference Pia2 => s_pia2.Value; 715private static readonly Lazy<PortableExecutableReference> s_pia3 = new Lazy<PortableExecutableReference>( 718public static PortableExecutableReference Pia3 => s_pia3.Value; 720private static readonly Lazy<PortableExecutableReference> s_pia4 = new Lazy<PortableExecutableReference>( 723public static PortableExecutableReference Pia4 => s_pia4.Value; 725private static readonly Lazy<PortableExecutableReference> s_pia5 = new Lazy<PortableExecutableReference>( 728public static PortableExecutableReference Pia5 => s_pia5.Value; 730private static readonly Lazy<PortableExecutableReference> s_generalPia = new Lazy<PortableExecutableReference>( 733public static PortableExecutableReference GeneralPia => s_generalPia.Value; 735private static readonly Lazy<PortableExecutableReference> s_generalPiaCopy = new Lazy<PortableExecutableReference>( 738public static PortableExecutableReference GeneralPiaCopy => s_generalPiaCopy.Value; 740private static readonly Lazy<PortableExecutableReference> s_noPIAGenericsAsm1 = new Lazy<PortableExecutableReference>( 743public static PortableExecutableReference NoPIAGenericsAsm1 => s_noPIAGenericsAsm1.Value; 745private static readonly Lazy<PortableExecutableReference> s_externalAsm1 = new Lazy<PortableExecutableReference>( 748public static PortableExecutableReference ExternalAsm1 => s_externalAsm1.Value; 750private static readonly Lazy<PortableExecutableReference> s_library1 = new Lazy<PortableExecutableReference>( 753public static PortableExecutableReference Library1 => s_library1.Value; 755private static readonly Lazy<PortableExecutableReference> s_library2 = new Lazy<PortableExecutableReference>( 758public static PortableExecutableReference Library2 => s_library2.Value; 760private static readonly Lazy<PortableExecutableReference> s_localTypes1 = new Lazy<PortableExecutableReference>( 763public static PortableExecutableReference LocalTypes1 => s_localTypes1.Value; 765private static readonly Lazy<PortableExecutableReference> s_localTypes2 = new Lazy<PortableExecutableReference>( 768public static PortableExecutableReference LocalTypes2 => s_localTypes2.Value; 770private static readonly Lazy<PortableExecutableReference> s_localTypes3 = new Lazy<PortableExecutableReference>( 773public static PortableExecutableReference LocalTypes3 => s_localTypes3.Value; 775private static readonly Lazy<PortableExecutableReference> s_A = new Lazy<PortableExecutableReference>( 778public static PortableExecutableReference A => s_A.Value; 780private static readonly Lazy<PortableExecutableReference> s_B = new Lazy<PortableExecutableReference>( 783public static PortableExecutableReference B => s_B.Value; 785private static readonly Lazy<PortableExecutableReference> s_C = new Lazy<PortableExecutableReference>( 788public static PortableExecutableReference C => s_C.Value; 790private static readonly Lazy<PortableExecutableReference> s_D = new Lazy<PortableExecutableReference>( 793public static PortableExecutableReference D => s_D.Value; 799private static readonly Lazy<PortableExecutableReference> s_missingPIAAttributes = new Lazy<PortableExecutableReference>( 802public static PortableExecutableReference MissingPIAAttributes => s_missingPIAAttributes.Value; 809private static readonly Lazy<PortableExecutableReference> s_staticMethodInInterface = new Lazy<PortableExecutableReference>( 812public static PortableExecutableReference StaticMethodInInterface => s_staticMethodInInterface.Value; 814private static readonly Lazy<PortableExecutableReference> s_MDInterfaceMapping = new Lazy<PortableExecutableReference>( 817public static PortableExecutableReference MDInterfaceMapping => s_MDInterfaceMapping.Value; 822private static readonly Lazy<PortableExecutableReference> s_MDTestLib1 = new Lazy<PortableExecutableReference>( 825public static PortableExecutableReference MDTestLib1 => s_MDTestLib1.Value; 827private static readonly Lazy<PortableExecutableReference> s_netModule1 = new Lazy<PortableExecutableReference>( 830public static PortableExecutableReference netModule1 => s_netModule1.Value; 837private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 840public static PortableExecutableReference CSharp => s_CSharp.Value; 842private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 845public static PortableExecutableReference IL => s_IL.Value; 850private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 853public static PortableExecutableReference CSharp => s_CSharp.Value; 855private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 858public static PortableExecutableReference IL => s_IL.Value; 863private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 866public static PortableExecutableReference CSharp => s_CSharp.Value; 870private static readonly Lazy<PortableExecutableReference> s_regress40025 = new Lazy<PortableExecutableReference>( 873public static PortableExecutableReference Regress40025 => s_regress40025.Value; 877private static readonly Lazy<PortableExecutableReference> s_simpleWithEvents = new Lazy<PortableExecutableReference>( 880public static PortableExecutableReference SimpleWithEvents => s_simpleWithEvents.Value; 885private static readonly Lazy<PortableExecutableReference> s_delegatesWithoutInvoke = new Lazy<PortableExecutableReference>( 888public static PortableExecutableReference DelegatesWithoutInvoke => s_delegatesWithoutInvoke.Value; 890private static readonly Lazy<PortableExecutableReference> s_delegateByRefParamArray = new Lazy<PortableExecutableReference>( 893public static PortableExecutableReference DelegateByRefParamArray => s_delegateByRefParamArray.Value; 898private static readonly Lazy<PortableExecutableReference> s_invalidCharactersInAssemblyName2 = new Lazy<PortableExecutableReference>( 901public static PortableExecutableReference InvalidCharactersInAssemblyName => s_invalidCharactersInAssemblyName2.Value; 903private static readonly Lazy<PortableExecutableReference> s_MDTestAttributeDefLib = new Lazy<PortableExecutableReference>( 906public static PortableExecutableReference MDTestAttributeDefLib => s_MDTestAttributeDefLib.Value; 908private static readonly Lazy<PortableExecutableReference> s_MDTestAttributeApplicationLib = new Lazy<PortableExecutableReference>( 911public static PortableExecutableReference MDTestAttributeApplicationLib => s_MDTestAttributeApplicationLib.Value; 913private static readonly Lazy<PortableExecutableReference> s_attributeInterop01 = new Lazy<PortableExecutableReference>( 916public static PortableExecutableReference AttributeInterop01 => s_attributeInterop01.Value; 918private static readonly Lazy<PortableExecutableReference> s_attributeInterop02 = new Lazy<PortableExecutableReference>( 921public static PortableExecutableReference AttributeInterop02 => s_attributeInterop02.Value; 923private static readonly Lazy<PortableExecutableReference> s_attributeTestLib01 = new Lazy<PortableExecutableReference>( 926public static PortableExecutableReference AttributeTestLib01 => s_attributeTestLib01.Value; 928private static readonly Lazy<PortableExecutableReference> s_attributeTestDef01 = new Lazy<PortableExecutableReference>( 931public static PortableExecutableReference AttributeTestDef01 => s_attributeTestDef01.Value; 933private static readonly Lazy<PortableExecutableReference> s_dynamicAttributeLib = new Lazy<PortableExecutableReference>( 936public static PortableExecutableReference DynamicAttributeLib => s_dynamicAttributeLib.Value; 941private static readonly Lazy<PortableExecutableReference> s_unavailable = new Lazy<PortableExecutableReference>( 944public static PortableExecutableReference Unavailable => s_unavailable.Value; 946private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 949public static PortableExecutableReference CSharp => s_CSharp.Value; 951private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 954public static PortableExecutableReference IL => s_IL.Value; 959private static readonly Lazy<PortableExecutableReference> s_AR_SA = new Lazy<PortableExecutableReference>( 962public static PortableExecutableReference AR_SA => s_AR_SA.Value; 964private static readonly Lazy<PortableExecutableReference> s_EN_US = new Lazy<PortableExecutableReference>( 967public static PortableExecutableReference EN_US => s_EN_US.Value; 969private static readonly Lazy<PortableExecutableReference> s_C1 = new Lazy<PortableExecutableReference>( 972public static PortableExecutableReference C1 => s_C1.Value; 974private static readonly Lazy<PortableExecutableReference> s_C2 = new Lazy<PortableExecutableReference>( 977public static PortableExecutableReference C2 => s_C2.Value;

105public static PortableExecutableReference netstandard { get; } = Net70.References.netstandard; 106public static PortableExecutableReference mscorlib { get; } = Net70.References.mscorlib; 107public static PortableExecutableReference SystemRuntime { get; } = Net70.References.SystemRuntime; 155public static PortableExecutableReference mscorlib { get; } = Net461.References.mscorlib; 156public static PortableExecutableReference System { get; } = Net461.References.System; 157public static PortableExecutableReference SystemRuntime { get; } = Net461.References.SystemRuntime; 158public static PortableExecutableReference SystemCore { get; } = Net461.References.SystemCore; 159public static PortableExecutableReference SystemData { get; } = Net461.References.SystemData; 160public static PortableExecutableReference SystemThreadingTasks { get; } = Net461.References.SystemThreadingTasks; 161public static PortableExecutableReference SystemXml { get; } = Net461.References.SystemXml; 162public static PortableExecutableReference SystemValueTuple { get; } = Net461.ExtraReferences.SystemValueTuple; 163public static PortableExecutableReference MicrosoftCSharp { get; } = Net461.References.MicrosoftCSharp; 164public static PortableExecutableReference MicrosoftVisualBasic { get; } = Net461.References.MicrosoftVisualBasic; 169private static readonly ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>> s_dynamicReferenceMap = new ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>>(StringComparer.Ordinal); 381if (m is PortableExecutableReference p && 402.Where(x => !(x is PortableExecutableReference pe && excludeReferenceNames.Contains(pe.FilePath))); 410private static ImmutableArray<PortableExecutableReference> LoadDynamicReferences(string targetFrameworkName) 431references = ((IEnumerable<PortableExecutableReference>)obj).ToImmutableArray();

102var winmd = AssemblyMetadata.CreateFromImage(TestResources.WinRt.Windows).GetReference(display: "Windows"); 104var windowsruntime = 107var runtime = 110var objectModel = 113var uixaml = AssemblyMetadata.CreateFromImage(TestResources.NetFX.WinRt.SystemRuntimeWindowsRuntimeUIXaml). 116var interop = AssemblyMetadata.CreateFromImage(Net461.Resources.SystemRuntimeInteropServicesWindowsRuntime). 120var system = AssemblyMetadata.CreateFromImage(Net461.Resources.System).GetReference(display: "System.dll"); 122var mscor = AssemblyMetadata.CreateFromImage(Net461.Resources.mscorlib).GetReference(display: "mscorlib");

1169var compilerReference = MetadataReference.CreateFromFile(typeof(SyntaxNode).Assembly.Location); 1170var immutableReference = MetadataReference.CreateFromFile(typeof(ImmutableArray).Assembly.Location);

64var r = immutableArray 80var r = immutableArray 98var r = MetadataReference.CreateFromStream(stream); 118var r = MetadataReference.CreateFromStream(new MemoryStream(TestResources.General.C1, writable: false)); 129var r = MetadataReference.CreateFromStream( 145var r = MetadataReference.CreateFromStream( 163var r = MetadataReference.CreateFromFile(file.Path, 187var r = MetadataReference.CreateFromFile(file.Path, MetadataReferenceProperties.Module); 208var r = (PortableExecutableReference)MetadataReference.CreateFromAssemblyInternal(assembly); 225var r = (PortableExecutableReference)MetadataReference.CreateFromAssemblyInternal(assembly, new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("a", "b"), embedInteropTypes: true), documentation: doc); 257var r = module.GetReference(filePath: @"c:\temp", display: "hello", documentation: doc); 266var r1 = r.WithAliases(default(ImmutableArray<string>)); 270var r2 = r.WithEmbedInteropTypes(false); 274var r3 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Module)); 277var r4 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Assembly)); 290var r = assembly.GetReference( 305var r2 = r.WithEmbedInteropTypes(true); 309var r3 = r.WithAliases(ImmutableArray.Create("b", "c")); 317var r4 = r.WithEmbedInteropTypes(false); 325var r5 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Module)); 330var r6 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("x"), embedInteropTypes: true)); 404var mmr1 = module.GetReference(); 409var r = module.GetReference(filePath: path); 419var mmr1 = assembly.GetReference(); 424var r = assembly.GetReference(filePath: path); 487protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 515protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 529var i1 = AssemblyMetadata.CreateFromImage(Net461.Resources.mscorlib).GetReference(display: "i1"); 530var i2 = AssemblyMetadata.CreateFromImage(Net461.Resources.mscorlib).GetReference(display: "i2"); 568var corlib = AssemblyMetadata.CreateFromImage(Net461.Resources.mscorlib). 584var r = MetadataReference.CreateFromStream(new MemoryStream(TestResources.SymbolsTests.Metadata.InvalidPublicKey, writable: false));

88Dim assemblyMetadata = TryCast(DirectCast(reference, PortableExecutableReference).GetMetadataNoCopy(), AssemblyMetadata)

328ImmutableDictionary(Of AssemblyIdentity, PortableExecutableReference).Empty)

1349Dim fileRef = TryCast(pair.Key, PortableExecutableReference)

70PortableExecutableReference reference,

115foreach (var peReference in project.MetadataReferences.OfType<PortableExecutableReference>())

27/// Cache from the <see cref="MetadataId"/> for a particular <see cref="PortableExecutableReference"/> to the 331using var _ = ArrayBuilder<(PortableExecutableReference reference, MetadataId metadataId)>.GetInstance(out var uncomputedReferences); 337if (reference is not PortableExecutableReference peReference)

119using var _4 = PooledHashSet<PortableExecutableReference>.GetInstance(out var seenPEReferences); 311if (reference is not PortableExecutableReference peReference) 329seenPEReferences.AddRange(compilation.References.OfType<PortableExecutableReference>()); 336PortableExecutableReference reference,

13/// for metadata symbols in <see cref="PortableExecutableReference"/>s. 18ValueTask<SymbolTreeInfo?> TryGetPotentiallyStaleMetadataSymbolTreeInfoAsync(Project project, PortableExecutableReference reference, CancellationToken cancellationToken);

21/// cref="Project"/> or <see cref="PortableExecutableReference"/>. This tree can be used to quickly determine if

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,

31private readonly ConcurrentDictionary<PortableExecutableReference, MetadataInfo> _peReferenceToInfo = []; 70PortableExecutableReference reference, 153foreach (var reference in project.MetadataReferences.OfType<PortableExecutableReference>().Distinct()) 192PortableExecutableReference reference,

51protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 60{nameof(PortableExecutableReference)}

49if (reference is PortableExecutableReference portable) 99if (reference is PortableExecutableReference portable) 117if (type == nameof(PortableExecutableReference)) 184PortableExecutableReference reference, SerializationKinds kind, ObjectWriter writer) 186writer.WriteString(nameof(PortableExecutableReference)); 192private static void WritePortableExecutableReferencePropertiesTo(PortableExecutableReference reference, ObjectWriter writer) 198private static Checksum CreatePortableExecutableReferenceChecksum(PortableExecutableReference reference) 272PortableExecutableReference reference, ObjectWriter writer) 280private PortableExecutableReference ReadPortableExecutableReferenceFrom(ObjectReader reader) 359PortableExecutableReference reference, 492private static Metadata? TryGetMetadata(PortableExecutableReference reference) 535protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

9PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties);

30public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties) 31=> (PortableExecutableReference)_metadataCache.GetReference(resolvedPath, properties);

28public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)

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); 1416foreach (var reference in originalMetadataReferences.OfType<PortableExecutableReference>())

46public FileWatchedReferenceFactory<PortableExecutableReference> FileWatchedPortableExecutableReferenceFactory { get; } 425foreach (var reference in projectUpdateState.RemovedMetadataReferences) 429foreach (var reference in projectUpdateState.AddedMetadataReferences) 567if (reference is PortableExecutableReference peReference 662var metadataReference = CreateMetadataReference_NoLock( 818public static PortableExecutableReference CreateMetadataReference_NoLock( 827getReferences: static project => project.MetadataReferences.OfType<PortableExecutableReference>(), 865/// cref="PortableExecutableReference"/> or <see cref="AnalyzerFileReference"/>.

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)

19=> new(reference.Properties, (reference as PortableExecutableReference)?.FilePath);

32private readonly Dictionary<MetadataReferenceProperties, PortableExecutableReference> _referenceMap = []; 36public PortableExecutableReference GetOrCreateMetadataReference(MetadataReferenceProperties properties) 40if (!_referenceMap.TryGetValue(properties, out var value))

1500if (meta is PortableExecutableReference pemeta)

87PortableExecutableReference portableExecutableReference => portableExecutableReference.FilePath,

583if (metadataReference is PortableExecutableReference peRef && peRef.FilePath != null) 619if (metadataReference is PortableExecutableReference peRef && peRef.FilePath != null)

86var fileNames = new HashSet<string>(references.Select(r => Path.GetFileName(((PortableExecutableReference)r).FilePath))); 190.OfType<PortableExecutableReference>() 195.OfType<PortableExecutableReference>() 201=> ((PortableExecutableReference)metadataReference).GetMetadata(); 328var pref = c2.References.OfType<PortableExecutableReference>().FirstOrDefault(r => r.Display == "CSharpProject"); 355var pref = c2.References.OfType<PortableExecutableReference>().FirstOrDefault(r => r.Display == "EmittedCSharpProject"); 798var csharpLib = refs.OfType<PortableExecutableReference>().FirstOrDefault(r => r.FilePath.Contains("Microsoft.CSharp")); 1332Assert.Contains(metaRefs, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1351Assert.Contains(project.MetadataReferences, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1391Assert.Contains(metaRefs, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1427Assert.Contains(vbProject.MetadataReferences, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1887var mtref = MetadataReference.CreateFromImage(metadataBytes); 1910var mtref = MetadataReference.CreateFromImage(metadataBytes); 1934var mtref = MetadataReference.CreateFromImage(metadataBytes); 1957var mtref = MetadataReference.CreateFromImage(metadataBytes); 3207project.MetadataReferences.Select(r => Path.GetFileName(((PortableExecutableReference)r).FilePath)).OrderBy(StringComparer.Ordinal));

746var metadataReference = MetadataReference.CreateFromImage(image, new MetadataReferenceProperties(aliases: aliases), includeXmlDocComments ? new DeferredDocumentationProvider(compilation) : null);

179Assert.Single(info.MetadataReferences.OfType<PortableExecutableReference>(), r => r.FilePath == pathToAssembly); 191Assert.Single(info.MetadataReferences.OfType<PortableExecutableReference>(), r => r.FilePath == pathToAssembly);

129.AddMetadataReference(pid, ((PortableExecutableReference)MscorlibRef).WithAliases(["X"]))

1158var metadataReference = MetadataReference.CreateFromImage([], filePath: "meta"); 2970var mefReference = NetFramework.SystemCore;

36var portableExecutableReference = MetadataReference.CreateFromFile(roslynCompilersLocation, documentation: documentationProvider);

26metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 55metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 66metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 95metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 106metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 135metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 146metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 179metadataReferences: [PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)]); 190PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location), 191PortableExecutableReference.CreateFromFile(typeof(Workspace).Assembly.Location),

785 return x.ExternalReferences.OfType<PortableExecutableReference>().SequenceEqual(y.ExternalReferences.OfType<PortableExecutableReference>());

139if (referenceListItem.MetadataReference is PortableExecutableReference portableExecutableReference)

618if (reference is PortableExecutableReference portableExecutableReference)

845if (referenceListItem.MetadataReference is not PortableExecutableReference metadataReference) 927if (referenceListItem.MetadataReference is not PortableExecutableReference portableExecutableReference)

26if (reference is PortableExecutableReference portableExecutableReference) 154libraryName = compilation.GetMetadataReference(containingAssembly) is PortableExecutableReference portableExecutableReference

33/// They monitor changes in the underlying files and provide snapshot references (subclasses of <see cref="PortableExecutableReference"/>) 129public PortableExecutableReference CreateMetadataReferenceSnapshot(string filePath, MetadataReferenceProperties properties)

29public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties)

26/// cref="PortableExecutableReference.GetMetadataImpl()"/> and the observed metadata is memoized by the compilation. 104protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

72/// Creates a <see cref="PortableExecutableReference" /> that correctly retrieves the Visual Studio context, 77public PortableExecutableReference CreatePortableExecutableReference(string filePath, MetadataReferenceProperties properties)

35var reference = fromProject.MetadataReferences.OfType<PortableExecutableReference>()

509if (metadataReference is PortableExecutableReference fileMetadata)

34var reference = fromProject.MetadataReferences.OfType<PortableExecutableReference>()

55IEnumerable<PortableExecutableReference> GetProject3MetadataReferences() 59.Cast<PortableExecutableReference>();

44public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties)

45if (compilation.GetMetadataReference(assembly) is not PortableExecutableReference metadataReference)

282var reference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); 729protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

140var metadataRef = MetadataReference.CreateFromStream(readableStream); 367var metadataRef = MetadataReference.CreateFromStream(readableStream);

120var libRef = MetadataReference.CreateFromImage(libImage); 165var libRef = MetadataReference.CreateFromImage(libImage); 207var libRef = MetadataReference.CreateFromImage(libImage);

80var reference = MetadataReference.CreateFromFile(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5.2\mscorlib.dll");

46public static Func<string, MetadataReferenceProperties, PortableExecutableReference> SharedAssemblyReferenceProvider { get; } = (path, properties) => new CachingMetadataReference(path, properties); 51private Func<string, MetadataReferenceProperties, PortableExecutableReference> AssemblyReferenceProvider { get; } = SharedAssemblyReferenceProvider;

17private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider; 19internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache) 24internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache) 30internal override Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()

134protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

19private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider; 21internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache) 26internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache) 32internal override Func<string, MetadataReferenceProperties, PortableExecutableReference> GetMetadataProvider()