/// <summary>
/// Resolves given metadata references to assemblies and modules.
/// </summary>
/// <param name="compilation">The compilation whose references are being resolved.</param>
/// <param name="references">List where to store resolved references. References from #r directives will follow references passed to the compilation constructor.</param>
/// <param name="boundReferenceDirectiveMap">Maps #r values to successuflly resolved metadata references. Does not contain values that failed to resolve.</param>
/// <param name="boundReferenceDirectives">Unique metadata references resolved from #r directives.</param>
/// <param name="assemblies">List where to store information about resolved assemblies to.</param>
/// <param name="modules">List where to store information about resolved modules to.</param>
/// <param name="diagnostics">Diagnostic bag where to report resolution errors.</param>
/// <returns>
/// Maps index to <paramref name="references"/> to an index of a resolved assembly or module in <paramref name="assemblies"/> or <paramref name="modules"/>, respectively.
///</returns>
protected ReadOnlyArray <ResolvedReference> ResolveMetadataReferences(
TCompilation compilation,
List <MetadataReference> references,
out IDictionary <string, MetadataReference> boundReferenceDirectiveMap,
out ReadOnlyArray <MetadataReference> boundReferenceDirectives,
List <AssemblyData> assemblies,
List <Module> modules,
DiagnosticBag diagnostics)
{
// Locations of all #r directives in the order they are listed in the references list.
List <CommonLocation> referenceDirectiveLocations;
GetCompilationReferences(compilation, diagnostics, references, out boundReferenceDirectiveMap, out referenceDirectiveLocations);
int externalReferenceCount = compilation.ExternalReferences.Count;
int referenceCount = references.Count;
// References originating from #r directives precede references supplied as arguments of the compilation.
int referenceDirectiveCount = referenceCount - externalReferenceCount;
Debug.Assert((referenceDirectiveLocations != null ? referenceDirectiveLocations.Count : 0) == referenceDirectiveCount);
var referenceMap = new ResolvedReference[referenceCount];
// Maps references that were added to the reference set (i.e. not filtered out as duplicates) to a set of names that
// can be used to alias these references. Duplicate assemblies contribute their aliases into this set.
Dictionary <MetadataReference, ArrayBuilder <string> > aliasMap = null;
// Used to filter out duplicate references that reference the same file (resolve to the same full normalized path).
var boundReferences = new Dictionary <MetadataReference, MetadataReference>(MetadataReferenceEqualityComparer.Instance);
// Used to filter out assemblies that have the same strong or weak identity.
// Maps simple name to a list of full names.
Dictionary <string, List <ReferencedAssemblyIdentity> > assemblyReferencesBySimpleName = null;
ArrayBuilder <MetadataReference> uniqueDirectiveReferences = (referenceDirectiveLocations != null) ? ArrayBuilder <MetadataReference> .GetInstance() : null;
// When duplicate references with conflicting EmbedInteropTypes flag are encountered,
// VB uses the flag from the last one, C# reports an error. We need to enumerate in reverse order
// so that we find the one that matters first.
for (int referenceIndex = referenceCount - 1; referenceIndex >= 0; referenceIndex--)
{
var boundReference = references[referenceIndex];
if (boundReference == null)
{
continue;
}
// add bound reference if it doesn't exist yet, merging aliases:
MetadataReference existingReference;
if (boundReferences.TryGetValue(boundReference, out existingReference))
{
if (CheckPropertiesConsistency(boundReference, existingReference, diagnostics))
{
AddAlias(existingReference, boundReference.Properties.Alias, ref aliasMap);
}
continue;
}
boundReferences.Add(boundReference, boundReference);
CommonLocation location;
if (referenceIndex < referenceDirectiveCount)
{
location = referenceDirectiveLocations[referenceIndex];
uniqueDirectiveReferences.Add(boundReference);
}
else
{
location = MessageProvider.NoLocation;
}
// compilation reference
var compilationReference = boundReference as CommonCompilationReference;
if (compilationReference != null)
{
switch (compilationReference.Properties.Kind)
{
case MetadataImageKind.Assembly:
existingReference = TryAddAssembly(compilationReference.Compilation.Assembly.Identity, boundReference, diagnostics, location, ref assemblyReferencesBySimpleName);
if (existingReference != null)
{
AddAlias(existingReference, boundReference.Properties.Alias, ref aliasMap);
continue;
}
// Note, if SourceAssemblySymbol hasn't been created for
// compilationAssembly.Compilation yet, we want this to happen
// right now. Conveniently, this constructor will trigger creation of the
// SourceAssemblySymbol.
var asmData = CreateAssemblyDataForCompilation(compilationReference);
AddAssembly(asmData, referenceIndex, assemblies, referenceMap);
break;
default:
throw Contract.Unreachable;
}
continue;
}
// PE reference
var peReference = (PortableExecutableReference)boundReference;
Metadata metadata = peReference.GetMetadata(MessageProvider, location, diagnostics);
Debug.Assert(metadata != null || diagnostics.HasAnyErrors());
if (metadata != null)
{
Debug.Assert(metadata != null);
switch (peReference.Properties.Kind)
{
case MetadataImageKind.Assembly:
var assemblyMetadata = (AssemblyMetadata)metadata;
WeakList <IAssemblySymbol> cachedSymbols = assemblyMetadata.CachedSymbols;
if (assemblyMetadata.IsValidAssembly())
{
Assembly assembly = assemblyMetadata.Assembly;
existingReference = TryAddAssembly(assembly.Identity, peReference, diagnostics, location, ref assemblyReferencesBySimpleName);
if (existingReference != null)
{
AddAlias(existingReference, boundReference.Properties.Alias, ref aliasMap);
continue;
}
var asmData = CreateAssemblyDataForFile(
assembly,
cachedSymbols,
peReference.GetDocumentationProvider(),
SimpleAssemblyName,
compilation.Options.AlwaysImportInternalMembers,
peReference.Properties.EmbedInteropTypes);
AddAssembly(asmData, referenceIndex, assemblies, referenceMap);
}
else
{
diagnostics.Add(MessageProvider.CreateDiagnostic(MessageProvider.ERR_MetadataFileNotAssembly, location, peReference.Display));
}
// asmData keeps strong ref after this point
GC.KeepAlive(assemblyMetadata);
break;
case MetadataImageKind.Module:
var moduleMetadata = (ModuleMetadata)metadata;
if (moduleMetadata.IsValidModule())
{
AddModule(moduleMetadata.Module, referenceIndex, modules, referenceMap);
}
else
{
diagnostics.Add(MessageProvider.CreateDiagnostic(MessageProvider.ERR_MetadataFileNotModule, location, peReference.Display));
}
break;
default:
throw Contract.Unreachable;
}
}
}
if (uniqueDirectiveReferences != null)
{
uniqueDirectiveReferences.Reverse();
boundReferenceDirectives = uniqueDirectiveReferences.ToReadOnlyAndFree();
}
else
{
boundReferenceDirectives = ReadOnlyArray <MetadataReference> .Empty;
}
for (int i = 0; i < referenceMap.Length; i++)
{
if (!referenceMap[i].IsSkipped)
{
int reversedIndex = (referenceMap[i].Kind == MetadataImageKind.Assembly ? assemblies.Count : modules.Count) - 1 - referenceMap[i].Index;
referenceMap[i] = new ResolvedReference(reversedIndex, referenceMap[i].Kind, GetAliases(references[i], aliasMap));
}
}
assemblies.Reverse();
modules.Reverse();
return(referenceMap.AsReadOnlyWrap());
}
