16internal sealed class MetadataImageReference : PortableExecutableReference

2170private sealed class EvolvingTestReference : PortableExecutableReference

15private sealed class ShadowCopyReference : PortableExecutableReference

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

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

2418Inherits PortableExecutableReference

596private sealed class MissingMetadataReference : PortableExecutableReference 630private sealed class SerializedMetadataReference : PortableExecutableReference, ISupportTemporaryStorage

37internal sealed class Snapshot : PortableExecutableReference, ISupportTemporaryStorage

712private class MissingMetadataReference : PortableExecutableReference

112internal sealed class CachingMetadataReference : PortableExecutableReference

2425MyBase.New(MetadataReferenceProperties.Assembly)

420internal static ImmutableArray<PortableExecutableReference> ResolveMetadataReference(CommandLineReference cmdReference, MetadataReferenceResolver metadataResolver, List<DiagnosticInfo>? diagnosticsOpt, CommonMessageProvider? messageProviderOpt) 425ImmutableArray<PortableExecutableReference> references; 432var diagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProviderOpt!, Location.None, cmdReference.Reference, cmdReference.Properties.Kind); 434return ImmutableArray<PortableExecutableReference>.Empty; 441return ImmutableArray<PortableExecutableReference>.Empty;

206internal 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;

661var peReference = reference as PortableExecutableReference;

292if (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( 251internal static PortableExecutableReference CreateFromFile( 321internal static PortableExecutableReference CreateFromAssemblyInternal(

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

383public 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)

102ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 214ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 265out PortableExecutableReference? resolvedReference)) 511ref ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?> implicitReferenceResolutions, 516[NotNullWhen(true)] out PortableExecutableReference? resolvedReference) 560PortableExecutableReference peReference,

320var peReference = (PortableExecutableReference)boundReference; 475private Metadata? GetMetadata(PortableExecutableReference peReference, CommonMessageProvider messageProvider, Location location, DiagnosticBag diagnostics) 505newDiagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProvider, location, peReference.Display ?? "", peReference.Properties.Kind); 526private bool TryGetObservedMetadata(PortableExecutableReference peReference, DiagnosticBag diagnostics, out Metadata? metadata) 545internal AssemblyMetadata? GetAssemblyMetadata(PortableExecutableReference peReference, DiagnosticBag diagnostics) 868private 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,

380ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>.Empty;

966var fileRef = pair.Key as PortableExecutableReference;

182PortableExecutableReference metadataReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;

11859var minSystemCollectionsImmutableRef = MetadataReference.CreateFromImage(minSystemCollectionsImmutableImage); 11871var minCodeAnalysisRef = MetadataReference.CreateFromImage(minCodeAnalysisImage);

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

3210var reference = MetadataReference.CreateFromImage(compilation.EmitToArray()); 3263var libRef = MetadataReference.CreateFromImage(libComp.EmitToArray());

298var funcRef = MetadataReference.CreateFromImage(TestResources.MetadataTests.Invalid.InvalidFuncDelegateName.AsImmutableOrNull()); 11561var 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;

4063var invalidAttributeReference = MetadataReference.CreateFromStream(peStream);

283var mscorlib17626 = MetadataReference.CreateFromImage(TestMetadata.ResourcesNet451.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;

15117var testReference = AssemblyMetadata.CreateFromImage(ProprietaryTestResources.Repros.BadDefaultParameterValue).GetReference();

23532var libCompRef = AssemblyMetadata.CreateFromImage(libComp.EmitToArray()).GetReference(); 23931var libCompRef = AssemblyMetadata.CreateFromImage(libComp.EmitToArray()).GetReference();

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

894var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference(); 1312var reference = ModuleMetadata.CreateFromImage(moduleComp.EmitToArray()).GetReference(); 2680var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 2740var libAssemblyReference = MetadataReference.CreateFromImage(dllImage.AsImmutableOrNull()); 4616var metadataRef = ModuleMetadata.CreateFromStream(comp.EmitToStream()).GetReference();

23var mscorlibRef = TestMetadata.Net40.mscorlib; 98var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 157var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 209var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 280var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 373var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 455var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 507var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 550var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll;

183var metadataTestLib1 = TestReferences.SymbolsTests.MDTestLib1; 184var metadataTestLib2 = TestReferences.SymbolsTests.MDTestLib2; 236var netModule1 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule1).GetReference(filePath: Path.GetFullPath("netModule1.netmodule")); 237var netModule2 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule2).GetReference(filePath: Path.GetFullPath("netModule2.netmodule"));

378var netModule1 = TestReferences.SymbolsTests.netModule.netModule1; 510var ref_mod1 = mod1.GetReference(); 559var ref_mod2 = ModuleMetadata.CreateFromImage(output_mod2.ToImmutable()).GetReference(); 616var ref_mod3 = mod3.GetReference();

4589var ref1 = MetadataReference.CreateFromStream(metadataStream1); 4598var ref2 = MetadataReference.CreateFromStream(metadataStream2);

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

107var reference = ModuleMetadata.CreateFromImage(module.EmitToArray()).GetReference(); 227var moduleRef = 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();

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

235var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 295var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 328var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream()); 373var metadataReference = MetadataReference.CreateFromStream(comp1.EmitToStream());

3886var referenceN0 = ModuleMetadata.CreateFromImage(compilationN0.EmitToArray()).GetReference(display: assemblyName + "_N0"); 3891var referenceN1 = ModuleMetadata.CreateFromImage(compilationN1.EmitToArray()).GetReference(display: assemblyName + "_N0"); 3896var referenceN2 = ModuleMetadata.CreateFromImage(compilationN2.EmitToArray()).GetReference(display: assemblyName + "_N2"); 3902var referenceD0 = AssemblyMetadata.CreateFromImage(compilationD0.EmitToArray()).GetReference(display: assemblyName + "_D0"); 3908var referenceD1 = AssemblyMetadata.CreateFromImage(compilationD1.EmitToArray()).GetReference(display: assemblyName + "_D1");

1002var referenceC = AssemblyMetadata.CreateFromImage(TestResources.ExpressionCompiler.Empty).GetReference();

218var assemblyReference = AssemblyMetadata.CreateFromImage(result.Assembly).GetReference();

89var referenceA = MetadataReference.CreateFromImage(bytesA); 250var referenceA = MetadataReference.CreateFromImage(bytesA);

2266var referenceA = MetadataReference.CreateFromImage(bytesA);

197var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 233var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 357var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 393var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 425var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 477var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 506var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 552var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 592var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 660var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 702var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 751var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 826var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 858var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 897var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 972var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 1024var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 1116var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 1158var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference(); 1201var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference();

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

87var libDRef = MetadataReference.CreateFromFile(libDFile.Path); 132var 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;

1580var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1621var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1659var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream()); 1700var ref1 = MetadataReference.CreateFromStream(comp1.EmitToStream());

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

29var mscorlibRef = AssemblyMetadata.CreateFromImage(TestMetadata.ResourcesNet451.mscorlib).GetReference(display: "mscorlib");

6831var libRef = TestReferences.SymbolsTests.BigVisitor;

4558var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 7800var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 12852var systemRef = Net451.System;

373var oldMsCorLib = TestMetadata.Net40.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; 1158var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1159var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 1172var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1173var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 1186var unavailableRef = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 1187var ilRef = TestReferences.SymbolsTests.UseSiteErrors.IL; 2270var unavailableAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.Unavailable; 2271var csharpAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.CSharp; 2272var ilAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.IL;

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

