private MetadataAttributeValue DecodeValue(MetadataTypeReference type, object value)
{
if (value == null)
{
return(ConstantAttributeValue.Null);
}
if (type is PrimitiveTypeReference)
{
return(new ConstantAttributeValue(MetadataConstantValue.FromObject(value)));
}
if (value is MetadataTypeReference typeValue)
{
return(new TypeAttributeValue(typeValue));
}
if (type is ArrayTypeReference arrayType)
{
var items = (ImmutableArray <CustomAttributeTypedArgument <MetadataTypeReference> >)value;
var values = new MetadataAttributeValue[items.Length];
for (var i = 0; i < values.Length; i++)
{
var item = items[i];
values[i] = DecodeValue(item.Type, item.Value);
}
return(new ArrayAttributeValue(arrayType, values));
}
// The only other thing DecodeValue can give us is an enum
return(new EnumAttributeValue(type, MetadataConstantValue.FromObject(value)));
}
public ReaderParameter(MetadataReader reader, TypeReferenceTypeProvider typeProvider, Parameter definition, GenericContext genericContext, MetadataTypeReference parameterType)
{
this.reader = reader;
this.typeProvider = typeProvider;
this.definition = definition;
this.genericContext = genericContext;
ParameterType = parameterType;
}
public bool TryGetIsDelegateType(MetadataTypeReference typeReference, out bool isDelegateType)
{
if (TryGetCachedInfo(typeReference, out var cachedInfo))
{
isDelegateType = cachedInfo.IsDelegateType;
return(true);
}
isDelegateType = default;
return(false);
}
public bool TryGetEnumInfo(MetadataTypeReference typeReference, out EnumInfo info)
{
if (TryGetCachedInfo(typeReference, out var cachedInfo) && cachedInfo.EnumInfo != null)
{
info = cachedInfo.EnumInfo.Value;
return(true);
}
info = default;
return(false);
}
private bool ParameterIsNamedType(MetadataTypeReference type)
{
switch (type)
{
case TopLevelTypeReference _:
case NestedTypeReference _:
return(true);
case GenericInstantiationTypeReference instantiation:
return(ParameterIsNamedType(instantiation.TypeDefinition));
default:
return(false);
}
}
private bool TryGetCachedInfo(MetadataTypeReference typeReference, out CachedInfo cachedInfo)
{
var(assemblyReference, typeName) = NameSpec.FromMetadataTypeReference(typeReference);
if (assemblyReference == null)
{
if (currentAssemblyLoader == null)
{
currentAssemblyLoader = new AssemblyLazyLoader(currentAssemblyStreamFactory.Invoke());
}
if (currentAssemblyLoader.TryGetInfo(typeName, this, out cachedInfo))
{
return(true);
}
// Attribute values containing enum type references serialize the string.
// So far all mscorlib enum references I've seen include the assembly name,
// but this is just in case.
if (currentAssemblyMscorlibReference == null)
{
currentAssemblyMscorlibReference = GetMscorlibReference(currentAssemblyStreamFactory.Invoke());
}
assemblyReference = currentAssemblyMscorlibReference;
}
var fullName = assemblyReference.FullName;
if (!assemblyLoadersByFullName.TryGetValue(fullName, out var loader))
{
loader = assemblyResolver.TryGetAssemblyPath(assemblyReference, out var path) ? new AssemblyLazyLoader(File.OpenRead(path)) : null;
assemblyLoadersByFullName.Add(fullName, loader);
}
if (loader == null)
{
// We couldn't locate the assembly.
cachedInfo = default;
return(false);
}
return(loader.TryGetInfo(typeName, this, out cachedInfo));
}
public ManualMetadataAttribute(MetadataTypeReference attributeType)
{
AttributeType = attributeType ?? throw new ArgumentNullException(nameof(attributeType));
}
private void VisitTypeReference(TextNode referencePath, MetadataTypeReference type)
{
for (;;)
{
switch (type)
{
case TopLevelTypeReference topLevel:
VisitTypeName(referencePath, topLevel.Namespace, topLevel.Name, Array.Empty <string>());
return;
case NestedTypeReference nested:
for (var nestedNames = new List <string>(); ;)
{
nestedNames.Add(nested.Name);
if (nested.DeclaringType is NestedTypeReference next)
{
nested = next;
}
else
{
var topLevel = (TopLevelTypeReference)nested.DeclaringType;
nestedNames.Reverse();
VisitTypeName(referencePath, topLevel.Namespace, topLevel.Name, nestedNames);
return;
}
}
case GenericInstantiationTypeReference genericInstantiation:
foreach (var argument in genericInstantiation.GenericTypeArguments)
{
VisitTypeReference(referencePath, argument);
}
type = genericInstantiation.TypeDefinition;
continue;
case ArrayTypeReference array:
type = array.ElementType;
continue;
case ByRefTypeReference byref:
type = byref.ElementType;
continue;
case PointerTypeReference pointer:
type = pointer.ElementType;
continue;
case GenericParameterTypeReference genericParameter:
foreach (var constraint in genericParameter.TypeParameter.TypeConstraints)
{
VisitTypeReference(referencePath + " generic constraint", constraint);
}
return;
case PrimitiveTypeReference _:
return;
default:
throw new NotImplementedException();
}
}
}
public ByRefTypeReference(MetadataTypeReference elementType)
{
ElementType = elementType;
}
public NestedTypeReference(MetadataTypeReference declaringType, string name)
{
DeclaringType = declaringType;
Name = name;
}
public TypeAttributeValue(MetadataTypeReference value)
{
Value = value ?? throw new ArgumentNullException(nameof(value));
}
public static (MetadataAssemblyReference assemblyReference, NameSpec typeName) FromMetadataTypeReference(MetadataTypeReference typeReference)
{
if (typeReference is GenericInstantiationTypeReference genericInstantiation)
{
typeReference = genericInstantiation.TypeDefinition;
}
var nestedNames = (List <string>)null;
for (; typeReference is NestedTypeReference nested; typeReference = nested.DeclaringType)
{
if (nestedNames == null)
{
nestedNames = new List <string>();
}
nestedNames.Add(nested.Name);
}
nestedNames?.Reverse();
if (!(typeReference is TopLevelTypeReference topLevel))
{
throw new ArgumentException($"Type reference must either be a {nameof(TopLevelTypeReference)} or a {nameof(NestedTypeReference)}.", nameof(typeReference));
}
return(
topLevel.Assembly,
new NameSpec(
topLevel.Namespace,
topLevel.Name,
nestedNames?.ToArray()));
}
public PointerTypeReference(MetadataTypeReference elementType)
{
ElementType = elementType;
}
public ArrayTypeReference(MetadataTypeReference elementType, int rank)
{
ElementType = elementType;
Rank = rank;
}
public EnumAttributeValue(MetadataTypeReference enumType, IMetadataConstantValue underlyingValue)
{
EnumType = enumType ?? throw new ArgumentNullException(nameof(enumType));
UnderlyingValue = underlyingValue ?? throw new ArgumentNullException(nameof(underlyingValue));
}