private DumpTypeRef(DumpTypeRef other, GenericTypeMap genericTypes)
{
Namespace = other.Namespace;
Name = other.Name;
IsGenericInstance = true;
IsGenericTemplate = false;
var newGenerics = new List <TypeRef>(other.Generics.Count);
foreach (var genericParameter in other.Generics)
{
if (genericParameter.IsGeneric)
{
newGenerics.Add(genericParameter.MakeGenericInstance(genericTypes));
}
else if (genericTypes.TryGetValue(genericParameter, out var genericArgument))
{
newGenerics.Add(genericArgument);
}
else
{
throw new UnresolvedTypeException(genericParameter, other);
}
}
Generics = newGenerics;
OriginalDeclaringType = other.DeclaringType;
UnNested = other.UnNested;
ElementType = other.ElementType;
}
private TypeRef(
Resolver resolver,
AssemblyName assemblyName,
StrongAssemblyIdentity?assemblyId,
int metadataToken,
string fullName,
TypeRefFlags typeFlags,
int genericTypeParameterCount,
ImmutableArray <TypeRef> genericTypeArguments,
bool shallow,
ImmutableArray <TypeRef> baseTypes,
TypeRef?elementTypeRef)
{
Requires.NotNull(resolver, nameof(resolver));
Requires.NotNull(assemblyName, nameof(assemblyName));
Requires.Argument(((MetadataTokenType)metadataToken & MetadataTokenType.Mask) == MetadataTokenType.Type, "metadataToken", Strings.NotATypeSpec);
Requires.Argument(metadataToken != (int)MetadataTokenType.Type, "metadataToken", Strings.UnresolvableMetadataToken);
Requires.NotNullOrEmpty(fullName, nameof(fullName));
this.resolver = resolver;
this.AssemblyName = GetNormalizedAssemblyName(assemblyName);
this.assemblyId = assemblyId;
this.MetadataToken = metadataToken;
this.FullName = fullName;
this.TypeFlags = typeFlags;
this.GenericTypeParameterCount = genericTypeParameterCount;
this.GenericTypeArguments = genericTypeArguments;
if (!shallow)
{
this.baseTypes = baseTypes;
}
this.ElementTypeRef = elementTypeRef ?? this;
}
private TypeRef?Scramble(TypeRef?typeRef)
{
if (typeRef == null)
{
return(null);
}
if (!this.scrambledTypeRefs.TryGetValue(typeRef, out TypeRef? scrambled))
{
scrambled = TypeRef.Get(
this.resolver,
this.Scramble(typeRef.AssemblyId),
typeRef.MetadataToken,
typeRef.FullName,
typeRef.TypeFlags,
typeRef.GenericTypeParameterCount,
typeRef.GenericTypeArguments.Select(this.Scramble).ToImmutableArray() !,
typeRef.IsShallow,
typeRef.IsShallow ? ImmutableArray <TypeRef> .Empty : typeRef.BaseTypes.Select(this.Scramble).ToImmutableArray() !,
typeRef.ElementTypeRef);
this.scrambledTypeRefs.Add(typeRef, scrambled);
}
return(scrambled);
}
public ITypeData?Resolve(TypeRef?typeRef)
{
if (typeRef is null)
{
throw new ArgumentNullException(nameof(typeRef));
}
return(Resolve(typeRef.AsDllTypeRef));
}
private DumpTypeRef(DumpTypeRef other, string?nameOverride = null)
{
Namespace = other.Namespace;
Name = nameOverride ?? other.Name;
IsGenericInstance = other.IsGenericInstance;
IsGenericTemplate = other.IsGenericTemplate;
Generics = new List <TypeRef>(other.Generics);
DeclaringType = other.DeclaringType;
ElementType = other.ElementType;
}
public RuntimeExport(string contractName, TypeRef declaringTypeRef, MemberRef?memberRef, TypeRef?exportedValueTypeRef, IReadOnlyDictionary <string, object?> metadata)
{
Requires.NotNullOrEmpty(contractName, nameof(contractName));
Requires.NotNull(declaringTypeRef, nameof(declaringTypeRef));
Requires.NotNull(metadata, nameof(metadata));
this.ContractName = contractName;
this.DeclaringTypeRef = declaringTypeRef;
this.MemberRef = memberRef;
this.exportedValueTypeRef = exportedValueTypeRef;
this.Metadata = metadata;
}
internal DumpTypeRef(string @namespace, string typeName)
{
Namespace = @namespace;
var GenericTypes = new List <TypeRef>();
if (typeName.EndsWith(">") && !typeName.StartsWith("<"))
{
var ind = typeName.IndexOf("<");
var types = typeName.Substring(ind + 1, typeName.Length - ind - 2);
var spl = types.Split(new string[] { ", " }, StringSplitOptions.None);
for (int i = 0; i < spl.Length;)
{
string s = spl[i];
int unclosed = s.Count(c => c == '<');
unclosed -= s.Count(c => c == '>');
i++;
while (unclosed > 0)
{
unclosed += spl[i].Count(c => c == '<');
unclosed -= spl[i].Count(c => c == '>');
s += ", " + spl[i];
i++;
}
// TODO: if this DumpTypeRef is the This for a DumpTypeData, mark these IsGenericParameter. "out" is not in dump.cs.
GenericTypes.Add(new DumpTypeRef(s));
}
}
Generics = GenericTypes;
// TODO: check that this gives correct results
if (string.IsNullOrEmpty(@namespace))
{
IsGenericInstance = true;
}
else
{
IsGenericTemplate = true;
}
var declInd = typeName.LastIndexOf('.');
if (declInd != -1)
{
// Create a new TypeRef for the declaring type, it should recursively create more declaring types
OriginalDeclaringType = new DumpTypeRef(typeName.Substring(0, declInd));
// TODO: need to resolve DeclaringType before this will make sense?
Namespace = OriginalDeclaringType.Namespace;
}
Name = typeName.Replace('.', '/');
if (IsArray())
{
ElementType = new DumpTypeRef(Name[0..^ 2]);
/// <summary>
/// Gets a type color
/// </summary>
/// <param name="type">Type</param>
/// <returns></returns>
public virtual object GetColor(TypeRef?type)
{
if (type is null)
{
return(BoxedTextColor.Text);
}
var td = type.Resolve();
if (!(td is null))
{
return(GetColor(td));
}
return(BoxedTextColor.Type);
}
private bool Equals(TypeRef?other, bool allowMvidMismatch)
{
if (other == null)
{
return(false);
}
// If we ever stop comparing metadata tokens,
// we would need to compare the other properties that describe this member.
bool result = this.MetadataToken == other.MetadataToken &&
this.AssemblyId.Equals(other.AssemblyId, allowMvidMismatch) &&
this.IsArray == other.IsArray &&
this.GenericTypeParameterCount == other.GenericTypeParameterCount &&
EqualsByValue(this.GenericTypeArguments, other.GenericTypeArguments, allowMvidMismatch) &&
this.IsShallow == other.IsShallow;
return(result);
// TODO: Ensure this behaves as intended for recursive DeclaringTypes (it probably does not)
public bool Equals(TypeRef?x, TypeRef?y)
{
if (x is null || y is null)
{
return(x is null == y is null);
}
if (x.Namespace != y.Namespace || x.Name != y.Name)
{
return(false);
}
if (x.IsGeneric && y.IsGeneric)
{
// If both x and y are generic
if (x.IsGenericInstance == y.IsGenericInstance || x.IsGenericTemplate == y.IsGenericTemplate)
{
// If they are both an instance or both a template, return sequence equal
return(x.Generics is null ? y.Generics is null : x.Generics.SequenceEqual(y.Generics, this));
}
// Otherwise, if one is a template and the other is an instance, if their counts match, consider it good enough.
return(x.Generics is null ? y.Generics is null : x.Generics.Count == y.Generics.Count);
}
return(true);
}
protected void WriteObject(object?value)
{
if (value == null)
{
using (this.Trace("Object"))
{
this.Write(ObjectType.Null);
}
}
else
{
Type valueType = value.GetType();
using (this.Trace("Object"))
{
if (valueType.IsArray)
{
Array array = (Array)value;
this.Write(ObjectType.Array);
TypeRef?elementTypeRef = TypeRef.Get(valueType.GetElementType(), this.Resolver);
this.Write(elementTypeRef);
this.Write(array, this.WriteObject);
}
else if (valueType == typeof(bool))
{
this.Write((bool)value ? ObjectType.BoolTrue : ObjectType.BoolFalse);
}
else if (valueType == typeof(string))
{
this.Write(ObjectType.String);
this.Write((string)value);
}
else if (valueType == typeof(long))
{
this.Write(ObjectType.Int64);
this.writer.Write((long)value);
}
else if (valueType == typeof(ulong))
{
this.Write(ObjectType.UInt64);
this.writer.Write((ulong)value);
}
else if (valueType == typeof(int))
{
this.Write(ObjectType.Int32);
this.writer.Write((int)value);
}
else if (valueType == typeof(uint))
{
this.Write(ObjectType.UInt32);
this.writer.Write((uint)value);
}
else if (valueType == typeof(short))
{
this.Write(ObjectType.Int16);
this.writer.Write((short)value);
}
else if (valueType == typeof(ushort))
{
this.Write(ObjectType.UInt16);
this.writer.Write((ushort)value);
}
else if (valueType == typeof(byte))
{
this.Write(ObjectType.Byte);
this.writer.Write((byte)value);
}
else if (valueType == typeof(sbyte))
{
this.Write(ObjectType.SByte);
this.writer.Write((sbyte)value);
}
else if (valueType == typeof(float))
{
this.Write(ObjectType.Single);
this.writer.Write((float)value);
}
else if (valueType == typeof(double))
{
this.Write(ObjectType.Double);
this.writer.Write((double)value);
}
else if (valueType == typeof(char))
{
this.Write(ObjectType.Char);
this.writer.Write((char)value);
}
else if (valueType == typeof(Guid))
{
this.Write(ObjectType.Guid);
this.Write((Guid)value);
}
else if (valueType == typeof(CreationPolicy)) // TODO: how do we handle arbitrary value types?
{
this.Write(ObjectType.CreationPolicy);
this.writer.Write((byte)(CreationPolicy)value);
}
else if (typeof(Type).GetTypeInfo().IsAssignableFrom(valueType))
{
this.Write(ObjectType.Type);
this.Write(TypeRef.Get((Type)value, this.Resolver));
}
else if (typeof(TypeRef) == valueType)
{
this.Write(ObjectType.TypeRef);
this.Write((TypeRef)value);
}
else if (typeof(LazyMetadataWrapper.Enum32Substitution) == valueType)
{
var substValue = (LazyMetadataWrapper.Enum32Substitution)value;
this.Write(ObjectType.Enum32Substitution);
this.Write(substValue.EnumType);
this.writer.Write(substValue.RawValue);
}
else if (typeof(LazyMetadataWrapper.TypeSubstitution) == valueType)
{
var substValue = (LazyMetadataWrapper.TypeSubstitution)value;
this.Write(ObjectType.TypeSubstitution);
this.Write(substValue.TypeRef);
}
else if (typeof(LazyMetadataWrapper.TypeArraySubstitution) == valueType)
{
var substValue = (LazyMetadataWrapper.TypeArraySubstitution)value;
this.Write(ObjectType.TypeArraySubstitution);
this.Write(substValue.TypeRefArray, this.Write);
}
else
{
Debug.WriteLine("Falling back to binary formatter for value of type: {0}", valueType);
this.Write(ObjectType.BinaryFormattedObject);
var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
this.writer.Flush();
formatter.Serialize(this.writer.BaseStream, value);
}
}
}
}
protected object?ReadObject()
{
using (this.Trace(nameof(Object)))
{
ObjectType objectType = this.ReadObjectType();
switch (objectType)
{
case ObjectType.Null:
return(null);
case ObjectType.Array:
Type?elementType = this.ReadTypeRef().Resolve();
return(this.ReadArray(this.reader, this.readObjectDelegate, elementType));
case ObjectType.BoolTrue:
return(true);
case ObjectType.BoolFalse:
return(false);
case ObjectType.Int64:
return(this.reader.ReadInt64());
case ObjectType.UInt64:
return(this.reader.ReadUInt64());
case ObjectType.Int32:
return(this.reader.ReadInt32());
case ObjectType.UInt32:
return(this.reader.ReadUInt32());
case ObjectType.Int16:
return(this.reader.ReadInt16());
case ObjectType.UInt16:
return(this.reader.ReadUInt16());
case ObjectType.Byte:
return(this.reader.ReadByte());
case ObjectType.SByte:
return(this.reader.ReadSByte());
case ObjectType.Single:
return(this.reader.ReadSingle());
case ObjectType.Double:
return(this.reader.ReadDouble());
case ObjectType.String:
return(this.ReadString());
case ObjectType.Char:
return(this.reader.ReadChar());
case ObjectType.Guid:
return(this.ReadGuid());
case ObjectType.CreationPolicy:
return((CreationPolicy)this.reader.ReadByte());
case ObjectType.Type:
return(this.ReadTypeRef().Resolve());
case ObjectType.TypeRef:
return(this.ReadTypeRef());
case ObjectType.Enum32Substitution:
TypeRef?enumType = this.ReadTypeRef();
int rawValue = this.reader.ReadInt32();
return(new LazyMetadataWrapper.Enum32Substitution(enumType, rawValue));
case ObjectType.TypeSubstitution:
TypeRef?typeRef = this.ReadTypeRef();
return(new LazyMetadataWrapper.TypeSubstitution(typeRef));
case ObjectType.TypeArraySubstitution:
IReadOnlyList <TypeRef?> typeRefArray = this.ReadList(this.reader, this.readTypeRefDelegate);
return(new LazyMetadataWrapper.TypeArraySubstitution(typeRefArray !, this.Resolver));
case ObjectType.BinaryFormattedObject:
var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
return(formatter.Deserialize(this.reader.BaseStream));
default:
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedFormat, objectType));
}
}
}
public void Local()
{
TypeRef?local = null;
DoNothing(ref local);
}
public static TypeRef Get(Resolver resolver, StrongAssemblyIdentity assemblyId, int metadataToken, string fullName, TypeRefFlags typeFlags, int genericTypeParameterCount, ImmutableArray <TypeRef> genericTypeArguments, bool shallow, ImmutableArray <TypeRef> baseTypes, TypeRef?elementTypeRef)
{
return(new TypeRef(resolver, assemblyId.Name, assemblyId, metadataToken, fullName, typeFlags, genericTypeParameterCount, genericTypeArguments, shallow, baseTypes, elementTypeRef));
}
public static Type?Resolve(this TypeRef?typeRef)
{
return(typeRef?.ResolvedType);
}
public static TypeRef Get(Resolver resolver, AssemblyName assemblyName, int metadataToken, string fullName, TypeRefFlags typeFlags, int genericTypeParameterCount, ImmutableArray <TypeRef> genericTypeArguments, bool shallow, ImmutableArray <TypeRef> baseTypes, TypeRef?elementTypeRef)
{
Requires.NotNull(resolver, nameof(resolver));
return(new TypeRef(resolver, assemblyName, null, metadataToken, fullName, typeFlags, genericTypeParameterCount, genericTypeArguments, shallow, baseTypes, elementTypeRef));
}
public bool Equals(TypeRef?other) => this.Equals(other, allowMvidMismatch: false);