491var ref1 = Net451.mscorlib; 492var ref2 = Net451.System; 591new TestMetadataReferenceResolver(files: new Dictionary<string, PortableExecutableReference>() 966var ref1 = Net451.mscorlib; 1186var ref1 = Net451.mscorlib; 1187var ref2 = Net451.System; 1217var modRef1 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 1354var modRef1 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 1411var ref1 = Net451.mscorlib; 1412var ref2 = Net451.System; 1413var ref3 = Net451.SystemData; 1414var ref4 = Net451.SystemXml; 1452var ref1 = Net451.mscorlib; 1473var ref1 = Net451.mscorlib; 1474var ref2 = Net451.SystemXml; 1895var alias = Net451.System.WithAliases(new[] { "alias" }); 2193protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 2300var mdRef = MetadataReference.CreateFromImage(refData); 2351var metadata = Net451.mscorlib; 3102var moduleReference = MetadataReference.CreateFromStream(moduleStream, MetadataReferenceProperties.Module); 3119var moduleReference = MetadataReference.CreateFromStream(moduleStream, MetadataReferenceProperties.Module); 3138var 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(ResourcesNet451.SystemCore).GetReference(filePath: @"c:\temp\aa.dll", display: "System.Core.v4_0_30319.dll"); 742var r2 = AssemblyMetadata.CreateFromImage(ResourcesNet451.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) }

6242var reference = TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(false); 6252var reference = TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(true);

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

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

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

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

70var mdTestLib1 = TestReferences.SymbolsTests.MDTestLib1; 108var mscorlibRef = Net451.mscorlib; 109var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 127var varV1MTTestLib2Ref = TestReferences.SymbolsTests.V1.MTTestLib2.dll; 171var varV2MTTestLib3Ref = TestReferences.SymbolsTests.V2.MTTestLib3.dll; 228var varV3MTTestLib4Ref = TestReferences.SymbolsTests.V3.MTTestLib4.dll; 2613var mscorlibRef = Net451.mscorlib; 2614var systemCoreRef = Net451.SystemCore; 2615var systemRef = Net451.System; 2646public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 2665return ImmutableArray<PortableExecutableReference>.Empty; 2760public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 2858var r = TestReferences.SymbolsTests.Metadata.InvalidCharactersInAssemblyName;

23var mscorlibRef = TestMetadata.Net40.mscorlib; 224var mscorlibRef = TestMetadata.Net40.mscorlib; 296var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll;

62392private static string BuildAssemblyExternClause(PortableExecutableReference reference) 62437var 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)));

3304var reference1 = MetadataReference.CreateFromImage(compilationVerifier.EmittedAssemblyData); 3317var 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;

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

309var mscorlibRef = Net40.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());

196var 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.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.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.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.mscorlib; 1005var pia1CopyLink = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(true); 1006var pia1CopyRef = TestReferences.SymbolsTests.NoPia.Pia1Copy.WithEmbedInteropTypes(false); 1103var mscorlibRef = Net40.mscorlib; 1265var mscorlibRef = Net40.mscorlib;

1458var ref1 = MetadataReference.CreateFromImage(verifier1.EmittedAssemblyData); 1532var refA = MetadataReference.CreateFromImage(bitsA); 1539var ref0 = ModuleMetadata.CreateFromImage(bits0).GetReference(); 1543var ref1 = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(bits1), ModuleMetadata.CreateFromImage(bits0)).GetReference(); 1723var ref0 = asm0.GetReference(); 1730var ref1 = assembly1.GetReference();

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

1253var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1254var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 1255var piaRef = TestReferences.SymbolsTests.NoPia.Pia1; 1278var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1279var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 1280var piaRef = TestReferences.SymbolsTests.NoPia.Pia1; 1304var mscorlibRef = TestReferences.SymbolsTests.MDTestLib1; 1305var cyclic2Ref = TestReferences.SymbolsTests.Cyclic.Cyclic2.dll; 2017var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2043var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2142var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2168var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2267var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2293var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2405var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray()); 2475var localTypes2Image = MetadataReference.CreateFromImage(localTypes2.EmitToArray()); 2501var piaImage = MetadataReference.CreateFromImage(pia.EmitToArray());

25var oldMsCorLib = TestMetadata.Net40.mscorlib; 26var newMsCorLib = TestMetadata.Net451.mscorlib; 132var oldMsCorLib = TestMetadata.Net40.mscorlib; 133var newMsCorLib = TestMetadata.Net451.mscorlib;

69var C1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 70var C2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 986var C1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 987var C2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 1007var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1025var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1060var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1061var ClassBv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassB.netmodule; 1081var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1121var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1150var ClassAv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassA.dll; 1176var ClassAv2 = TestReferences.SymbolsTests.RetargetingCycle.V2.ClassA.dll; 1177var ClassBv1 = TestReferences.SymbolsTests.RetargetingCycle.V1.ClassB.netmodule; 1207var 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; 288var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 397var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 466var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.Modifiers.dll; 557var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 590var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll; 631var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll;

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

2610var 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");

141var ref2 = TestReferences.SymbolsTests.MDTestLib2; 3874var ref1 = TestReferences.SymbolsTests.CyclicInheritance.Class1; 3875var ref2 = TestReferences.SymbolsTests.CyclicInheritance.Class2; 5412var ref1 = TestReferences.SymbolsTests.V1.MTTestLib1.dll; 5415var ref2 = TestReferences.SymbolsTests.MultiModule.Assembly; 5473var ref1 = TestReferences.DiagnosticTests.ErrTestLib11.dll; 5474var ref2 = TestReferences.DiagnosticTests.ErrTestLib02.dll; 7058var moduleRef = ModuleMetadata.CreateFromImage(ilBytes).GetReference(); 7127var moduleRef1 = ModuleMetadata.CreateFromImage(ilBytes).GetReference(); 14936var ref1 = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.netModule.netModule1).GetReference(display: "NetModule.mod"); 15079var ref1 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.CorLibrary.NoMsCorLibRef).GetReference(display: "NoMsCorLibRef.mod"); 16076var ref1 = TestReferences.SymbolsTests.NoPia.Microsoft.VisualStudio.MissingPIAAttributes.WithEmbedInteropTypes(true); 17543var ref1 = TestReferences.SymbolsTests.Fields.CSFields.dll; 17580var ref1 = TestReferences.SymbolsTests.V1.MTTestLib1.dll; 17820var cs00 = TestReferences.MetadataTests.NetModule01.ModuleCS00; 17821var cs01 = TestReferences.MetadataTests.NetModule01.ModuleCS01; 17822var vb01 = TestReferences.MetadataTests.NetModule01.ModuleVB01; 17823var ref1 = TestReferences.MetadataTests.NetModule01.AppCS;

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

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

624var serializationRef = TestMetadata.Net451.SystemRuntimeSerialization;

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

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

28var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 29var reference2 = reference1.WithAliases(new[] { "Alias" }); 49var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 50var reference2 = reference1.WithAliases(new[] { "Alias" }); 72var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 73var reference2 = reference1.WithAliases(new[] { "Alias" }); 94var reference1 = (PortableExecutableReference)project.MetadataReferences.First(); 95var reference2 = reference1.WithAliases(new[] { "Alias" });

108if (reference is PortableExecutableReference portableExecutable)

31public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 45return (PortableExecutableReference?)result.Reference; 48public 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)

467var assemblyMetadata = ((PortableExecutableReference)reference).GetMetadataNoCopy() as AssemblyMetadata; 479return ModuleInstance.Create((PortableExecutableReference)reference);

67public static ModuleInstance Create(PortableExecutableReference reference)

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

31: IAddImportFeatureService, IEqualityComparer<PortableExecutableReference> 129var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count)); 161ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation, 241ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation, 255var seenReferences = new HashSet<PortableExecutableReference>(comparer: this); 256seenReferences.AddAll(project.MetadataReferences.OfType<PortableExecutableReference>()); 290private static ImmutableArray<(Project, PortableExecutableReference)> GetUnreferencedMetadataReferences( 291Project project, HashSet<PortableExecutableReference> seenReferences) 293var result = ArrayBuilder<(Project, PortableExecutableReference)>.GetInstance(); 305if (reference is PortableExecutableReference peReference && 377private static bool IsInPackagesDirectory(PortableExecutableReference reference) 384static bool ContainsPathComponent(PortableExecutableReference reference, string pathComponent) 399private static Compilation CreateCompilation(Project project, PortableExecutableReference reference) 406bool IEqualityComparer<PortableExecutableReference>.Equals(PortableExecutableReference? x, PortableExecutableReference? y) 419int IEqualityComparer<PortableExecutableReference>.GetHashCode(PortableExecutableReference obj)

63/// is the id for the <see cref="Project"/> we can find that <see cref="PortableExecutableReference"/> 70/// If we want to add a <see cref="PortableExecutableReference"/> metadata reference, this 71/// is the <see cref="PortableExecutableReference.FilePath"/> for it.

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

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

25private readonly PortableExecutableReference _reference; 31PortableExecutableReference reference)

