public Ref <Types> OptionalModifier(Ref <Types> elementType, ClassName className)
{
var elementRefType = RefToValue(elementType);
var modifierType = ClassNameToTypeReference(className);
var type = new OptionalModifierType(modifierType, elementRefType);
return(ValueToRef(type));
}
void addOptionalModifierType(OptionalModifierType omt)
{
if (omt == null)
{
return;
}
addTypeSpecification(omt);
pushMember(omt.ModifierType);
}
void doOptionalModifierType(OptionalModifierType optionalModifierType)
{
if (optionalModifierTypes.ContainsKey(optionalModifierType))
{
return;
}
optionalModifierTypes[optionalModifierType] = true;
addOptionalModifierType(optionalModifierType);
}
public TypeReference Visit(OptionalModifierType current, IGenericContext gcontext)
{
var result = new OptionalModifierType(Get(current.ModifierType, gcontext), Get(current.ElementType, gcontext));
if (current.HasGenericParameters)
{
CopyAndUpdate(result, current, gcontext);
}
return(result);
}
public NetTypeReference Visit(OptionalModifierType type, ResolveData data)
{
throw new NotImplementedException("OptionalModifierType to NetTypeReference");
}
/// <summary>
/// Gets a TypeRef from a TypeReference.
/// </summary>
/// <param name="type">The TypeReference.</param>
/// <returns>The TypeRef.</returns>
public static TypeRef GetTypeRefFromType(TypeReference type)
{
switch (type.MetadataType)
{
case MetadataType.UInt64:
case MetadataType.Int64:
return(Int64);
case MetadataType.UInt32:
case MetadataType.Int32:
return(Int32);
case MetadataType.UInt16:
case MetadataType.Int16:
return(Int16);
case MetadataType.Byte:
case MetadataType.SByte:
return(Int8);
case MetadataType.Char:
return(Int8);
case MetadataType.String:
return(String);
case MetadataType.Boolean:
return(Boolean);
case MetadataType.Void:
return(Void);
case MetadataType.Single:
return(Float);
case MetadataType.Double:
return(Double);
case MetadataType.IntPtr:
case MetadataType.UIntPtr:
return(NativeIntType);
case MetadataType.Array:
ArrayType array = (ArrayType)type;
return(LLVM.PointerType(GetTypeRefFromType(array.ElementType), 0));
case MetadataType.Pointer:
PointerType ptr = (PointerType)type;
return(LLVM.PointerType(GetTypeRefFromType(ptr.ElementType), 0));
case MetadataType.ByReference:
ByReferenceType byRef = (ByReferenceType)type;
return(LLVM.PointerType(GetTypeRefFromType(byRef.ElementType), 0));
case MetadataType.Pinned:
PinnedType pinned = (PinnedType)type;
return(GetTypeRefFromType(pinned.ElementType));
case MetadataType.Class:
return(LLVM.PointerType(mLookup.GetTypeRef(type), 0));
case MetadataType.ValueType:
return(mLookup.GetTypeRef(type));
case MetadataType.GenericInstance:
case MetadataType.Var:
case MetadataType.Object:
return(VoidPtr);
case MetadataType.RequiredModifier:
RequiredModifierType requiredModifier = (RequiredModifierType)type;
return(GetTypeRefFromType(requiredModifier.ElementType));
case MetadataType.OptionalModifier:
OptionalModifierType optionalModifier = (OptionalModifierType)type;
return(GetTypeRefFromType(optionalModifier.ElementType));
default:
throw new InvalidOperationException("Invalid meta data type to get type from: " + type.MetadataType);
}
}
private static TypeReference ImportType(TypeReference typeRef, ModuleDefinition mod,
MethodReference context,
Dictionary <MetadataToken, IMemberDefinition> mems)
{
TypeReference ret = typeRef;
if (typeRef is TypeSpecification)
{
if (typeRef is ArrayType)
{
ArrayType _spec = typeRef as ArrayType;
ret = new ArrayType(ImportType(_spec.ElementType, mod, context, mems));
(ret as ArrayType).Dimensions.Clear();
foreach (var i in _spec.Dimensions)
{
(ret as ArrayType).Dimensions.Add(i);
}
}
else if (typeRef is GenericInstanceType)
{
GenericInstanceType _spec = typeRef as GenericInstanceType;
ret = new GenericInstanceType(ImportType(_spec.ElementType, mod, context, mems));
foreach (var i in _spec.GenericArguments)
{
(ret as GenericInstanceType).GenericArguments.Add(ImportType(i, mod, context, mems));
}
}
else if (typeRef is OptionalModifierType)
{
ret =
new OptionalModifierType(
ImportType((typeRef as OptionalModifierType).ModifierType, mod, context, mems),
ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is RequiredModifierType)
{
ret =
new RequiredModifierType(
ImportType((typeRef as RequiredModifierType).ModifierType, mod, context, mems),
ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is ByReferenceType)
{
ret = new ByReferenceType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is PointerType)
{
ret = new PointerType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is PinnedType)
{
ret = new PinnedType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is SentinelType)
{
ret = new SentinelType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else
{
throw new NotSupportedException();
}
}
else if (typeRef is GenericParameter)
{
if (context == null || (typeRef as GenericParameter).Owner is TypeReference ||
(typeRef as GenericParameter).Position >= context.GenericParameters.Count)
{
return(typeRef);
}
return(context.GenericParameters[(typeRef as GenericParameter).Position]);
}
else
{
if (mems != null && mems.ContainsKey(typeRef.MetadataToken))
{
ret = mems[typeRef.MetadataToken] as TypeReference;
}
else if (!(ret is TypeDefinition) && typeRef.Scope.Name != "Confuser.Core.Injections.dll")
{
ret = mod.Import(ret);
}
}
return(ret);
}
private static string GetFriendlyFullOptionalModifierTypeName(this OptionalModifierType self, ILanguage language)
{
return(String.Concat(self.GetFriendlyFullTypeSpecificationName(language), self.get_Suffix()));
}
static bool Match(TypeReference type, TypeReference target)
{
if (!(target is TypeSpecification))
{
return(type.Name == target.Name && type.Namespace == target.Namespace);
}
if (type.MetadataType != target.MetadataType)
{
return(false);
}
TypeSpecification typeSpecA = type as TypeSpecification;
TypeSpecification typeSpecB = target as TypeSpecification;
switch (type.MetadataType)
{
case MetadataType.Array:
{
ArrayType arrA = type as ArrayType, arrB = target as ArrayType;
if (arrA.Dimensions.Count != arrB.Dimensions.Count)
{
return(false);
}
for (int i = 0; i < arrA.Dimensions.Count; i++)
{
if (arrA.Dimensions[i].LowerBound != arrB.Dimensions[i].LowerBound ||
arrA.Dimensions[i].UpperBound != arrB.Dimensions[i].UpperBound)
{
return(false);
}
}
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.RequiredModifier:
{
RequiredModifierType modA = type as RequiredModifierType, modB = target as RequiredModifierType;
return(Match(modA.ModifierType, modB.ModifierType) &&
Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.OptionalModifier:
{
OptionalModifierType modA = type as OptionalModifierType, modB = target as OptionalModifierType;
return(Match(modA.ModifierType, modB.ModifierType) &&
Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.ByReference:
case MetadataType.Pinned:
case MetadataType.Pointer:
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
case MetadataType.GenericInstance:
GenericInstanceType instA = type as GenericInstanceType, instB = target as GenericInstanceType;
if (instA.GenericArguments.Count != instB.GenericArguments.Count)
{
return(false);
}
for (int i = 0; i < instA.GenericArguments.Count; i++)
{
if (!Match(instA.GenericArguments[i], instB.GenericArguments[i]))
{
return(false);
}
}
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
case MetadataType.FunctionPointer: //not support
throw new NotSupportedException();
}
return(false);
}
/* AGPL */
private static string GetFriendlyFullOptionalModifierTypeName(this OptionalModifierType self, ILanguage language, bool includeNamespace = true)
{
return(self.GetFriendlyFullTypeSpecificationName(language, includeNamespace) + self.Suffix);
}
public static bool AreEqual(TypeReference a, TypeReference b, TypeComparisonMode comparisonMode = 0)
{
if (object.ReferenceEquals(a, b))
{
return(true);
}
if ((a == null) || (b == null))
{
return(false);
}
MetadataType metadataType = a.MetadataType;
MetadataType type2 = b.MetadataType;
if ((metadataType == MetadataType.GenericInstance) || (type2 == MetadataType.GenericInstance))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual((GenericInstanceType)a, (GenericInstanceType)b, comparisonMode));
}
if ((metadataType == MetadataType.Array) || (type2 == MetadataType.Array))
{
if (metadataType != type2)
{
return(false);
}
ArrayType type3 = (ArrayType)a;
ArrayType type4 = (ArrayType)b;
if (type3.Rank != type4.Rank)
{
return(false);
}
return(AreEqual(type3.ElementType, type4.ElementType, comparisonMode));
}
if ((metadataType == MetadataType.Var) || (type2 == MetadataType.Var))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual((GenericParameter)a, (GenericParameter)b, TypeComparisonMode.Exact));
}
if ((metadataType == MetadataType.MVar) || (type2 == MetadataType.MVar))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual((GenericParameter)a, (GenericParameter)b, comparisonMode));
}
if ((metadataType == MetadataType.ByReference) || (type2 == MetadataType.ByReference))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual(((ByReferenceType)a).ElementType, ((ByReferenceType)b).ElementType, comparisonMode));
}
if ((metadataType == MetadataType.Pointer) || (type2 == MetadataType.Pointer))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual(((PointerType)a).ElementType, ((PointerType)b).ElementType, comparisonMode));
}
if ((metadataType == MetadataType.RequiredModifier) || (type2 == MetadataType.RequiredModifier))
{
if (metadataType != type2)
{
return(false);
}
RequiredModifierType type5 = (RequiredModifierType)a;
RequiredModifierType type6 = (RequiredModifierType)b;
return(AreEqual(type5.ModifierType, type6.ModifierType, TypeComparisonMode.Exact) && AreEqual(type5.ElementType, type6.ElementType, comparisonMode));
}
if ((metadataType == MetadataType.OptionalModifier) || (type2 == MetadataType.OptionalModifier))
{
if (metadataType != type2)
{
return(false);
}
OptionalModifierType type7 = (OptionalModifierType)a;
OptionalModifierType type8 = (OptionalModifierType)b;
return(AreEqual(type7.ModifierType, type8.ModifierType, TypeComparisonMode.Exact) && AreEqual(type7.ElementType, type8.ElementType, comparisonMode));
}
if ((metadataType == MetadataType.Pinned) || (type2 == MetadataType.Pinned))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual(((PinnedType)a).ElementType, ((PinnedType)b).ElementType, comparisonMode));
}
if ((metadataType == MetadataType.Sentinel) || (type2 == MetadataType.Sentinel))
{
if (metadataType != type2)
{
return(false);
}
return(AreEqual(((SentinelType)a).ElementType, ((SentinelType)b).ElementType, TypeComparisonMode.Exact));
}
if (!a.Name.Equals(b.Name) || !a.Namespace.Equals(b.Namespace))
{
return(false);
}
TypeDefinition definition = a.Resolve();
TypeDefinition definition2 = b.Resolve();
return(definition == definition2);
}
public static bool IsEqual(Reflector.CodeModel.IType t, TypeReference tr)
{
if (t is Reflector.CodeModel.ITypeReference)
{
return(IsEqual((Reflector.CodeModel.ITypeReference)t, tr));
}
else if ((t is Reflector.CodeModel.IArrayType) && (tr is ArrayType))
{
Reflector.CodeModel.IArrayType t2 = (Reflector.CodeModel.IArrayType)t;
ArrayType tr2 = (ArrayType)tr;
if (
!(t2.Dimensions.Count == 0 && tr2.Dimensions.Count == 1) && // one dimension
(t2.Dimensions.Count != tr2.Dimensions.Count) // two or more dimension
)
{
return(false);
}
return(IsEqual(t2.ElementType, tr2.ElementType));
}
else if ((t is Reflector.CodeModel.IReferenceType) && (tr is ByReferenceType))
{
return(IsEqual(((Reflector.CodeModel.IReferenceType)t).ElementType, ((ByReferenceType)tr).ElementType));
}
else if ((t is Reflector.CodeModel.IPointerType) && (tr is PointerType))
{
return(IsEqual(((Reflector.CodeModel.IPointerType)t).ElementType, ((PointerType)tr).ElementType));
}
else if ((t is Reflector.CodeModel.IOptionalModifier) && (tr is OptionalModifierType))
{
Reflector.CodeModel.IOptionalModifier t2 = (Reflector.CodeModel.IOptionalModifier)t;
OptionalModifierType tr2 = (OptionalModifierType)tr;
return(IsEqual(t2.Modifier, tr2.ModifierType) && IsEqual(t2.ElementType, tr2.ElementType));
}
else if ((t is Reflector.CodeModel.IFunctionPointer) && (tr is FunctionPointerType))
{
Reflector.CodeModel.IFunctionPointer t2 = (Reflector.CodeModel.IFunctionPointer)t;
FunctionPointerType tr2 = (FunctionPointerType)tr;
if (t2.Parameters.Count == tr2.Parameters.Count && IsEqual(t2.ReturnType.Type, tr2.ReturnType))
{
for (int i = 0; i < t2.Parameters.Count; i++)
{
if (!IsEqual(t2.Parameters[i].ParameterType, tr2.Parameters[i].ParameterType))
{
return(false);
}
}
return(true);
}
return(false);
}
else if ((t is Reflector.CodeModel.IRequiredModifier) && (tr is RequiredModifierType))
{
Reflector.CodeModel.IRequiredModifier t2 = (Reflector.CodeModel.IRequiredModifier)t;
RequiredModifierType tr2 = (RequiredModifierType)tr;
return(IsEqual(t2.Modifier, tr2.ModifierType) && IsEqual(t2.ElementType, tr2.ElementType));
}
else
{
string trName = InsUtils.GetOldMemberName(tr);
//when tr is GenericParameter, it may be !0 or something, no clue what it is, no luck ...
if ("!0" == trName && t.ToString() == "T")
{
return(true);
}
return(t.ToString().Equals(trName));
}
}
public CodeTypeReference Visit(OptionalModifierType type, object data)
{
throw new System.NotImplementedException();
}
public TypeReference Resolve(TypeReference typeReference)
{
GenericParameter genericParameter = typeReference as GenericParameter;
if (genericParameter != null)
{
return(this.Resolve(this.ResolveGenericParameter(genericParameter)));
}
ArrayType arrayType = typeReference as ArrayType;
if (arrayType != null)
{
return(new ArrayType(this.Resolve(arrayType.ElementType), arrayType.Rank));
}
PointerType pointerType = typeReference as PointerType;
if (pointerType != null)
{
return(new PointerType(this.Resolve(pointerType.ElementType)));
}
ByReferenceType byReferenceType = typeReference as ByReferenceType;
if (byReferenceType != null)
{
return(new ByReferenceType(this.Resolve(byReferenceType.ElementType)));
}
GenericInstanceType genericInstanceType = typeReference as GenericInstanceType;
if (genericInstanceType != null)
{
GenericInstanceType genericInstanceType2 = new GenericInstanceType(this.Resolve(genericInstanceType.ElementType));
foreach (TypeReference current in genericInstanceType.GenericArguments)
{
genericInstanceType2.GenericArguments.Add(this.Resolve(current));
}
return(genericInstanceType2);
}
PinnedType pinnedType = typeReference as PinnedType;
if (pinnedType != null)
{
return(new PinnedType(this.Resolve(pinnedType.ElementType)));
}
RequiredModifierType requiredModifierType = typeReference as RequiredModifierType;
if (requiredModifierType != null)
{
return(this.Resolve(requiredModifierType.ElementType));
}
OptionalModifierType optionalModifierType = typeReference as OptionalModifierType;
if (optionalModifierType != null)
{
return(new OptionalModifierType(this.Resolve(optionalModifierType.ModifierType), this.Resolve(optionalModifierType.ElementType)));
}
SentinelType sentinelType = typeReference as SentinelType;
if (sentinelType != null)
{
return(new SentinelType(this.Resolve(sentinelType.ElementType)));
}
FunctionPointerType functionPointerType = typeReference as FunctionPointerType;
if (functionPointerType != null)
{
throw new NotSupportedException("Function pointer types are not supported by the SerializationWeaver");
}
if (typeReference is TypeSpecification)
{
throw new NotSupportedException();
}
return(typeReference);
}
private void GetXmlDocParameterPathRecursive(
TypeReference tpType,
bool ExplicitMode,
StringBuilder CurrPath)
{
if (tpType == null)
{
return;
}
if (tpType.GenericParameters.Count > 0)
{
CurrPath.Append(
tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".") +
StripGenericName(tpType.Name));
// list parameters or types
bool firstAppend = true;
CurrPath.Append("{");
foreach (GenericParameter TempType in tpType.GenericParameters)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(TempType, ExplicitMode));
firstAppend = false;
}
CurrPath.Append("}");
}
else if (tpType is GenericInstanceType)
{
GenericInstanceType thisGenericType = tpType as GenericInstanceType;
// if nested, scan enclosing type
if (tpType.DeclaringType != null)
{
CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode));
}
// determine namespace
string strNamespace = string.Empty;
if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null)
{
strNamespace = tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".");
}
CurrPath.Append(strNamespace + StripGenericName(thisGenericType.Name));
// list parameters or types
bool firstAppend = true;
CurrPath.Append("{");
foreach (TypeReference tempTypeRef in thisGenericType.GenericArguments)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(tempTypeRef, ExplicitMode));
firstAppend = false;
}
CurrPath.Append("}");
}
else if (tpType is GenericParameter)
{
GenericParameter thisGenParam = tpType as GenericParameter;
if (ExplicitMode)
{
// in explicit mode we print parameter name
CurrPath.Append(thisGenParam.Name);
}
else
{
// in non-explicit mode we print parameter order
int paramOrder = 0;
// find
for (int i = 0; i < thisGenParam.Owner.GenericParameters.Count; i++)
{
if (thisGenParam.Owner.GenericParameters[i].Name == tpType.Name)
{
paramOrder = i;
break;
}
}
if (thisGenParam.Owner is MethodReference)
{
CurrPath.Append("``" + paramOrder);
}
else
{
CurrPath.Append("`" + paramOrder);
}
}
}
else if (tpType is PointerType)
{
// parameter is pointer type
CurrPath.Append(GetXmlDocParameterPath((tpType as PointerType).ElementType, ExplicitMode));
CurrPath.Append("*");
}
else if (tpType is ArrayType)
{
ArrayType thisArrayType = tpType as ArrayType;
if (thisArrayType.ElementType != null)
{
CurrPath.Append(GetXmlDocParameterPath(thisArrayType.ElementType, ExplicitMode));
}
int iRank = thisArrayType.Rank;
if (iRank == 1)
{
CurrPath.Append("[]");
}
else
{
bool firstAppend = true;
CurrPath.Append("[");
for (int i = 0; i < (ExplicitMode ? iRank - 1 : iRank); i++)
{
// in explicit mode for .NET3.5/VS2008,
// there is no separator char "," used for multi-dimensional array,
// so there are three cases when comma shall be added:
// firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = true;
// firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = false;
// firstAppend = false; ExplicitMode = true; CanAppendSpecialExplicitChar() = false;
// below this is stored in decent manner
if (!firstAppend && (!ExplicitMode || !CanAppendSpecialExplicitChar()))
{
CurrPath.Append(",");
}
CurrPath.Append(((CanAppendSpecialExplicitChar() && ExplicitMode) ? "@" : "0:"));
if (thisArrayType.Dimensions[i].UpperBound > 0)
{
CurrPath.Append(thisArrayType.Dimensions[i].UpperBound.ToString());
}
firstAppend = false;
}
CurrPath.Append("]");
}
}
else if (tpType is ByReferenceType)
{
// parameter is passed by reference
CurrPath.Append(GetXmlDocParameterPath((tpType as ByReferenceType).ElementType, false));
CurrPath.Append("@");
}
else if (tpType is OptionalModifierType)
{
// parameter has optional modifier
OptionalModifierType thisModOpt = tpType as OptionalModifierType;
CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ElementType, ExplicitMode));
CurrPath.Append("!");
CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ModifierType, ExplicitMode));
}
else if (tpType is RequiredModifierType)
{
// parameter has required modifier
RequiredModifierType thisModReq = tpType as RequiredModifierType;
CurrPath.Append(GetXmlDocParameterPath(thisModReq.ElementType, ExplicitMode));
CurrPath.Append("|");
CurrPath.Append(GetXmlDocParameterPath(thisModReq.ModifierType, ExplicitMode));
}
else if (tpType is FunctionPointerType)
{
// type is function pointer
FunctionPointerType thisFuncPtr = tpType as FunctionPointerType;
string tempString = string.Empty;
// return type
CurrPath.Append("=FUNC:");
CurrPath.Append(GetXmlDocParameterPath(thisFuncPtr.ReturnType, ExplicitMode));
// method's parameters
if (thisFuncPtr.Parameters.Count > 0)
{
bool firstAppend = true;
CurrPath.Append("(");
foreach (ParameterDefinition tempParam in thisFuncPtr.Parameters)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(tempParam.ParameterType, ExplicitMode));
firstAppend = false;
}
CurrPath.Append(")");
}
else
{
CurrPath.Append("(System.Void)");
}
}
else if (tpType is PinnedType)
{
// type is pinned type
CurrPath.Append(GetXmlDocParameterPath((tpType as PinnedType).ElementType, ExplicitMode));
CurrPath.Append("^");
}
else if (tpType is TypeReference)
{
// if nested, scan enclosing type
if (tpType.DeclaringType != null)
{
CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode));
}
// determine namespace
string strNamespace = string.Empty;
if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null)
{
strNamespace = tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".");
}
// concrete type
CurrPath.Append(
strNamespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? tpType.Name.Replace(".", "#") : tpType.Name));
}
}
static bool compareOptionalModifierTypes(Type a, OptionalModifierType b) {
return compareTypes(a, b.ElementType);
}
protected virtual OptionalModifierType updateOptionalModifierType(OptionalModifierType a)
{
return(new OptionalModifierType(update(a.ModifierType), update(a.ElementType)));
}
protected override StringBuilder AppendOptionalModifierType(StringBuilder buf, OptionalModifierType type, DynamicParserContext context)
{
if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsLong" &&
type.ElementType.FullName == "System.Int32")
{
return(buf.Append("long"));
}
if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsSignUnspecifiedByte" &&
type.ElementType.FullName == "System.SByte")
{
return(buf.Append("char"));
}
if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsConst")
{
buf.Append("const ");
_AppendTypeName(buf, type.ElementType, context);
return(buf);
}
_AppendTypeName(buf, type.ElementType, context);
buf.Append(" modopt(");
_AppendTypeName(buf, type.ModifierType, context);
buf.Append(')');
return(buf);
}
protected void TypeIdentifier(OptionalModifierType modopt, TypeReferenceContext context, bool includeParens)
{
Identifier(modopt.ElementType as dynamic, context, includeParens);
}
public static int GetHashCodeFor(TypeReference obj)
{
MetadataType metadataType = obj.MetadataType;
switch (metadataType)
{
case MetadataType.GenericInstance:
{
GenericInstanceType type2 = (GenericInstanceType)obj;
int num = (GetHashCodeFor(type2.ElementType) * 0x1cfaa2db) + 0x1f;
for (int i = 0; i < type2.GenericArguments.Count; i++)
{
num = (num * 0x1cfaa2db) + GetHashCodeFor(type2.GenericArguments[i]);
}
return(num);
}
case MetadataType.Array:
{
ArrayType type3 = (ArrayType)obj;
return((GetHashCodeFor(type3.ElementType) * 0x1cfaa2db) + type3.Rank.GetHashCode());
}
case MetadataType.Var:
case MetadataType.MVar:
{
GenericParameter parameter = (GenericParameter)obj;
int num7 = (int)metadataType;
int num5 = (parameter.Position.GetHashCode() * 0x1cfaa2db) + num7.GetHashCode();
TypeReference owner = parameter.Owner as TypeReference;
if (owner != null)
{
return((num5 * 0x1cfaa2db) + GetHashCodeFor(owner));
}
MethodReference reference2 = parameter.Owner as MethodReference;
if (reference2 == null)
{
throw new InvalidOperationException("Generic parameter encountered with invalid owner");
}
return((num5 * 0x1cfaa2db) + Unity.IL2CPP.Common.MethodReferenceComparer.GetHashCodeFor(reference2));
}
case MetadataType.ByReference:
{
ByReferenceType type4 = (ByReferenceType)obj;
return((GetHashCodeFor(type4.ElementType) * 0x1cfaa2db) * 0x25);
}
case MetadataType.Pointer:
{
PointerType type5 = (PointerType)obj;
return((GetHashCodeFor(type5.ElementType) * 0x1cfaa2db) * 0x29);
}
case MetadataType.RequiredModifier:
{
RequiredModifierType type6 = (RequiredModifierType)obj;
int num8 = GetHashCodeFor(type6.ElementType) * 0x2b;
return((num8 * 0x1cfaa2db) + GetHashCodeFor(type6.ModifierType));
}
case MetadataType.OptionalModifier:
{
OptionalModifierType type7 = (OptionalModifierType)obj;
int num9 = GetHashCodeFor(type7.ElementType) * 0x2f;
return((num9 * 0x1cfaa2db) + GetHashCodeFor(type7.ModifierType));
}
case MetadataType.Pinned:
{
PinnedType type8 = (PinnedType)obj;
return((GetHashCodeFor(type8.ElementType) * 0x1cfaa2db) * 0x35);
}
case MetadataType.Sentinel:
{
SentinelType type9 = (SentinelType)obj;
return((GetHashCodeFor(type9.ElementType) * 0x1cfaa2db) * 0x3b);
}
case MetadataType.FunctionPointer:
throw new NotImplementedException("We currently don't handle function pointer types.");
}
return((obj.Namespace.GetHashCode() * 0x1cfaa2db) + obj.FullName.GetHashCode());
}
protected override StringBuilder AppendOptionalModifierType(StringBuilder buf, OptionalModifierType type, DynamicParserContext context)
{
_AppendTypeName(buf, type.ElementType, context);
buf.Append(" modopt(");
_AppendTypeName(buf, type.ModifierType, context);
buf.Append(')');
return(buf);
}
public TypeReference Resolve(TypeReference typeReference)
{
GenericParameter genericParameter = typeReference as GenericParameter;
if (genericParameter != null)
{
return(this.Resolve(this.ResolveGenericParameter(genericParameter)));
}
ArrayType type = typeReference as ArrayType;
if (type != null)
{
return(new ArrayType(this.Resolve(type.ElementType), type.Rank));
}
PointerType type2 = typeReference as PointerType;
if (type2 != null)
{
return(new PointerType(this.Resolve(type2.ElementType)));
}
ByReferenceType type3 = typeReference as ByReferenceType;
if (type3 != null)
{
return(new ByReferenceType(this.Resolve(type3.ElementType)));
}
GenericInstanceType type4 = typeReference as GenericInstanceType;
if (type4 != null)
{
GenericInstanceType type5 = new GenericInstanceType(this.Resolve(type4.ElementType));
foreach (TypeReference reference2 in type4.GenericArguments)
{
type5.GenericArguments.Add(this.Resolve(reference2));
}
return(type5);
}
PinnedType type6 = typeReference as PinnedType;
if (type6 != null)
{
return(new PinnedType(this.Resolve(type6.ElementType)));
}
RequiredModifierType type7 = typeReference as RequiredModifierType;
if (type7 != null)
{
return(this.Resolve(type7.ElementType));
}
OptionalModifierType type8 = typeReference as OptionalModifierType;
if (type8 != null)
{
return(new OptionalModifierType(this.Resolve(type8.ModifierType), this.Resolve(type8.ElementType)));
}
SentinelType type9 = typeReference as SentinelType;
if (type9 != null)
{
return(new SentinelType(this.Resolve(type9.ElementType)));
}
if (typeReference is FunctionPointerType)
{
throw new NotSupportedException("Function pointer types are not supported by the SerializationWeaver");
}
if (typeReference is TypeSpecification)
{
throw new NotSupportedException();
}
return(typeReference);
}
