public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
if (reference.StartsWith("nuget:", StringComparison.OrdinalIgnoreCase))
{
// HACK We need to return something here to "mark" the reference as resolved.
// https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs#L838
return(ImmutableArray <PortableExecutableReference> .Empty.Add(
MetadataReference.CreateFromFile(typeof(NuGetMetadataReferenceResolver).GetTypeInfo().Assembly.Location)));
}
if (_cache == null)
{
return(_innerReferenceResolver.ResolveReference(reference, baseFilePath, properties));
}
if (_cache.TryGetValue(reference, out var result))
{
return(result);
}
result = _innerReferenceResolver.ResolveReference(reference, baseFilePath, properties);
if (!result.IsDefaultOrEmpty)
{
_cache.TryAdd(reference, result);
}
return(result);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
if (reference == null)
{
return(ImmutableArray <PortableExecutableReference> .Empty);
}
if (!HasValidAssemblyFileExtension(reference))
{
// Try to resolve using the default resolver (framework assemblies, e.g. System.Core, System.Xml, etc.)
ImmutableArray <PortableExecutableReference> result = _scriptResolver.ResolveReference(reference, baseFilePath, properties);
// If the default script resolver can't resolve the assembly
// check if this is one of host's shared assemblies
if (result.IsEmpty)
{
Assembly assembly = null;
if (SharedAssemblyProviders.Any(p => p.TryResolveAssembly(reference, AssemblyLoadContext.Default, _logger, out assembly)) ||
_extensionSharedAssemblyProvider.TryResolveAssembly(reference, AssemblyLoadContext.Default, _logger, out assembly))
{
result = ImmutableArray.Create(MetadataReference.CreateFromFile(assembly.Location));
}
}
return(result);
}
return(GetMetadataFromReferencePath(reference));
}
protected IEnumerable <MetadataReference> ResolveReferences(MetadataReferenceResolver metadataReferenceResolver)
{
List <MetadataReference> references = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)
};
foreach (MetadataReference reference in MetadataReferences)
{
UnresolvedMetadataReference unresolved = reference as UnresolvedMetadataReference;
if (unresolved != null)
{
ImmutableArray <PortableExecutableReference> resolved =
metadataReferenceResolver.ResolveReference(unresolved.Reference, null, unresolved.Properties);
references.AddRange(resolved);
}
else
{
references.Add(reference);
}
}
return(references);
}
AssemblySymbol CreateAssemblyFromIdentity(MetadataReferenceResolver resolver, AssemblyIdentity identity, string basePath, List <PEModuleSymbol> modules)
{
if (!_observedMetadata.TryGetValue(identity, out var ass))
{
// temporary: lookup ignoring version number
foreach (var pair in _observedMetadata)
{
if (IsIdentitySimilar(pair.Key, identity))
{
_observedMetadata[identity] = pair.Value; // do not resolve this ever again
return(pair.Value);
}
}
//foreach (var m in modules)
//{
// if (IsIdentitySimilar(m.ContainingAssembly.Identity, identity))
// {
// return m.ContainingAssembly as PEAssemblySymbol;
// }
//}
//
if (resolver != null)
{
string keytoken = string.Join("", identity.PublicKeyToken.Select(b => b.ToString("x2")));
var pes = resolver.ResolveReference(identity.Name + ".dll", basePath, MetadataReferenceProperties.Assembly)
.Concat(resolver.ResolveReference($"{identity.Name}/v4.0_{identity.Version}__{keytoken}/{identity.Name}.dll", basePath, MetadataReferenceProperties.Assembly));
var pe = pes.FirstOrDefault();
if (pe != null)
{
_observedMetadata[identity] = ass = PEAssemblySymbol.Create(pe, isLinked: false);
ass.SetCorLibrary(_lazyCorLibrary);
modules.AddRange(ass.Modules.Cast <PEModuleSymbol>());
}
}
if (ass == null)
{
//_diagnostics.Add(Location.None, Errors.ErrorCode.ERR_MetadataFileNotFound, identity);
return(new MissingAssemblySymbol(identity));
}
}
return(ass);
}
AssemblySymbol CreateAssemblyFromIdentity(MetadataReferenceResolver resolver, AssemblyIdentity identity, string basePath, List <PEModuleSymbol> modules)
{
PEAssemblySymbol ass;
if (!_observedMetadata.TryGetValue(identity, out ass))
{
// temporary: lookup ignoring minor version number
foreach (var pair in _observedMetadata)
{
// TODO: _identityComparer
if (pair.Key.Name.Equals(identity.Name, StringComparison.OrdinalIgnoreCase) &&
(pair.Key.Version.Major == identity.Version.Major || identity.Version == new Version(0, 0, 0, 0)))
{
_observedMetadata[identity] = pair.Value;
return(pair.Value);
}
}
//
if (resolver != null)
{
string keytoken = string.Join("", identity.PublicKeyToken.Select(b => b.ToString("x2")));
var pes = resolver.ResolveReference(identity.Name + ".dll", basePath, MetadataReferenceProperties.Assembly)
.Concat(resolver.ResolveReference($"{identity.Name}/v4.0_{identity.Version}__{keytoken}/{identity.Name}.dll", basePath, MetadataReferenceProperties.Assembly));
var pe = pes.FirstOrDefault();
if (pe != null)
{
_observedMetadata[identity] = ass = PEAssemblySymbol.Create(pe, isLinked: false);
ass.SetCorLibrary(_lazyCorLibrary);
modules.AddRange(ass.Modules.Cast <PEModuleSymbol>());
}
}
if (ass == null)
{
//_diagnostics.Add(Location.None, Errors.ErrorCode.ERR_MetadataFileNotFound, identity);
return(new MissingAssemblySymbol(identity));
}
}
return(ass);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
if (reference.StartsWith("nuget", StringComparison.OrdinalIgnoreCase))
{
// HACK We need to return something here to "mark" the reference as resolved.
// https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs#L838
return(ImmutableArray <PortableExecutableReference> .Empty.Add(
MetadataReference.CreateFromFile(typeof(string).GetTypeInfo().Assembly.Location)));
}
var resolvedReference = metadataReferenceResolver.ResolveReference(reference, baseFilePath, properties);
return(resolvedReference);
}
PEAssemblySymbol CreateAssemblyFromIdentity(MetadataReferenceResolver resolver, AssemblyIdentity identity, string basePath, List <PEModuleSymbol> modules)
{
PEAssemblySymbol ass;
if (!_observedMetadata.TryGetValue(identity, out ass))
{
// temporary: lookup ignoring minor version number
foreach (var pair in _observedMetadata)
{
// TODO: _identityComparer
if (pair.Key.Name.Equals(identity.Name, StringComparison.OrdinalIgnoreCase) && pair.Key.Version.Major == identity.Version.Major)
{
_observedMetadata[identity] = pair.Value;
return(pair.Value);
}
}
//
string keytoken = string.Join("", identity.PublicKeyToken.Select(b => b.ToString("x2")));
var pes = resolver.ResolveReference(identity.Name + ".dll", basePath, MetadataReferenceProperties.Assembly)
.Concat(resolver.ResolveReference($"{identity.Name}/v4.0_{identity.Version}__{keytoken}/{identity.Name}.dll", basePath, MetadataReferenceProperties.Assembly));
var pe = pes.FirstOrDefault();
if (pe != null)
{
_observedMetadata[identity] = ass = PEAssemblySymbol.Create(pe);
ass.SetCorLibrary(_lazyCorLibrary);
modules.AddRange(ass.Modules.Cast <PEModuleSymbol>());
}
else
{
// TODO: diagnostics
throw new DllNotFoundException(identity.GetDisplayName());
}
}
return(ass);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
var key = $"{reference}-{baseFilePath}";
if (DirectReferenceCache.TryGetValue(key, out var result))
{
return(result);
}
result = DefaultRuntimeResolver.ResolveReference(reference, baseFilePath, properties);
if (result.Length > 0)
{
DirectReferenceCache[key] = result;
}
return(result);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
string cacheKey = $"{reference}:{baseFilePath}";
if (_referenceCache.TryGetValue(cacheKey, out ImmutableArray <PortableExecutableReference> result))
{
return(result);
}
result = _innerResolver.ResolveReference(reference, baseFilePath, properties);
if (result.Length > 0)
{
_referenceCache[cacheKey] = result;
}
return(result);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
var key = $"{reference}-{baseFilePath}";
if (DirectReferenceCache.ContainsKey(key))
{
return(DirectReferenceCache[key]);
}
var result = _defaultReferenceResolver.ResolveReference(reference, baseFilePath, properties);
if (result.Length > 0)
{
DirectReferenceCache[key] = result;
}
return(result);
}
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
// Check the previous resolver
var result = previousResolver.ResolveReference(reference, baseFilePath, properties);
if (result.Length > 0)
{
return(result);
}
// Try to use file resolver
string path = ResolvePath(reference, baseFilePath);
if (!string.IsNullOrEmpty(path))
{
return(ImmutableArray.Create(MetadataReference.CreateFromFile(path, properties)));
}
return(ImmutableArray <PortableExecutableReference> .Empty);
}
/// <summary>
/// Resolves the reference.
/// </summary>
/// <param name="reference">The reference.</param>
/// <param name="baseFilePath">The base file path.</param>
/// <param name="properties">The properties.</param>
/// <returns></returns>
public override ImmutableArray <PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)
{
// Check if we are referencing CodeGen assembly
ImportUserTypeAssembly codeGenAssembly;
if (codeGenAssemblies.TryGetValue(reference, out codeGenAssembly))
{
using (MemoryStream stream = new MemoryStream(codeGenAssembly.AssemblyBytes))
{
return(ImmutableArray.Create(MetadataReference.CreateFromStream(stream, properties, null, codeGenAssembly.AssemblyPath)));
}
}
// Check the previous resolver
var result = previousResolver.ResolveReference(reference, baseFilePath, properties);
if (result.Length > 0)
{
return(result);
}
// Try to use file resolver
try
{
string path = ResolvePath(reference, baseFilePath);
if (!string.IsNullOrEmpty(path))
{
return(ImmutableArray.Create(MetadataReference.CreateFromFile(path, properties)));
}
}
catch
{
}
// Check if reference holds xml for CodeGen
ImportUserTypeOptions options = ImportUserTypeOptions.ParseString(reference);
if (options != null)
{
foreach (ImportUserTypeAssembly assembly in codeGenAssemblies.Values)
{
if (assembly.Options.Equals(options))
{
// TODO: Compare that used PDBs have same GUID.
codeGenAssembly = assembly;
break;
}
}
if (codeGenAssembly == null)
{
codeGenAssembly = GenerateAssembly(options);
AddAssembly(codeGenAssembly);
}
using (MemoryStream stream = new MemoryStream(codeGenAssembly.AssemblyBytes))
{
return(ImmutableArray.Create(MetadataReference.CreateFromStream(stream, properties, null, codeGenAssembly.AssemblyPath)));
}
}
return(ImmutableArray <PortableExecutableReference> .Empty);
}