22private readonly PortableExecutableReference _metadataReference; 28PortableExecutableReference metadataReference,

108IAssemblySymbol assembly, Project assemblyProject, PortableExecutableReference metadataReference,

107foreach (var peReference in currentProject.MetadataReferences.OfType<PortableExecutableReference>()) 156private static string? GetPEReferenceCacheKey(PortableExecutableReference peReference) 186PortableExecutableReference peReference,

69private static string? GetPEReferenceCacheKey(PortableExecutableReference peReference) 88foreach (var peReference in GetAllRelevantPeReferences(project)) 99foreach (var peReference in GetAllRelevantPeReferences(_originatingDocument.Project)) 155private static ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences(Project project) 156=> project.MetadataReferences.OfType<PortableExecutableReference>().ToImmutableArray(); 194PortableExecutableReference peReference,

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

107if (compilation.GetMetadataReference(symbol.ContainingAssembly) is not PortableExecutableReference { FilePath: not null and var dllPath }) 143var dllReference = IOUtilities.PerformIO(() => MetadataReference.CreateFromFile(dllPath));

51.OfType<PortableExecutableReference>()

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

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

34Assert.Equal(referencePath, DirectCast(metadataReference, PortableExecutableReference).FilePath) 61Assert.Equal(referencePath, DirectCast(metadataReference, PortableExecutableReference).FilePath)

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> _fileReferenceProvider; 54Func<string, MetadataReferenceProperties, PortableExecutableReference>? fileReferenceProvider = null) 71Func<string, MetadataReferenceProperties, PortableExecutableReference>? fileReferenceProvider = null) 85Func<string, MetadataReferenceProperties, PortableExecutableReference>? fileReferenceProvider = null) 92new Func<string, MetadataReferenceProperties, PortableExecutableReference>((path, properties) => MetadataReference.CreateFromFile(path, properties)); 99public override PortableExecutableReference? ResolveMissingAssembly(MetadataReference definition, AssemblyIdentity referenceIdentity) 114var result = ResolveTrustedPlatformAssembly(referenceIdentity.Name, s_resolvedMissingAssemblyReferenceProperties); 122var definitionDirectory = PathUtilities.GetDirectoryName((definition as PortableExecutableReference)?.FilePath); 139private PortableExecutableReference CreateResolvedMissingReference(string fullPath) 144public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string? baseFilePath, MetadataReferenceProperties properties) 159var result = ResolveTrustedPlatformAssembly(PathUtilities.GetFileName(reference, includeExtension: false), properties); 188var result = ResolveTrustedPlatformAssembly(identity.Name, properties); 196return ImmutableArray<PortableExecutableReference>.Empty; 199private 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();

137var delta1Reference = MetadataReference.CreateFromFile(Delta1); 160var gammaReference = MetadataReference.CreateFromFile(Gamma); 219var delta2Reference = MetadataReference.CreateFromFile(Delta2); 280var compilerReference = MetadataReference.CreateFromFile(typeof(Microsoft.CodeAnalysis.SyntaxNode).Assembly.Location); 299var userSystemCollectionsImmutableReference = MetadataReference.CreateFromFile(UserSystemCollectionsImmutable); 354var realSciReference = MetadataReference.CreateFromFile(typeof(ImmutableArray).Assembly.Location); 416var fakeCompilerReference = MetadataReference.CreateFromFile(fakeCompilerAssembly); 444var laterCompilerReference = MetadataReference.CreateFromFile(laterFakeCompilerAssembly);

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

122public static PortableExecutableReference EmitToPortableExecutableReference( 458public static PortableExecutableReference CreateWindowsRuntimeMetadataReference(TargetFramework targetFramework = TargetFramework.NetCoreApp)

103var peRef = (PortableExecutableReference)metadataReference;

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

42public static PortableExecutableReference mscorlib { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet20.mscorlib).GetReference(display: "mscorlib.dll (net20)", filePath: "mscorlib.dll"); 43public static PortableExecutableReference System { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet20.System).GetReference(display: "System.dll (net20)", filePath: "System.dll"); 44public static PortableExecutableReference MicrosoftVisualBasic { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet20.MicrosoftVisualBasic).GetReference(display: "Microsoft.VisualBasic.dll (net20)", filePath: "Microsoft.VisualBasic.dll"); 57public static PortableExecutableReference SystemCore { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet35.SystemCore).GetReference(display: "System.Core.dll (net35)", filePath: "System.Core.dll"); 91public static PortableExecutableReference mscorlib { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.mscorlib).GetReference(display: "mscorlib.dll (net40)", filePath: "mscorlib.dll"); 92public static PortableExecutableReference System { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.System).GetReference(display: "System.dll (net40)", filePath: "System.dll"); 93public static PortableExecutableReference SystemCore { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.SystemCore).GetReference(display: "System.Core.dll (net40)", filePath: "System.Core.dll"); 94public static PortableExecutableReference SystemData { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.SystemData).GetReference(display: "System.Data.dll (net40)", filePath: "System.Data.dll"); 95public static PortableExecutableReference SystemXml { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.SystemXml).GetReference(display: "System.Xml.dll (net40)", filePath: "System.Xml.dll"); 96public static PortableExecutableReference SystemXmlLinq { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.SystemXmlLinq).GetReference(display: "System.Xml.Linq.dll (net40)", filePath: "System.Xml.Linq.dll"); 97public static PortableExecutableReference MicrosoftVisualBasic { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.MicrosoftVisualBasic).GetReference(display: "Microsoft.VisualBasic.dll (net40)", filePath: "Microsoft.VisualBasic.dll"); 98public static PortableExecutableReference MicrosoftCSharp { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet40.MicrosoftCSharp).GetReference(display: "Microsoft.CSharp.dll (net40)", filePath: "Microsoft.CSharp.dll"); 165public static PortableExecutableReference mscorlib { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.mscorlib).GetReference(display: "mscorlib.dll (net451)", filePath: "mscorlib.dll"); 166public static PortableExecutableReference System { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.System).GetReference(display: "System.dll (net451)", filePath: "System.dll"); 167public static PortableExecutableReference SystemConfiguration { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemConfiguration).GetReference(display: "System.Configuration.dll (net451)", filePath: "System.Configuration.dll"); 168public static PortableExecutableReference SystemCore { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemCore).GetReference(display: "System.Core.dll (net451)", filePath: "System.Core.dll"); 169public static PortableExecutableReference SystemData { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemData).GetReference(display: "System.Data.dll (net451)", filePath: "System.Data.dll"); 170public static PortableExecutableReference SystemDrawing { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemDrawing).GetReference(display: "System.Drawing.dll (net451)", filePath: "System.Drawing.dll"); 171public static PortableExecutableReference SystemEnterpriseServices { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemEnterpriseServices).GetReference(display: "System.EnterpriseServices.dll (net451)", filePath: "System.EnterpriseServices.dll"); 172public static PortableExecutableReference SystemRuntimeSerialization { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemRuntimeSerialization).GetReference(display: "System.Runtime.Serialization.dll (net451)", filePath: "System.Runtime.Serialization.dll"); 173public static PortableExecutableReference SystemWindowsForms { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemWindowsForms).GetReference(display: "System.Windows.Forms.dll (net451)", filePath: "System.Windows.Forms.dll"); 174public static PortableExecutableReference SystemWebServices { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemWebServices).GetReference(display: "System.Web.Services.dll (net451)", filePath: "System.Web.Services.dll"); 175public static PortableExecutableReference SystemXml { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemXml).GetReference(display: "System.Xml.dll (net451)", filePath: "System.Xml.dll"); 176public static PortableExecutableReference SystemXmlLinq { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemXmlLinq).GetReference(display: "System.Xml.Linq.dll (net451)", filePath: "System.Xml.Linq.dll"); 177public static PortableExecutableReference MicrosoftCSharp { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.MicrosoftCSharp).GetReference(display: "Microsoft.CSharp.dll (net451)", filePath: "Microsoft.CSharp.dll"); 178public static PortableExecutableReference MicrosoftVisualBasic { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.MicrosoftVisualBasic).GetReference(display: "Microsoft.VisualBasic.dll (net451)", filePath: "Microsoft.VisualBasic.dll"); 179public static PortableExecutableReference SystemObjectModel { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemObjectModel).GetReference(display: "System.ObjectModel.dll (net451)", filePath: "System.ObjectModel.dll"); 180public static PortableExecutableReference SystemRuntime { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemRuntime).GetReference(display: "System.Runtime.dll (net451)", filePath: "System.Runtime.dll"); 181public static PortableExecutableReference SystemRuntimeInteropServicesWindowsRuntime { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemRuntimeInteropServicesWindowsRuntime).GetReference(display: "System.Runtime.InteropServices.WindowsRuntime.dll (net451)", filePath: "System.Runtime.InteropServices.WindowsRuntime.dll"); 182public static PortableExecutableReference SystemThreading { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemThreading).GetReference(display: "System.Threading.dll (net451)", filePath: "System.Threading.dll"); 183public static PortableExecutableReference SystemThreadingTasks { get; } = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemThreadingTasks).GetReference(display: "System.Threading.Tasks.dll (net451)", filePath: "System.Threading.Tasks.dll"); 199public static PortableExecutableReference Netstandard10 { get; } = AssemblyMetadata.CreateFromImage(ResourcesMicrosoftCSharp.Netstandard10).GetReference(display: "Microsoft.CSharp.dll (microsoftcsharp)", filePath: "Netstandard10.dll"); 200public static PortableExecutableReference Netstandard13Lib { get; } = AssemblyMetadata.CreateFromImage(ResourcesMicrosoftCSharp.Netstandard13Lib).GetReference(display: "Microsoft.CSharp.dll (microsoftcsharp)", filePath: "Netstandard13Lib.dll"); 213public static PortableExecutableReference Netstandard11 { get; } = AssemblyMetadata.CreateFromImage(ResourcesMicrosoftVisualBasic.Netstandard11).GetReference(display: "Microsoft.VisualBasic.dll (microsoftvisualbasic)", filePath: "Netstandard11.dll"); 229public static PortableExecutableReference PortableLib { get; } = AssemblyMetadata.CreateFromImage(ResourcesSystemThreadingTasksExtensions.PortableLib).GetReference(display: "System.Threading.Tasks.Extensions.dll (systemthreadingtasksextensions)", filePath: "PortableLib.dll"); 230public static PortableExecutableReference NetStandard20Lib { get; } = AssemblyMetadata.CreateFromImage(ResourcesSystemThreadingTasksExtensions.NetStandard20Lib).GetReference(display: "System.Threading.Tasks.Extensions.dll (systemthreadingtasksextensions)", filePath: "NetStandard20Lib.dll"); 243public static PortableExecutableReference NetStandardToNet461 { get; } = AssemblyMetadata.CreateFromImage(ResourcesBuildExtensions.NetStandardToNet461).GetReference(display: "netstandard.dll (buildextensions)", filePath: "NetStandardToNet461.dll");

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>);

