protected override void ScanCore(MemberImportingOptions options, List<MemberImporter> importList)
{
//Type
var type = (TypeSpecification)Member;
//Checks if the type is a generic instance type
MemberImporter importer;
if (type is GenericInstanceType)
{
importer = new GenericInstanceTypeImporter(type, Session.Destination, Session).Scan(options);
importList.Add(importer);
importer.ImportFinished += t => retType = (TypeSpecification)t;
return;
}
//Creates the importer for the element type
importer = Helpers.CreateTypeImporter(type.ElementType, Session, importList, options);
//Switches on the metadata type of the specification
switch (type.MetadataType)
{
case MetadataType.Pointer:
importer.ImportFinished += t => retType = new PointerType((TypeReference)t);
break;
case MetadataType.ByReference:
importer.ImportFinished += t => retType = new ByReferenceType((TypeReference)t);
break;
default:
throw new NotImplementedException();
}
}
private static bool AreSame(TypeSpecification a, TypeSpecification b)
{
if (!TypeMatch(a.ElementType, b.ElementType))
return false;
if (a.IsGenericInstance)
{
if (!b.IsGenericInstance)
return false;
return AreSame((GenericInstanceType)a, (GenericInstanceType)b);
}
if (a.IsRequiredModifier || a.IsOptionalModifier)
return AreSame((IModifierType)a, (IModifierType)b);
if (a.IsArray)
{
if (!b.IsArray)
return false;
return AreSame((ArrayType)a, (ArrayType)b);
}
return true;
}
static bool TypeMatch(TypeSpecification a, TypeSpecification b)
{
if (a.IsGenericInstance)
return TypeMatch((GenericInstanceType)a, (GenericInstanceType)b);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return TypeMatch((IModifierType)a, (IModifierType)b);
return TypeMatch(a.ElementType, b.ElementType);
}
static bool TypeMatch(TypeSpecification a, TypeSpecification b, ref Dictionary<string, string> gp)
{
var gita = a as GenericInstanceType;
if (gita != null)
return TypeMatch(gita, (GenericInstanceType)b, ref gp);
var mta = a as IModifierType;
if (mta != null)
return TypeMatch(mta, (IModifierType)b, ref gp);
return TypeMatch(a.ElementType, b.ElementType, ref gp);
}
private void UpdateSpecification(bool allow, TypeSpecification specification)
{
foreach (var tslevel in new[] {TypeSpecificationL1, TypeSpecificationL2, TypeSpecificationL3})
{
if (allow && !tslevel.Items.Contains(specification))
{
tslevel.Items.Add(specification);
}
else if (!allow && tslevel.Items.Contains(specification))
{
tslevel.Items.Remove(specification);
}
}
}
public static bool IsEqualTo(this TypeSpecification a, TypeSpecification b)
{
if (!IsEqualTo(a.ElementType, b.ElementType)) {
return false;
}
if (a.IsGenericInstance) {
return IsEqualTo((GenericInstanceType)a, (GenericInstanceType)b);
}
if (a.IsRequiredModifier || a.IsOptionalModifier) {
return IsEqualTo((IModifierType)a, (IModifierType)b);
}
if (a.IsArray) {
return IsEqualTo((ArrayType)a, (ArrayType)b);
}
return true;
}
internal bool AreSame(TypeSpecification a, TypeSpecification b)
{
if (!AreSame(a.ElementType, b.ElementType))
return false;
if (a.IsGenericInstance)
return AreSame((GenericInstanceType)a, (GenericInstanceType)b);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return AreSame((IModifierType)a, (IModifierType)b);
if (a.IsArray)
return AreSame((ArrayType)a, (ArrayType)b);
return true;
}
TypeSpecification GetTypeSpec (TypeSpecification original, ImportContext context)
{
TypeSpecification typeSpec;
TypeReference elementType = ImportTypeReference (original.ElementType, context);
if (original is PointerType) {
typeSpec = new PointerType (elementType);
} else if (original is ArrayType) { // deal with complex arrays
typeSpec = new ArrayType (elementType);
} else if (original is ReferenceType) {
typeSpec = new ReferenceType (elementType);
} else if (original is GenericInstanceType) {
GenericInstanceType git = original as GenericInstanceType;
GenericInstanceType genElemType = new GenericInstanceType (elementType);
context.GenericContext.CheckProvider (genElemType.GetOriginalType (), git.GenericArguments.Count);
foreach (TypeReference arg in git.GenericArguments)
genElemType.GenericArguments.Add (ImportTypeReference (arg, context));
typeSpec = genElemType;
} else if (original is ModifierOptional) {
TypeReference mt = (original as ModifierOptional).ModifierType;
typeSpec = new ModifierOptional (elementType, ImportTypeReference (mt, context));
} else if (original is ModifierRequired) {
TypeReference mt = (original as ModifierRequired).ModifierType;
typeSpec = new ModifierRequired (elementType, ImportTypeReference (mt, context));
} else if (original is SentinelType) {
typeSpec = new SentinelType (elementType);
} else if (original is FunctionPointerType) {
FunctionPointerType ori = original as FunctionPointerType;
FunctionPointerType fnptr = new FunctionPointerType (
ori.HasThis,
ori.ExplicitThis,
ori.CallingConvention,
new MethodReturnType (ImportTypeReference (ori.ReturnType.ReturnType, context)));
foreach (ParameterDefinition parameter in ori.Parameters)
fnptr.Parameters.Add (new ParameterDefinition (ImportTypeReference (parameter.ParameterType, context)));
typeSpec = fnptr;
} else
throw new ReflectionException ("Unknown element type: {0}", original.GetType ().Name);
return typeSpec;
}
static bool AreSame(TypeSpecification a, TypeSpecification b)
{
if (!AreSame(a.ElementType, b.ElementType))
{
return(false);
}
if (a.IsGenericInstance)
{
return(AreSame((GenericInstanceType)a, (GenericInstanceType)b));
}
if (a.IsRequiredModifier || a.IsOptionalModifier)
{
return(AreSame((IModifierType)a, (IModifierType)b));
}
if (a.IsArray)
{
return(AreSame((ArrayType)a, (ArrayType)b));
}
return(true);
}
internal Type ResolveTypeSpecification(TypeSpecification typeSpecification)
{
Type elementType = ResolveType(typeSpecification.ElementType);
ArrayType arrayType = typeSpecification as ArrayType;
if (arrayType != null)
{
if (arrayType.IsSizedArray)
return elementType.MakeArrayType();
return elementType.MakeArrayType(arrayType.Rank);
}
GenericInstanceType genericInstanceType = typeSpecification as GenericInstanceType;
if (genericInstanceType != null)
{
Type[] args = ResolveTypes(genericInstanceType.GenericArguments);
return elementType.MakeGenericType(args);
}
ReferenceType referenceType = typeSpecification as ReferenceType;
if (referenceType != null)
{
return elementType.MakeByRefType();
}
PointerType pointerType = typeSpecification as PointerType;
if (pointerType != null)
{
return elementType.MakePointerType();
}
FunctionPointerType functionPointerType = typeSpecification as FunctionPointerType;
PinnedType pinnedType = typeSpecification as PinnedType;
ModifierOptional modifierOptional = typeSpecification as ModifierOptional;
ModifierRequired modifierRequired = typeSpecification as ModifierRequired;
SentinelType sentinelType = typeSpecification as SentinelType;
throw new NotImplementedException();
}
TypeSpecification GetTypeSpec(TypeSpecification original, ImportContext context)
{
TypeSpecification typeSpec;
TypeReference elementType = ImportTypeReference(original.ElementType, context);
if (original is PointerType)
{
typeSpec = new PointerType(elementType);
}
else if (original is ArrayType) // deal with complex arrays
{
typeSpec = new ArrayType(elementType);
}
else if (original is ReferenceType)
{
typeSpec = new ReferenceType(elementType);
}
else if (original is GenericInstanceType)
{
GenericInstanceType git = original as GenericInstanceType;
GenericInstanceType genElemType = new GenericInstanceType(elementType);
context.GenericContext.CheckProvider(genElemType.GetOriginalType(), git.GenericArguments.Count);
foreach (TypeReference arg in git.GenericArguments)
{
genElemType.GenericArguments.Add(ImportTypeReference(arg, context));
}
typeSpec = genElemType;
}
else if (original is ModifierOptional)
{
TypeReference mt = (original as ModifierOptional).ModifierType;
typeSpec = new ModifierOptional(elementType, ImportTypeReference(mt, context));
}
else if (original is ModifierRequired)
{
TypeReference mt = (original as ModifierRequired).ModifierType;
typeSpec = new ModifierRequired(elementType, ImportTypeReference(mt, context));
}
else if (original is SentinelType)
{
typeSpec = new SentinelType(elementType);
}
else if (original is FunctionPointerType)
{
FunctionPointerType ori = original as FunctionPointerType;
FunctionPointerType fnptr = new FunctionPointerType(
ori.HasThis,
ori.ExplicitThis,
ori.CallingConvention,
new MethodReturnType(ImportTypeReference(ori.ReturnType.ReturnType, context)));
foreach (ParameterDefinition parameter in ori.Parameters)
{
fnptr.Parameters.Add(new ParameterDefinition(ImportTypeReference(parameter.ParameterType, context)));
}
typeSpec = fnptr;
}
else
{
throw new ReflectionException("Unknown element type: {0}", original.GetType().Name);
}
return(typeSpec);
}
private static void AppendTypeSpecification(TypeSpecification type, StringBuilder name)
{
ArrayType arrayType;
int i;
StringBuilder stringBuilder;
StringBuilder stringBuilder1;
StringBuilder stringBuilder2;
StringBuilder stringBuilder3;
if (type.ElementType.IsTypeSpecification())
{
TypeParser.AppendTypeSpecification((TypeSpecification)type.ElementType, name);
}
ElementType elementType = type.etype;
switch (elementType)
{
case ElementType.Ptr:
{
name.Append('*');
return;
}
case ElementType.ByRef:
{
name.Append('&');
return;
}
case ElementType.ValueType:
case ElementType.Class:
case ElementType.Var:
{
return;
}
case ElementType.Array:
{
arrayType = (ArrayType)type;
if (arrayType.IsVector)
{
stringBuilder = name.Append("[]");
return;
}
stringBuilder1 = name.Append('[');
for (i = 1; i < arrayType.Rank; i++)
{
stringBuilder2 = name.Append(',');
}
stringBuilder3 = name.Append(']');
return;
}
case ElementType.GenericInst:
{
Collection <TypeReference> genericArguments = ((GenericInstanceType)type).GenericArguments;
name.Append('[');
for (int j = 0; j < genericArguments.Count; j++)
{
if (j > 0)
{
name.Append(',');
}
TypeReference item = genericArguments[j];
bool scope = item.Scope != item.Module;
if (scope)
{
name.Append('[');
}
TypeParser.AppendType(item, name, true, false);
if (scope)
{
name.Append(']');
}
}
name.Append(']');
return;
}
default:
{
if (elementType == ElementType.SzArray)
{
arrayType = (ArrayType)type;
if (arrayType.IsVector)
{
stringBuilder = name.Append("[]");
return;
}
stringBuilder1 = name.Append('[');
for (i = 1; i < arrayType.Rank; i++)
{
stringBuilder2 = name.Append(',');
}
stringBuilder3 = name.Append(']');
return;
}
return;
}
}
}
private void UpdateSpecification(bool allow, TypeSpecification specification)
{
if (allow && !TypeSpecification.Items.Contains(specification))
{
TypeSpecification.Items.Add(specification);
}
else if (!allow && TypeSpecification.Items.Contains(specification))
{
TypeSpecification.Items.Remove(specification);
}
}
private TypeSpecification Fix(TypeSpecification type, IGenericParameterProvider context)
{
var fet = Fix(type.ElementType, context);
if (type is ArrayType)
{
var array = (ArrayType)type;
var imported_array = new ArrayType(fet);
if (array.IsVector)
return imported_array;
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions[i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return imported_array;
}
if (type is PointerType)
return new PointerType(fet);
if (type is ByReferenceType)
return new ByReferenceType(fet);
if (type is PinnedType)
return new PinnedType(fet);
if (type is SentinelType)
return new SentinelType(fet);
if (type is OptionalModifierType)
{
TypeReference fmt = Fix(((OptionalModifierType)type).ModifierType, context);
return new OptionalModifierType(fmt, fet);
}
if (type is RequiredModifierType)
{
TypeReference fmt = Fix(((RequiredModifierType)type).ModifierType);
return new RequiredModifierType(fmt, fet);
}
if (type is GenericInstanceType)
{
var instance = (GenericInstanceType)type;
var imported_instance = new GenericInstanceType(fet);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add(Fix(arguments[i], context));
return imported_instance;
}
// TODO: what about FunctionPointerType?
throw new InvalidOperationException();
}
protected override void WriteTypeSpecification(TypeSpecification typeSpecification, int startingArgument = 0)
{
if (isDynamicEnumerator != null && !typeSpecification.IsGenericInstance)
{
if (typeSpecification.IsArray)
{
TypeReference currentTypeRef = typeSpecification;
while (currentTypeRef.IsArray)
{
if (!isDynamicEnumerator.MoveNext() || (bool)isDynamicEnumerator.Current)
{
throw new Exception("Invalid argument type for DynamicAttribute");
}
currentTypeRef = (currentTypeRef as ArrayType).ElementType;
}
}
else if (!isDynamicEnumerator.MoveNext() || (bool)isDynamicEnumerator.Current)
{
throw new Exception("Invalid argument type for DynamicAttribute");
}
}
if (typeSpecification.IsRequiredModifier || typeSpecification.IsOptionalModifier)
{
WriteModifier(typeSpecification);
return;
}
base.WriteTypeSpecification(typeSpecification, startingArgument);
}
static bool TypeMatch (TypeSpecification a, TypeSpecification b)
{
var gita = a as GenericInstanceType;
if (gita != null)
return TypeMatch (gita, (GenericInstanceType) b);
var mta = a as IModifierType;
if (mta != null)
return TypeMatch (mta, (IModifierType) b);
return TypeMatch (a.ElementType, b.ElementType);
}
public TypeSpecificationImporter(TypeSpecification type, MemberImportingSession session)
: base(type, session)
{
}
private static MemberReference ElementTypeFor(TypeSpecification genericInstanceType)
{
return genericInstanceType.ElementType;
}
static bool IsMatch(TypeSpecification a, TypeSpecification b)
{
if (a is GenericInstanceType) {
return IsMatch((GenericInstanceType)a, (GenericInstanceType)b);
}
return IsMatch(a.ElementType, b.ElementType);
}
/// <summary>
/// Is type a the same as type b?
/// </summary>
public static bool AreSame(this TypeSpecification a, TypeSpecification b, Func<GenericParameter, TypeReference> genericParamResolver)
{
if (!AreSame(a.ElementType, b.ElementType, genericParamResolver))
return false;
if (a.IsGenericInstance)
return AreSame((GenericInstanceType)a, (GenericInstanceType)b, genericParamResolver);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return AreSame((IModifierType)a, (IModifierType)b, genericParamResolver);
if (a.IsArray)
return AreSame((ArrayType)a, (ArrayType)b);
return true;
}
static bool compareTypeSpecifications(TypeSpecification a, TypeSpecification b)
{
// It overrides everything of importance in TypeReference. The only thing to check
// is the ElementType.
return compareTypes(a.ElementType, b.ElementType);
}
static int typeSpecificationHashCode(TypeSpecification a)
{
if (a == null)
return 0;
return typeHashCode(a.ElementType);
}
public static bool TypeMatch(TypeSpecification a, TypeSpecification b)
{
if (a is GenericInstanceType)
return TypeMatch ((GenericInstanceType) a, (GenericInstanceType) b);
if (a is IModifierType)
return TypeMatch ((IModifierType) a, (IModifierType) b);
return TypeMatch (a.ElementType, b.ElementType);
}
public static bool IsSameType(TypeSpecification a, TypeSpecification b, bool genericMatch)
{
if (!IsSameType(a.ElementType, b.ElementType, genericMatch))
return false;
if (a.IsGenericInstance)
return IsSameType((GenericInstanceType)a, (GenericInstanceType)b, genericMatch);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return IsSameType((IModifierType)a, (IModifierType)b, genericMatch);
if (a.IsArray)
return IsSameType((ArrayType)a, (ArrayType)b, genericMatch);
return true;
}
public static bool AreSame(TypeSpecification a, TypeSpecification b)
{
if (a is GenericInstanceType)
return AreSame ((GenericInstanceType) a, (GenericInstanceType) b);
if (a is ModType)
return AreSame ((ModType) a, (ModType) b);
return AreSame (a.ElementType, b.ElementType);
}
private static void AppendTypeSpecification(TypeSpecification type, StringBuilder name)
{
if (type.ElementType.IsTypeSpecification())
{
AppendTypeSpecification((TypeSpecification)type.ElementType, name);
}
switch (type.etype)
{
case ElementType.Ptr:
name.Append('*');
break;
case ElementType.ByRef:
name.Append('&');
break;
case ElementType.Array:
case ElementType.SzArray:
{
ArrayType arrayType = (ArrayType)type;
if (arrayType.IsVector)
{
name.Append("[]");
}
else
{
name.Append('[');
for (int j = 1; j < arrayType.Rank; j++)
{
name.Append(',');
}
name.Append(']');
}
break;
}
case ElementType.GenericInst:
{
Collection <TypeReference> genericArguments = ((GenericInstanceType)type).GenericArguments;
name.Append('[');
for (int i = 0; i < genericArguments.Count; i++)
{
if (i > 0)
{
name.Append(',');
}
TypeReference typeReference = genericArguments[i];
bool num = typeReference.Scope != typeReference.Module;
if (num)
{
name.Append('[');
}
AppendType(typeReference, name, true, false);
if (num)
{
name.Append(']');
}
}
name.Append(']');
break;
}
}
}
static void AppendTypeSpecification(TypeSpecification type, StringBuilder name)
{
if (type.ElementType.IsTypeSpecification())
{
AppendTypeSpecification((TypeSpecification)type.ElementType, name);
}
switch (type.etype)
{
case ElementType.Ptr:
name.Append('*');
break;
case ElementType.ByRef:
name.Append('&');
break;
case ElementType.SzArray:
case ElementType.Array:
var array = (ArrayType)type;
if (array.IsVector)
{
name.Append("[]");
}
else
{
name.Append('[');
for (int i = 1; i < array.Rank; i++)
{
name.Append(',');
}
name.Append(']');
}
break;
case ElementType.GenericInst:
var instance = (GenericInstanceType)type;
var arguments = instance.GenericArguments;
name.Append('[');
for (int i = 0; i < arguments.Count; i++)
{
if (i > 0)
{
name.Append(',');
}
var argument = arguments [i];
var requires_fqname = argument.Scope != argument.Module;
if (requires_fqname)
{
name.Append('[');
}
AppendType(argument, name, true, false);
if (requires_fqname)
{
name.Append(']');
}
}
name.Append(']');
break;
default:
return;
}
}
private void WriteModifier(TypeSpecification typeSpecification)
{
StringBuilder sb = new StringBuilder();
TypeReference elementType = typeSpecification;
IModifierType currentType = typeSpecification as IModifierType;
bool wroteModifier = false;
while (currentType != null)
{
if (currentType.ModifierType.FullName == "System.Runtime.CompilerServices.IsVolatile")
{
elementType = currentType.ElementType;
currentType = elementType as IModifierType;
continue;
}
if (wroteModifier)
{
sb.Append(", ");
}
sb.Append(currentType is RequiredModifierType ? "modreq" : "modopt");
sb.Append("(");
sb.Append(currentType.ModifierType.FullName);
sb.Append(")");
wroteModifier = true;
elementType = currentType.ElementType;
currentType = elementType as IModifierType;
}
if (wroteModifier)
{
WriteCommentBlock(sb.ToString());
WriteSpace();
}
WriteReferenceAndNamespaceIfInCollision(elementType);
}
private static bool AreSame(TypeSpecification a, TypeSpecification b) => (AreSame(a.ElementType, b.ElementType) ? (!a.IsGenericInstance ? ((a.IsRequiredModifier || a.IsOptionalModifier) ? AreSame((IModifierType)a, (IModifierType)b) : (!a.IsArray || AreSame((ArrayType)a, (ArrayType)b))) : AreSame((GenericInstanceType)a, (GenericInstanceType)b)) : false);
static string ToString (TypeSpecification specification)
{
var pointer = specification as PointerType;
if (pointer != null)
return ToString (specification.ElementType) + "*";
var reference = specification as ByReferenceType;
if (reference != null)
return ToString (specification.ElementType) + "&";
var array = specification as ArrayType;
if (array != null)
return ToString (specification.ElementType) + "[]";
var generic = specification as GenericInstanceType;
if (generic != null)
return ToString (generic);
throw new NotSupportedException ();
}
private static void AppendTypeSpecification(TypeSpecification type, StringBuilder name)
{
ArrayType type2;
if (type.ElementType.IsTypeSpecification())
{
AppendTypeSpecification((TypeSpecification)type.ElementType, name);
}
ElementType etype = type.etype;
switch (etype)
{
case ElementType.Ptr:
name.Append('*');
return;
case ElementType.ByRef:
name.Append('&');
return;
case ElementType.ValueType:
case ElementType.Class:
case ElementType.Var:
break;
case ElementType.Array:
goto TR_0007;
case ElementType.GenericInst:
{
Collection <TypeReference> genericArguments = ((GenericInstanceType)type).GenericArguments;
name.Append('[');
int num2 = 0;
while (true)
{
if (num2 >= genericArguments.Count)
{
name.Append(']');
break;
}
if (num2 > 0)
{
name.Append(',');
}
TypeReference reference = genericArguments[num2];
bool flag = !ReferenceEquals(reference.Scope, reference.Module);
if (flag)
{
name.Append('[');
}
AppendType(reference, name, true, false);
if (flag)
{
name.Append(']');
}
num2++;
}
break;
}
default:
if (etype != ElementType.SzArray)
{
return;
}
goto TR_0007;
}
return;
TR_0007:
type2 = (ArrayType)type;
if (type2.IsVector)
{
name.Append("[]");
}
else
{
name.Append('[');
for (int i = 1; i < type2.Rank; i++)
{
name.Append(',');
}
name.Append(']');
}
}
private TypeSpecification Fix(TypeSpecification type)
{
var fet = Fix(type.ElementType);
if (type is ArrayType)
{
var array = (ArrayType)type;
var imported_array = new ArrayType(fet);
if (array.IsVector)
return imported_array;
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions[i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return imported_array;
}
if (type is PointerType)
return new PointerType(fet);
if (type is ByReferenceType)
return new ByReferenceType(fet);
if (type is PinnedType)
return new PinnedType(fet);
if (type is SentinelType)
return new SentinelType(fet);
if (type is OptionalModifierType)
{
TypeReference fmt = Fix(((OptionalModifierType)type).ModifierType);
return new OptionalModifierType(fmt, fet);
}
if (type is RequiredModifierType)
{
TypeReference fmt = Fix(((RequiredModifierType)type).ModifierType);
return new RequiredModifierType(fmt, fet);
}
if (type is GenericInstanceType)
{
var instance = (GenericInstanceType)type;
var imported_instance = new GenericInstanceType(fet);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add(Fix(arguments[i]));
return imported_instance;
}
if (type is FunctionPointerType)
{
var funcPtr = (FunctionPointerType)type;
var imported_instance = new FunctionPointerType()
{
HasThis = funcPtr.HasThis,
ExplicitThis = funcPtr.ExplicitThis,
CallingConvention = funcPtr.CallingConvention,
ReturnType = Fix(funcPtr.ReturnType)
};
if (funcPtr.HasParameters)
{
foreach (var pd in funcPtr.Parameters)
{
imported_instance.Parameters.Add(pd);
}
FixReferences(imported_instance.Parameters);
}
return imported_instance;
}
throw new InvalidOperationException();
}
public static bool AreSame(TypeSpecification a, TypeSpecification b)
{
if (a.IsGenericInstance)
return AreSame((GenericInstanceType)a, (GenericInstanceType)b);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return AreSame((IModifierType)a, (IModifierType)b);
if (a.IsArray)
return AreSame((ArrayType)a, (ArrayType)b);
return AreSame(a.ElementType, b.ElementType);
}
void addTypeSpecification(TypeSpecification ts)
{
if (ts == null)
return;
addTypeReference(ts);
pushMember(ts.ElementType);
}
protected override void WriteTypeSpecification(TypeSpecification typeSpecification, int startingArgument = 0)
{
if ((typeSpecification.IsOptionalModifier || typeSpecification.IsRequiredModifier) && !isWritingComment)
{
WriteReferenceAndNamespaceIfInCollision(typeSpecification.ElementType);
return;
}
base.WriteTypeSpecification(typeSpecification, startingArgument);
}
protected virtual void WriteTypeSpecification(TypeSpecification typeSpecification, int startingArgument = 0)
{
PointerType pointer = typeSpecification as PointerType;
if (pointer != null)
{
WriteReference(typeSpecification.ElementType);
WriteToken("*");
return;
}
PinnedType pinnedType = typeSpecification as PinnedType;
if (pinnedType != null)
{
if (typeSpecification.ElementType is ByReferenceType)
{
WriteReference(((typeSpecification.ElementType) as ByReferenceType).ElementType);
WriteToken("*");
}
else
{
WriteReference(typeSpecification.ElementType);
}
return;
}
ByReferenceType reference = typeSpecification as ByReferenceType;
if (reference != null)
{
WriteReference(typeSpecification.ElementType);
WriteToken("&");
return;
}
ArrayType array = typeSpecification as ArrayType;
if (array != null)
{
List<int> dimentions = new List<int>();
TypeReference elementType = typeSpecification.ElementType;
while (elementType is ArrayType)
{
ArrayType ar = (elementType as ArrayType);
dimentions.Add(ar.Dimensions.Count);
elementType = ar.ElementType;
}
WriteReference(elementType);
WriteToken(IndexLeftBracket);
if (array.Dimensions != null)
{
for (int i = 1; i < array.Dimensions.Count; i++)
{
WriteToken(",");
}
}
WriteToken(IndexRightBracket);
foreach (int dimentionsSize in dimentions)
{
WriteToken(IndexLeftBracket);
for (int i = 1; i < dimentionsSize; i++)
{
WriteToken(",");
}
WriteToken(IndexRightBracket);
}
return;
}
GenericInstanceType generic = typeSpecification as GenericInstanceType;
if (generic != null)
{
if (SupportsSpecialNullable && (generic.GetFriendlyFullName(Language).IndexOf("System.Nullable<") == 0) &&
generic.GenericArguments[0].IsValueType)
{
TypeReference toWrite = generic.GenericArguments[0];
if (generic.PostionToArgument.ContainsKey(0))
{
toWrite = generic.PostionToArgument[0];
}
WriteReference(toWrite);
WriteToken("?");
return;
}
else
{
WriteGenericInstance(generic, startingArgument);
return;
}
}
if (typeSpecification.MetadataType == MetadataType.OptionalModifier)
{
Write(typeSpecification.Name);
return;
}
if (typeSpecification.IsRequiredModifier)
{
if (isWritingComment && (typeSpecification as RequiredModifierType).ModifierType.FullName == "System.Runtime.CompilerServices.IsVolatile")
{
//Corner case when writing field declarations in visual basic
WriteVolatileType(typeSpecification.ElementType);
}
else
{
WriteReference(typeSpecification.ElementType);
}
return;
}
throw new NotSupportedException();
}
public void WriteTypeSignature(TypeReference type)
{
if (type == null)
{
throw new ArgumentNullException();
}
ElementType etype = type.etype;
switch (etype)
{
case ElementType.Var:
case ElementType.MVar:
{
GenericParameter obj = (GenericParameter)type;
WriteElementType(etype);
int position = obj.Position;
if (position == -1)
{
throw new NotSupportedException();
}
base.WriteCompressedUInt32((uint)position);
break;
}
case ElementType.GenericInst:
{
GenericInstanceType genericInstanceType = (GenericInstanceType)type;
WriteElementType(ElementType.GenericInst);
WriteElementType(genericInstanceType.IsValueType ? ElementType.ValueType : ElementType.Class);
base.WriteCompressedUInt32(MakeTypeDefOrRefCodedRID(genericInstanceType.ElementType));
WriteGenericInstanceSignature(genericInstanceType);
break;
}
case ElementType.Ptr:
case ElementType.ByRef:
case ElementType.Sentinel:
case ElementType.Pinned:
{
TypeSpecification typeSpecification = (TypeSpecification)type;
WriteElementType(etype);
WriteTypeSignature(typeSpecification.ElementType);
break;
}
case ElementType.FnPtr:
{
FunctionPointerType method = (FunctionPointerType)type;
WriteElementType(ElementType.FnPtr);
WriteMethodSignature(method);
break;
}
case ElementType.CModReqD:
case ElementType.CModOpt:
{
IModifierType type2 = (IModifierType)type;
WriteModifierSignature(etype, type2);
break;
}
case ElementType.Array:
{
ArrayType arrayType = (ArrayType)type;
if (!arrayType.IsVector)
{
WriteArrayTypeSignature(arrayType);
}
else
{
WriteElementType(ElementType.SzArray);
WriteTypeSignature(arrayType.ElementType);
}
break;
}
case ElementType.None:
WriteElementType(type.IsValueType ? ElementType.ValueType : ElementType.Class);
base.WriteCompressedUInt32(MakeTypeDefOrRefCodedRID(type));
break;
default:
if (TryWriteElementType(type))
{
break;
}
throw new NotSupportedException();
}
}