20private static readonly Lazy<PortableExecutableReference> s_appCS = new Lazy<PortableExecutableReference>( 23public static PortableExecutableReference AppCS => s_appCS.Value; 25private static readonly Lazy<PortableExecutableReference> s_moduleCS00 = new Lazy<PortableExecutableReference>( 28public static PortableExecutableReference ModuleCS00 => s_moduleCS00.Value; 30private static readonly Lazy<PortableExecutableReference> s_moduleCS01 = new Lazy<PortableExecutableReference>( 33public static PortableExecutableReference ModuleCS01 => s_moduleCS01.Value; 35private static readonly Lazy<PortableExecutableReference> s_moduleVB01 = new Lazy<PortableExecutableReference>( 38public static PortableExecutableReference ModuleVB01 => s_moduleVB01.Value; 43private static readonly Lazy<PortableExecutableReference> s_CSClasses01 = new Lazy<PortableExecutableReference>( 46public static PortableExecutableReference CSClasses01 => s_CSClasses01.Value; 48private static readonly Lazy<PortableExecutableReference> s_CSInterfaces01 = new Lazy<PortableExecutableReference>( 51public static PortableExecutableReference CSInterfaces01 => s_CSInterfaces01.Value; 53private static readonly Lazy<PortableExecutableReference> s_VBClasses01 = new Lazy<PortableExecutableReference>( 56public static PortableExecutableReference VBClasses01 => s_VBClasses01.Value; 58private static readonly Lazy<PortableExecutableReference> s_VBClasses02 = new Lazy<PortableExecutableReference>( 61public static PortableExecutableReference VBClasses02 => s_VBClasses02.Value; 63private static readonly Lazy<PortableExecutableReference> s_VBInterfaces01 = new Lazy<PortableExecutableReference>( 66public static PortableExecutableReference VBInterfaces01 => s_VBInterfaces01.Value; 74private static readonly Lazy<PortableExecutableReference> s_mincorlib = new Lazy<PortableExecutableReference>( 77public static PortableExecutableReference mincorlib => s_mincorlib.Value; 79private static readonly Lazy<PortableExecutableReference> s_minasync = new Lazy<PortableExecutableReference>( 82public static PortableExecutableReference minasync => s_minasync.Value; 84private static readonly Lazy<PortableExecutableReference> s_minasynccorlib = new Lazy<PortableExecutableReference>( 87public static PortableExecutableReference minasynccorlib => s_minasynccorlib.Value; 92private static readonly Lazy<PortableExecutableReference> s_tuplelib = new Lazy<PortableExecutableReference>( 95public static PortableExecutableReference tuplelib => s_tuplelib.Value; 100private static readonly Lazy<PortableExecutableReference> s_system = new Lazy<PortableExecutableReference>( 103public static PortableExecutableReference System => s_system.Value; 111private static readonly Lazy<PortableExecutableReference> s_errTestLib01 = new Lazy<PortableExecutableReference>( 114public static PortableExecutableReference dll => s_errTestLib01.Value; 119private static readonly Lazy<PortableExecutableReference> s_errTestLib02 = new Lazy<PortableExecutableReference>( 122public static PortableExecutableReference dll => s_errTestLib02.Value; 127private static readonly Lazy<PortableExecutableReference> s_errTestLib11 = new Lazy<PortableExecutableReference>( 130public static PortableExecutableReference dll => s_errTestLib11.Value; 135private static readonly Lazy<PortableExecutableReference> s_errTestMod01 = new Lazy<PortableExecutableReference>( 138public static PortableExecutableReference dll => s_errTestMod01.Value; 143private static readonly Lazy<PortableExecutableReference> s_errTestMod02 = new Lazy<PortableExecutableReference>( 146public static PortableExecutableReference dll => s_errTestMod02.Value; 151private static readonly Lazy<PortableExecutableReference> s_badresfile = new Lazy<PortableExecutableReference>( 154public static PortableExecutableReference res => s_badresfile.Value; 160private static readonly Lazy<PortableExecutableReference> s_mdTestLib1 = new Lazy<PortableExecutableReference>( 163public static PortableExecutableReference MDTestLib1 => s_mdTestLib1.Value; 165private static readonly Lazy<PortableExecutableReference> s_mdTestLib2 = new Lazy<PortableExecutableReference>( 168public static PortableExecutableReference MDTestLib2 => s_mdTestLib2.Value; 170private static readonly Lazy<PortableExecutableReference> s_VBConversions = new Lazy<PortableExecutableReference>( 173public static PortableExecutableReference VBConversions => s_VBConversions.Value; 175private static readonly Lazy<PortableExecutableReference> s_withSpaces = new Lazy<PortableExecutableReference>( 178public static PortableExecutableReference WithSpaces => s_withSpaces.Value; 180private static readonly Lazy<PortableExecutableReference> s_withSpacesModule = new Lazy<PortableExecutableReference>( 183public static PortableExecutableReference WithSpacesModule => s_withSpacesModule.Value; 185private static readonly Lazy<PortableExecutableReference> s_inheritIComparable = new Lazy<PortableExecutableReference>( 188public static PortableExecutableReference InheritIComparable => s_inheritIComparable.Value; 190private static readonly Lazy<PortableExecutableReference> s_bigVisitor = new Lazy<PortableExecutableReference>( 193public static PortableExecutableReference BigVisitor => s_bigVisitor.Value; 195private static readonly Lazy<PortableExecutableReference> s_properties = new Lazy<PortableExecutableReference>( 198public static PortableExecutableReference Properties => s_properties.Value; 200private static readonly Lazy<PortableExecutableReference> s_propertiesWithByRef = new Lazy<PortableExecutableReference>( 203public static PortableExecutableReference PropertiesWithByRef => s_propertiesWithByRef.Value; 205private static readonly Lazy<PortableExecutableReference> s_indexers = new Lazy<PortableExecutableReference>( 208public static PortableExecutableReference Indexers => s_indexers.Value; 210private static readonly Lazy<PortableExecutableReference> s_events = new Lazy<PortableExecutableReference>( 213public static PortableExecutableReference Events => s_events.Value; 217private static readonly Lazy<PortableExecutableReference> s_netModule1 = new Lazy<PortableExecutableReference>( 220public static PortableExecutableReference netModule1 => s_netModule1.Value; 222private static readonly Lazy<PortableExecutableReference> s_netModule2 = new Lazy<PortableExecutableReference>( 225public static PortableExecutableReference netModule2 => s_netModule2.Value; 227private static readonly Lazy<PortableExecutableReference> s_crossRefModule1 = new Lazy<PortableExecutableReference>( 230public static PortableExecutableReference CrossRefModule1 => s_crossRefModule1.Value; 232private static readonly Lazy<PortableExecutableReference> s_crossRefModule2 = new Lazy<PortableExecutableReference>( 235public static PortableExecutableReference CrossRefModule2 => s_crossRefModule2.Value; 237private static readonly Lazy<PortableExecutableReference> s_crossRefLib = new Lazy<PortableExecutableReference>( 243public static PortableExecutableReference CrossRefLib => s_crossRefLib.Value; 245private static readonly Lazy<PortableExecutableReference> s_hash_module = new Lazy<PortableExecutableReference>( 248public static PortableExecutableReference hash_module => s_hash_module.Value; 250private static readonly Lazy<PortableExecutableReference> s_x64COFF = new Lazy<PortableExecutableReference>( 253public static PortableExecutableReference x64COFF => s_x64COFF.Value; 260private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 263public static PortableExecutableReference dll => s_v1MTTestLib1.Value; 268private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 271public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 276private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib2 = new Lazy<PortableExecutableReference>( 279public static PortableExecutableReference dll => s_v1MTTestLib2.Value; 284private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 287public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 295private static readonly Lazy<PortableExecutableReference> s_v2MTTestLib1 = new Lazy<PortableExecutableReference>( 298public static PortableExecutableReference dll => s_v2MTTestLib1.Value; 303private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 306public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 311private static readonly Lazy<PortableExecutableReference> s_v2MTTestLib3 = new Lazy<PortableExecutableReference>( 314public static PortableExecutableReference dll => s_v2MTTestLib3.Value; 319private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 322public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 330private static readonly Lazy<PortableExecutableReference> s_v3MTTestLib1 = new Lazy<PortableExecutableReference>( 333public static PortableExecutableReference dll => s_v3MTTestLib1.Value; 338private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 341public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 346private static readonly Lazy<PortableExecutableReference> s_v3MTTestLib4 = new Lazy<PortableExecutableReference>( 349public static PortableExecutableReference dll => s_v3MTTestLib4.Value; 354private static readonly Lazy<PortableExecutableReference> s_v1MTTestLib1 = new Lazy<PortableExecutableReference>( 357public static PortableExecutableReference netmodule => s_v1MTTestLib1.Value; 363private static readonly Lazy<PortableExecutableReference> s_assembly = new Lazy<PortableExecutableReference>( 369public static PortableExecutableReference Assembly => s_assembly.Value; 371private static readonly Lazy<PortableExecutableReference> s_mod2 = new Lazy<PortableExecutableReference>( 374public static PortableExecutableReference mod2 => s_mod2.Value; 376private static readonly Lazy<PortableExecutableReference> s_mod3 = new Lazy<PortableExecutableReference>( 379public static PortableExecutableReference mod3 => s_mod3.Value; 381private static readonly Lazy<PortableExecutableReference> s_consumer = new Lazy<PortableExecutableReference>( 384public static PortableExecutableReference Consumer => s_consumer.Value; 389private static readonly Lazy<PortableExecutableReference> s_typeAndNamespaceDifferByCase = new Lazy<PortableExecutableReference>( 392public static PortableExecutableReference TypeAndNamespaceDifferByCase => s_typeAndNamespaceDifferByCase.Value; 394private static readonly Lazy<PortableExecutableReference> s_differByCaseConsumer = new Lazy<PortableExecutableReference>( 397public static PortableExecutableReference Consumer => s_differByCaseConsumer.Value; 399private static readonly Lazy<PortableExecutableReference> s_csharpCaseSen = new Lazy<PortableExecutableReference>( 402public static PortableExecutableReference CsharpCaseSen => s_csharpCaseSen.Value; 404private static readonly Lazy<PortableExecutableReference> s_csharpDifferCaseOverloads = new Lazy<PortableExecutableReference>( 407public static PortableExecutableReference CsharpDifferCaseOverloads => s_csharpDifferCaseOverloads.Value; 414private static readonly Lazy<PortableExecutableReference> s_exe = new Lazy<PortableExecutableReference>( 417public static PortableExecutableReference exe => s_exe.Value; 420private static readonly Lazy<PortableExecutableReference> s_noMsCorLibRef = new Lazy<PortableExecutableReference>( 423public static PortableExecutableReference NoMsCorLibRef => s_noMsCorLibRef.Value; 427private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 430public static PortableExecutableReference dll => s_dll.Value; 438private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 441public static PortableExecutableReference dll => s_dll.Value; 443private static readonly Lazy<PortableExecutableReference> s_module = new Lazy<PortableExecutableReference>( 446public static PortableExecutableReference netmodule => s_module.Value; 449private static readonly Lazy<PortableExecutableReference> s_modoptTests = new Lazy<PortableExecutableReference>( 452public static PortableExecutableReference ModoptTests => s_modoptTests.Value; 456private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 459public static PortableExecutableReference dll => s_dll.Value; 464private static readonly Lazy<PortableExecutableReference> s_dll = new Lazy<PortableExecutableReference>( 467public static PortableExecutableReference dll => s_dll.Value; 475private static readonly Lazy<PortableExecutableReference> s_cyclic1 = new Lazy<PortableExecutableReference>( 478public static PortableExecutableReference dll => s_cyclic1.Value; 483private static readonly Lazy<PortableExecutableReference> s_cyclic2 = new Lazy<PortableExecutableReference>( 486public static PortableExecutableReference dll => s_cyclic2.Value; 492private static readonly Lazy<PortableExecutableReference> s_class1 = new Lazy<PortableExecutableReference>( 495public static PortableExecutableReference Class1 => s_class1.Value; 497private static readonly Lazy<PortableExecutableReference> s_class2 = new Lazy<PortableExecutableReference>( 500public static PortableExecutableReference Class2 => s_class2.Value; 502private static readonly Lazy<PortableExecutableReference> s_class3 = new Lazy<PortableExecutableReference>( 505public static PortableExecutableReference Class3 => s_class3.Value; 508private static readonly Lazy<PortableExecutableReference> s_cycledStructs = new Lazy<PortableExecutableReference>( 511public static PortableExecutableReference CycledStructs => s_cycledStructs.Value; 519private static readonly Lazy<PortableExecutableReference> s_classA = new Lazy<PortableExecutableReference>( 522public static PortableExecutableReference dll => s_classA.Value; 527private static readonly Lazy<PortableExecutableReference> s_classB = new Lazy<PortableExecutableReference>( 530public static PortableExecutableReference netmodule => s_classB.Value; 538private static readonly Lazy<PortableExecutableReference> s_classA = new Lazy<PortableExecutableReference>( 541public static PortableExecutableReference dll => s_classA.Value; 546private static readonly Lazy<PortableExecutableReference> s_classB = new Lazy<PortableExecutableReference>( 549public static PortableExecutableReference dll => s_classB.Value; 556private static readonly Lazy<PortableExecutableReference> s_CSMethods = new Lazy<PortableExecutableReference>( 559public static PortableExecutableReference CSMethods => s_CSMethods.Value; 561private static readonly Lazy<PortableExecutableReference> s_VBMethods = new Lazy<PortableExecutableReference>( 564public static PortableExecutableReference VBMethods => s_VBMethods.Value; 566private static readonly Lazy<PortableExecutableReference> s_ILMethods = new Lazy<PortableExecutableReference>( 569public static PortableExecutableReference ILMethods => s_ILMethods.Value; 571private static readonly Lazy<PortableExecutableReference> s_byRefReturn = new Lazy<PortableExecutableReference>( 574public static PortableExecutableReference ByRefReturn => s_byRefReturn.Value; 581private static readonly Lazy<PortableExecutableReference> s_CSFields = new Lazy<PortableExecutableReference>( 584public static PortableExecutableReference dll => s_CSFields.Value; 589private static readonly Lazy<PortableExecutableReference> s_VBFields = new Lazy<PortableExecutableReference>( 592public static PortableExecutableReference dll => s_VBFields.Value; 595private static readonly Lazy<PortableExecutableReference> s_constantFields = new Lazy<PortableExecutableReference>( 598public static PortableExecutableReference ConstantFields => s_constantFields.Value; 603private static readonly Lazy<PortableExecutableReference> s_MDMissingType = new Lazy<PortableExecutableReference>( 606public static PortableExecutableReference MDMissingType => s_MDMissingType.Value; 608private static readonly Lazy<PortableExecutableReference> s_MDMissingTypeLib = new Lazy<PortableExecutableReference>( 611public static PortableExecutableReference MDMissingTypeLib => s_MDMissingTypeLib.Value; 613private static readonly Lazy<PortableExecutableReference> s_missingTypesEquality1 = new Lazy<PortableExecutableReference>( 616public static PortableExecutableReference MissingTypesEquality1 => s_missingTypesEquality1.Value; 618private static readonly Lazy<PortableExecutableReference> s_missingTypesEquality2 = new Lazy<PortableExecutableReference>( 621public static PortableExecutableReference MissingTypesEquality2 => s_missingTypesEquality2.Value; 623private static readonly Lazy<PortableExecutableReference> s_CL2 = new Lazy<PortableExecutableReference>( 626public static PortableExecutableReference CL2 => s_CL2.Value; 628private static readonly Lazy<PortableExecutableReference> s_CL3 = new Lazy<PortableExecutableReference>( 631public static PortableExecutableReference CL3 => s_CL3.Value; 638private static readonly Lazy<PortableExecutableReference> s_typeForwarder2 = new Lazy<PortableExecutableReference>( 641public static PortableExecutableReference dll => s_typeForwarder2.Value; 646private static readonly Lazy<PortableExecutableReference> s_typeForwarderLib2 = new Lazy<PortableExecutableReference>( 649public static PortableExecutableReference dll => s_typeForwarderLib2.Value; 654private static readonly Lazy<PortableExecutableReference> s_typeForwarderBase2 = new Lazy<PortableExecutableReference>( 657public static PortableExecutableReference dll => s_typeForwarderBase2.Value; 663private static readonly Lazy<PortableExecutableReference> s_source1Module = new Lazy<PortableExecutableReference>( 666public static PortableExecutableReference Source1Module => s_source1Module.Value; 668private static readonly Lazy<PortableExecutableReference> s_source3Module = new Lazy<PortableExecutableReference>( 671public static PortableExecutableReference Source3Module => s_source3Module.Value; 673private static readonly Lazy<PortableExecutableReference> s_source4Module = new Lazy<PortableExecutableReference>( 676public static PortableExecutableReference Source4Module => s_source4Module.Value; 678private static readonly Lazy<PortableExecutableReference> s_source5Module = new Lazy<PortableExecutableReference>( 681public static PortableExecutableReference Source5Module => s_source5Module.Value; 683private static readonly Lazy<PortableExecutableReference> s_source7Module = new Lazy<PortableExecutableReference>( 686public static PortableExecutableReference Source7Module => s_source7Module.Value; 691private static readonly Lazy<PortableExecutableReference> s_stdOle = new Lazy<PortableExecutableReference>( 694public static PortableExecutableReference StdOle => s_stdOle.Value; 696private static readonly Lazy<PortableExecutableReference> s_pia1 = new Lazy<PortableExecutableReference>( 699public static PortableExecutableReference Pia1 => s_pia1.Value; 701private static readonly Lazy<PortableExecutableReference> s_pia1Copy = new Lazy<PortableExecutableReference>( 704public static PortableExecutableReference Pia1Copy => s_pia1Copy.Value; 706private static readonly Lazy<PortableExecutableReference> s_pia2 = new Lazy<PortableExecutableReference>( 709public static PortableExecutableReference Pia2 => s_pia2.Value; 711private static readonly Lazy<PortableExecutableReference> s_pia3 = new Lazy<PortableExecutableReference>( 714public static PortableExecutableReference Pia3 => s_pia3.Value; 716private static readonly Lazy<PortableExecutableReference> s_pia4 = new Lazy<PortableExecutableReference>( 719public static PortableExecutableReference Pia4 => s_pia4.Value; 721private static readonly Lazy<PortableExecutableReference> s_pia5 = new Lazy<PortableExecutableReference>( 724public static PortableExecutableReference Pia5 => s_pia5.Value; 726private static readonly Lazy<PortableExecutableReference> s_generalPia = new Lazy<PortableExecutableReference>( 729public static PortableExecutableReference GeneralPia => s_generalPia.Value; 731private static readonly Lazy<PortableExecutableReference> s_generalPiaCopy = new Lazy<PortableExecutableReference>( 734public static PortableExecutableReference GeneralPiaCopy => s_generalPiaCopy.Value; 736private static readonly Lazy<PortableExecutableReference> s_noPIAGenericsAsm1 = new Lazy<PortableExecutableReference>( 739public static PortableExecutableReference NoPIAGenericsAsm1 => s_noPIAGenericsAsm1.Value; 741private static readonly Lazy<PortableExecutableReference> s_externalAsm1 = new Lazy<PortableExecutableReference>( 744public static PortableExecutableReference ExternalAsm1 => s_externalAsm1.Value; 746private static readonly Lazy<PortableExecutableReference> s_library1 = new Lazy<PortableExecutableReference>( 749public static PortableExecutableReference Library1 => s_library1.Value; 751private static readonly Lazy<PortableExecutableReference> s_library2 = new Lazy<PortableExecutableReference>( 754public static PortableExecutableReference Library2 => s_library2.Value; 756private static readonly Lazy<PortableExecutableReference> s_localTypes1 = new Lazy<PortableExecutableReference>( 759public static PortableExecutableReference LocalTypes1 => s_localTypes1.Value; 761private static readonly Lazy<PortableExecutableReference> s_localTypes2 = new Lazy<PortableExecutableReference>( 764public static PortableExecutableReference LocalTypes2 => s_localTypes2.Value; 766private static readonly Lazy<PortableExecutableReference> s_localTypes3 = new Lazy<PortableExecutableReference>( 769public static PortableExecutableReference LocalTypes3 => s_localTypes3.Value; 771private static readonly Lazy<PortableExecutableReference> s_A = new Lazy<PortableExecutableReference>( 774public static PortableExecutableReference A => s_A.Value; 776private static readonly Lazy<PortableExecutableReference> s_B = new Lazy<PortableExecutableReference>( 779public static PortableExecutableReference B => s_B.Value; 781private static readonly Lazy<PortableExecutableReference> s_C = new Lazy<PortableExecutableReference>( 784public static PortableExecutableReference C => s_C.Value; 786private static readonly Lazy<PortableExecutableReference> s_D = new Lazy<PortableExecutableReference>( 789public static PortableExecutableReference D => s_D.Value; 795private static readonly Lazy<PortableExecutableReference> s_missingPIAAttributes = new Lazy<PortableExecutableReference>( 798public static PortableExecutableReference MissingPIAAttributes => s_missingPIAAttributes.Value; 805private static readonly Lazy<PortableExecutableReference> s_staticMethodInInterface = new Lazy<PortableExecutableReference>( 808public static PortableExecutableReference StaticMethodInInterface => s_staticMethodInInterface.Value; 810private static readonly Lazy<PortableExecutableReference> s_MDInterfaceMapping = new Lazy<PortableExecutableReference>( 813public static PortableExecutableReference MDInterfaceMapping => s_MDInterfaceMapping.Value; 818private static readonly Lazy<PortableExecutableReference> s_MDTestLib1 = new Lazy<PortableExecutableReference>( 821public static PortableExecutableReference MDTestLib1 => s_MDTestLib1.Value; 823private static readonly Lazy<PortableExecutableReference> s_netModule1 = new Lazy<PortableExecutableReference>( 826public static PortableExecutableReference netModule1 => s_netModule1.Value; 833private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 836public static PortableExecutableReference CSharp => s_CSharp.Value; 838private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 841public static PortableExecutableReference IL => s_IL.Value; 846private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 849public static PortableExecutableReference CSharp => s_CSharp.Value; 851private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 854public static PortableExecutableReference IL => s_IL.Value; 859private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 862public static PortableExecutableReference CSharp => s_CSharp.Value; 866private static readonly Lazy<PortableExecutableReference> s_regress40025 = new Lazy<PortableExecutableReference>( 869public static PortableExecutableReference Regress40025 => s_regress40025.Value; 873private static readonly Lazy<PortableExecutableReference> s_simpleWithEvents = new Lazy<PortableExecutableReference>( 876public static PortableExecutableReference SimpleWithEvents => s_simpleWithEvents.Value; 881private static readonly Lazy<PortableExecutableReference> s_delegatesWithoutInvoke = new Lazy<PortableExecutableReference>( 884public static PortableExecutableReference DelegatesWithoutInvoke => s_delegatesWithoutInvoke.Value; 886private static readonly Lazy<PortableExecutableReference> s_delegateByRefParamArray = new Lazy<PortableExecutableReference>( 889public static PortableExecutableReference DelegateByRefParamArray => s_delegateByRefParamArray.Value; 894private static readonly Lazy<PortableExecutableReference> s_invalidCharactersInAssemblyName2 = new Lazy<PortableExecutableReference>( 897public static PortableExecutableReference InvalidCharactersInAssemblyName => s_invalidCharactersInAssemblyName2.Value; 899private static readonly Lazy<PortableExecutableReference> s_MDTestAttributeDefLib = new Lazy<PortableExecutableReference>( 902public static PortableExecutableReference MDTestAttributeDefLib => s_MDTestAttributeDefLib.Value; 904private static readonly Lazy<PortableExecutableReference> s_MDTestAttributeApplicationLib = new Lazy<PortableExecutableReference>( 907public static PortableExecutableReference MDTestAttributeApplicationLib => s_MDTestAttributeApplicationLib.Value; 909private static readonly Lazy<PortableExecutableReference> s_attributeInterop01 = new Lazy<PortableExecutableReference>( 912public static PortableExecutableReference AttributeInterop01 => s_attributeInterop01.Value; 914private static readonly Lazy<PortableExecutableReference> s_attributeInterop02 = new Lazy<PortableExecutableReference>( 917public static PortableExecutableReference AttributeInterop02 => s_attributeInterop02.Value; 919private static readonly Lazy<PortableExecutableReference> s_attributeTestLib01 = new Lazy<PortableExecutableReference>( 922public static PortableExecutableReference AttributeTestLib01 => s_attributeTestLib01.Value; 924private static readonly Lazy<PortableExecutableReference> s_attributeTestDef01 = new Lazy<PortableExecutableReference>( 927public static PortableExecutableReference AttributeTestDef01 => s_attributeTestDef01.Value; 929private static readonly Lazy<PortableExecutableReference> s_dynamicAttributeLib = new Lazy<PortableExecutableReference>( 932public static PortableExecutableReference DynamicAttributeLib => s_dynamicAttributeLib.Value; 937private static readonly Lazy<PortableExecutableReference> s_unavailable = new Lazy<PortableExecutableReference>( 940public static PortableExecutableReference Unavailable => s_unavailable.Value; 942private static readonly Lazy<PortableExecutableReference> s_CSharp = new Lazy<PortableExecutableReference>( 945public static PortableExecutableReference CSharp => s_CSharp.Value; 947private static readonly Lazy<PortableExecutableReference> s_IL = new Lazy<PortableExecutableReference>( 950public static PortableExecutableReference IL => s_IL.Value; 955private static readonly Lazy<PortableExecutableReference> s_AR_SA = new Lazy<PortableExecutableReference>( 958public static PortableExecutableReference AR_SA => s_AR_SA.Value; 960private static readonly Lazy<PortableExecutableReference> s_EN_US = new Lazy<PortableExecutableReference>( 963public static PortableExecutableReference EN_US => s_EN_US.Value; 965private static readonly Lazy<PortableExecutableReference> s_C1 = new Lazy<PortableExecutableReference>( 968public static PortableExecutableReference C1 => s_C1.Value; 970private static readonly Lazy<PortableExecutableReference> s_C2 = new Lazy<PortableExecutableReference>( 973public static PortableExecutableReference C2 => s_C2.Value;

106public static PortableExecutableReference netstandard { get; } = Net70.netstandard; 107public static PortableExecutableReference mscorlib { get; } = Net70.mscorlib; 108public static PortableExecutableReference SystemRuntime { get; } = Net70.SystemRuntime; 144public static PortableExecutableReference mscorlib { get; } = Net461.mscorlib; 145public static PortableExecutableReference System { get; } = Net461.System; 146public static PortableExecutableReference SystemRuntime { get; } = Net461.SystemRuntime; 147public static PortableExecutableReference SystemCore { get; } = Net461.SystemCore; 148public static PortableExecutableReference SystemThreadingTasks { get; } = Net461.SystemThreadingTasks; 149public static PortableExecutableReference MicrosoftCSharp { get; } = Net461.MicrosoftCSharp; 150public static PortableExecutableReference MicrosoftVisualBasic { get; } = Net461.MicrosoftVisualBasic; 155private static readonly ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>> s_dynamicReferenceMap = new ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>>(StringComparer.Ordinal); 281if (m is PortableExecutableReference p && 302.Where(x => !(x is PortableExecutableReference pe && excludeReferenceNames.Contains(pe.FilePath))); 310private static ImmutableArray<PortableExecutableReference> LoadDynamicReferences(string targetFrameworkName) 326references = ((IEnumerable<PortableExecutableReference>)obj).ToImmutableArray();

85var winmd = AssemblyMetadata.CreateFromImage(TestResources.WinRt.Windows).GetReference(display: "Windows"); 87var windowsruntime = 90var runtime = 93var objectModel = 96var uixaml = AssemblyMetadata.CreateFromImage(ProprietaryTestResources.v4_0_30319_17929.System_Runtime_WindowsRuntime_UI_Xaml). 99var interop = AssemblyMetadata.CreateFromImage(ResourcesNet451.SystemRuntimeInteropServicesWindowsRuntime). 103var system = AssemblyMetadata.CreateFromImage(ResourcesNet451.System).GetReference(display: "System.dll"); 105var mscor = AssemblyMetadata.CreateFromImage(ResourcesNet451.mscorlib).GetReference(display: "mscorlib");

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(ResourcesNet451.mscorlib).GetReference(display: "i1"); 530var i2 = AssemblyMetadata.CreateFromImage(ResourcesNet451.mscorlib).GetReference(display: "i2"); 568var corlib = AssemblyMetadata.CreateFromImage(ResourcesNet451.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)

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

2506Public Overrides Function ResolveReference(reference As String, baseFilePath As String, properties As MetadataReferenceProperties) As ImmutableArray(Of PortableExecutableReference) 2535Dim peRef = TryCast(r, PortableExecutableReference) 2551Dim peRef = TryCast(r, PortableExecutableReference)

16''' Need to create a <see cref="PortableExecutableReference"/> without a file path here. Scripting 20Private Shared ReadOnly s_msvbReference As PortableExecutableReference = AssemblyMetadata.CreateFromImage(TestMetadata.ResourcesNet451.MicrosoftVisualBasic).GetReference()

2439Protected Overrides Function WithPropertiesImpl(properties As MetadataReferenceProperties) As PortableExecutableReference

72PortableExecutableReference reference,

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

118using var _4 = PooledHashSet<PortableExecutableReference>.GetInstance(out var seenPEReferences); 310if (reference is not PortableExecutableReference peReference) 328seenPEReferences.AddRange(compilation.References.OfType<PortableExecutableReference>()); 335PortableExecutableReference reference,

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

22/// 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, 123PortableExecutableReference reference, 148PortableExecutableReference reference, 178public static async Task<SymbolTreeInfo?> TryGetCachedInfoForMetadataReferenceIgnoreChecksumAsync(PortableExecutableReference reference, CancellationToken cancellationToken) 188SolutionServices services, PortableExecutableReference reference, CancellationToken cancellationToken) 201static Checksum GetMetadataChecksumSlow(SolutionServices services, PortableExecutableReference reference, CancellationToken cancellationToken) 216private static string GetMetadataKeySuffix(PortableExecutableReference reference) 226PortableExecutableReference reference,

30private readonly ConcurrentDictionary<PortableExecutableReference, MetadataInfo> _peReferenceToInfo = new(); 69PortableExecutableReference reference, 152foreach (var reference in project.MetadataReferences.OfType<PortableExecutableReference>().Distinct()) 191PortableExecutableReference reference,

29if (reference is PortableExecutableReference portable) 66if (reference is PortableExecutableReference portable) 86if (type == nameof(PortableExecutableReference)) 127PortableExecutableReference reference, SerializationKinds kind, ObjectWriter writer, CancellationToken cancellationToken) 129writer.WriteString(nameof(PortableExecutableReference)); 135private static void WritePortableExecutableReferencePropertiesTo(PortableExecutableReference reference, ObjectWriter writer, CancellationToken cancellationToken) 141private static Checksum CreatePortableExecutableReferenceChecksum(PortableExecutableReference reference, CancellationToken cancellationToken) 219PortableExecutableReference reference, ObjectWriter writer, CancellationToken cancellationToken) 228private PortableExecutableReference ReadPortableExecutableReferenceFrom(ObjectReader reader, CancellationToken cancellationToken) 341WritePortableExecutableReferenceHeaderTo((PortableExecutableReference)reference, SerializationKinds.MemoryMapFile, writer, cancellationToken); 552private static Metadata? TryGetMetadata(PortableExecutableReference reference) 625protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties) 656protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

11PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties);

35public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties) 36=> (PortableExecutableReference)_metadataCache.GetReference(resolvedPath, properties);

28public override ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties) 33return ImmutableArray<PortableExecutableReference>.Empty;

30private readonly Dictionary<PortableExecutableReference, IWatchedFile> _metadataReferenceFileWatchingTokens = new(); 64public PortableExecutableReference CreateReferenceAndStartWatchingFile(string fullFilePath, MetadataReferenceProperties properties) 68var reference = _solutionServices.GetRequiredService<IMetadataService>().GetReference(fullFilePath, properties); 77public void StopWatchingReference(PortableExecutableReference reference)

573var metadataReference = _projectSystemProjectFactory.Workspace.CurrentSolution.GetRequiredProject(Id).MetadataReferences.Cast<PortableExecutableReference>() 602var metadataReference = _projectSystemProjectFactory.FileWatchedReferenceFactory.CreateReferenceAndStartWatchingFile(path, properties); 1062var metadataReference = _projectSystemProjectFactory.FileWatchedReferenceFactory.CreateReferenceAndStartWatchingFile(fullPath, properties); 1134var metadataReference = w.CurrentSolution.GetRequiredProject(Id).MetadataReferences.Cast<PortableExecutableReference>() 1304foreach (PortableExecutableReference reference in remainingMetadataReferences)

409foreach (PortableExecutableReference reference in solutionChanges.Solution.GetProjectState(projectIdToRetarget)!.MetadataReferences) 499var metadataReference = 630foreach (var portableExecutableReference in project.MetadataReferences.OfType<PortableExecutableReference>()) 636var newPortableExecutableReference =

37private readonly Dictionary<MetadataReferenceProperties, PortableExecutableReference> _referenceMap = new(); 49public PortableExecutableReference GetOrCreateMetadataReference(MetadataReferenceProperties properties) 53if (!_referenceMap.TryGetValue(properties, out var value))

1221if (meta is PortableExecutableReference pemeta)

86PortableExecutableReference portableExecutableReference => portableExecutableReference.FilePath,

346if (reference is PortableExecutableReference peRef && peRef.FilePath != null) 408if (reference is PortableExecutableReference peRef && peRef.FilePath != null)

79var fileNames = new HashSet<string>(references.Select(r => Path.GetFileName(((PortableExecutableReference)r).FilePath))); 169.OfType<PortableExecutableReference>() 174.OfType<PortableExecutableReference>() 180=> ((PortableExecutableReference)metadataReference).GetMetadata(); 307var pref = c2.References.OfType<PortableExecutableReference>().FirstOrDefault(r => r.Display == "CSharpProject"); 334var pref = c2.References.OfType<PortableExecutableReference>().FirstOrDefault(r => r.Display == "EmittedCSharpProject"); 775var csharpLib = refs.OfType<PortableExecutableReference>().FirstOrDefault(r => r.FilePath.Contains("Microsoft.CSharp")); 1317Assert.Contains(metaRefs, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1339Assert.Contains(project.MetadataReferences, r => r is PortableExecutableReference reference && reference.Display.Contains("CSharpProject.dll")); 1385Assert.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")); 1890var mtref = MetadataReference.CreateFromImage(metadataBytes); 1913var mtref = MetadataReference.CreateFromImage(metadataBytes); 1937var mtref = MetadataReference.CreateFromImage(metadataBytes); 1960var mtref = MetadataReference.CreateFromImage(metadataBytes); 3154project.MetadataReferences.Select(r => Path.GetFileName(((PortableExecutableReference)r).FilePath)).OrderBy(StringComparer.Ordinal));

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

108.AddMetadataReference(pid, ((PortableExecutableReference)MscorlibRef).WithAliases(new[] { "X" }))

2293var mefReference = TestMetadata.Net451.SystemCore;

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

27metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 56metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 67metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 96metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 107metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 136metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 147metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 180metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location))); 190PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location), 191PortableExecutableReference.CreateFromFile(typeof(Workspace).Assembly.Location)));

141if (referenceListItem.MetadataReference is PortableExecutableReference portableExecutableReference)

625if (reference is PortableExecutableReference portableExecutableReference)

851if (referenceListItem.MetadataReference is not PortableExecutableReference metadataReference) 933if (referenceListItem.MetadataReference is not PortableExecutableReference portableExecutableReference)

27if (reference is PortableExecutableReference portableExecutableReference) 155libraryName = compilation.GetMetadataReference(containingAssembly) is PortableExecutableReference portableExecutableReference

426if (compilation.GetMetadataReference(containingAssembly) is PortableExecutableReference reference && !string.IsNullOrEmpty(reference.FilePath))

28/// The compiler observes the metadata content a reference refers to by calling <see cref="PortableExecutableReference.GetMetadataImpl()"/> 107protected override PortableExecutableReference WithPropertiesImpl(MetadataReferenceProperties properties)

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

41public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties)

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

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

571if (metadataReference is PortableExecutableReference fileMetadata)

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

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

45public PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties)

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

12Return project.MetadataReferences.Cast(Of PortableExecutableReference).Any(Function(vsReference) String.Equals(vsReference.FilePath, path, StringComparison.OrdinalIgnoreCase))

857Dim references = New List(Of PortableExecutableReference) 859references.Add(PortableExecutableReference.CreateFromFile(Path.Combine(directory.Path, referenceName + ".dll")))

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

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()