protected virtual FunctionPointerType updateFunctionPointerType(FunctionPointerType a)
{
var rv = new FunctionPointerType();
rv.function = a.function;
return(rv);
}
public override IType VisitFunctionPointerType(FunctionPointerType type)
{
builder.Append("method ");
if (type.CallingConvention != SignatureCallingConvention.Default)
{
builder.Append(type.CallingConvention.ToILSyntax());
builder.Append(' ');
}
type.ReturnType.AcceptVisitor(this);
builder.Append(" *(");
bool first = true;
foreach (var p in type.ParameterTypes)
{
if (first)
{
first = false;
}
else
{
builder.Append(", ");
}
p.AcceptVisitor(this);
}
builder.Append(')');
return(type);
}
public override void AppendName(StringBuilder sb, FunctionPointerType type)
{
MethodSignature signature = type.Signature;
sb.Append("method ");
if (!signature.IsStatic)
{
sb.Append("instance ");
}
// TODO: rest of calling conventions
AppendName(sb, signature.ReturnType);
sb.Append(" *(");
for (int i = 0; i < signature.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
AppendName(sb, signature[i]);
}
sb.Append(')');
}
private bool IsAssignableToWithSubstitutionsCore(FunctionPointerType self, IType type, ICollection <Substitution> substitutions)
{
if (type is FunctionPointerType func)
{
//covariant
if (!IsAssignableToWithSubstitutions(self.ReturnType, func.ReturnType, substitutions))
{
return(false);
}
if (self.Parameters.Length != func.Parameters.Length)
{
return(false);
}
return(self.Parameters
.Zip(func.Parameters, (sPar, tPar) => (sPar, tPar))
.All(x => {
if (x.tPar is TypeParameterType t)
{
substitutions.Add(new Substitution(t, x.sPar));
return true;
}
//contravariant
return IsAssignableToWithSubstitutions(x.tPar, x.sPar, substitutions);
}));
}
return(false);
}
protected override FunctionPointerType updateFunctionPointerType(FunctionPointerType a)
{
var rv = new FunctionPointerType();
rv.function = MethodReferenceInstance.make(a.function, git, gim);
checkModified(a.function, rv.function);
return(rv);
}
void doFunctionPointerType(FunctionPointerType functionPointerType)
{
if (functionPointerTypes.ContainsKey(functionPointerType))
{
return;
}
functionPointerTypes[functionPointerType] = true;
addFunctionPointerType(functionPointerType);
}
public FunctionPointerField(IType ownerType,
string name,
FunctionPointerType type) : base(name,
type.Parameters,
ImmutableArray <IType> .Empty,
type.ReturnType)
{
OwnerType = ownerType;
}
void WriteFunctionPointerTypeSignature(FunctionPointerType type)
{
id.Append("=FUNC:");
WriteTypeSignature(type.ReturnType);
if (type.HasParameters)
{
WriteParameters(type.Parameters);
}
}
private static string GetFriendlyFullFunctionPointerTypeName(this FunctionPointerType self, ILanguage language)
{
V_0 = new StringBuilder();
dummyVar0 = V_0.Append(self.get_Function().get_Name());
dummyVar1 = V_0.Append(" ");
dummyVar2 = V_0.Append(self.get_Function().get_FixedReturnType().GetFriendlyFullName(language));
dummyVar3 = V_0.Append(" *");
self.MethodSignatureFriendlyFullName(language, V_0, false);
return(V_0.ToString());
}
public CallIndirect(bool isInstance, bool hasExplicitThis, FunctionPointerType functionPointerType,
ILInstruction functionPointer, IEnumerable <ILInstruction> arguments) : base(OpCode.CallIndirect)
{
this.IsInstance = isInstance;
this.HasExplicitThis = hasExplicitThis;
this.FunctionPointerType = functionPointerType;
this.FunctionPointer = functionPointer;
this.Arguments = new InstructionCollection <ILInstruction>(this, 1);
this.Arguments.AddRange(arguments);
}
void addFunctionPointerType(FunctionPointerType fpt)
{
if (fpt == null)
{
return;
}
addTypeSpecification(fpt);
// It's an anon MethodReference created by the class. Not useful to us.
//pushMember(fpt.function);
}
private static string GetFriendlyFullFunctionPointerTypeName(this FunctionPointerType self, ILanguage language)
{
StringBuilder signature = new StringBuilder();
signature.Append(self.Function.Name);
signature.Append(" ");
signature.Append(self.Function.FixedReturnType.GetFriendlyFullName(language));
signature.Append(" *");
self.MethodSignatureFriendlyFullName(language, signature, false);
return(signature.ToString());
}
bool EqualSignature(CallIndirect other)
{
if (IsInstance != other.IsInstance)
{
return(false);
}
if (HasExplicitThis != other.HasExplicitThis)
{
return(false);
}
return(FunctionPointerType.Equals(other.FunctionPointerType));
}
private IExtractedEntity CreateGenericHandle(IGenericContext gc, Handle handle)
{
IExtractedEntity entity;
switch (handle.Kind)
{
case HandleKind.MethodDefinition:
entity = new DefinitionMethod(gc, (MethodDefinitionHandle)handle);
break;
case HandleKind.MemberReference:
entity = Create(gc, (MemberReferenceHandle)handle);
break;
case HandleKind.MethodSpecification:
entity = new MethodSpecificationMethod(gc, (MethodSpecificationHandle)handle);
break;
case HandleKind.FieldDefinition:
entity = new DefinitionField(gc.Context, (FieldDefinitionHandle)handle);
break;
case HandleKind.TypeReference:
var tr = new TypeReferenceType(this, (TypeReferenceHandle)handle);
if (tr.TryGetPrimitiveType(out var pt))
{
// Map special names like `System.Int32` to `int`
return(pt);
}
entity = tr;
break;
case HandleKind.TypeSpecification:
return(Entities.Type.DecodeType(gc, (TypeSpecificationHandle)handle));
case HandleKind.TypeDefinition:
entity = new TypeDefinitionType(this, (TypeDefinitionHandle)handle);
break;
case HandleKind.StandaloneSignature:
var signature = MdReader.GetStandaloneSignature((StandaloneSignatureHandle)handle);
var method = signature.DecodeMethodSignature(gc.Context.TypeSignatureDecoder, gc);
entity = new FunctionPointerType(this, method);
break;
default:
throw new InternalError("Unhandled handle kind " + handle.Kind);
}
Populate(entity);
return(entity);
}
private IFunctionPointerTypeReference GetFunctionPointerType(
uint standAloneSigToken
)
{
FunctionPointerType /*?*/ fpt = this.GetStandAloneMethodSignature(standAloneSigToken);
if (fpt != null)
{
return(fpt);
}
// Error...
return(Dummy.FunctionPointer);
}
private static Type ReadFunctionPointer(ModuleReader module, ByteReader br, IGenericContext context)
{
__StandAloneMethodSig sig = MethodSignature.ReadStandAloneMethodSig(module, br, context);
if (module.universe.EnableFunctionPointers)
{
return(FunctionPointerType.Make(module.universe, sig));
}
else
{
// by default, like .NET we return System.IntPtr here
return(module.universe.System_IntPtr);
}
}
private void EmitFunctionPointerTypeSignature(FunctionPointerType type, SignatureContext context)
{
SignatureCallingConvention callingConvention = (SignatureCallingConvention)(type.Signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask);
SignatureAttributes callingConventionAttributes = ((type.Signature.Flags & MethodSignatureFlags.Static) != 0 ? SignatureAttributes.None : SignatureAttributes.Instance);
EmitElementType(CorElementType.ELEMENT_TYPE_FNPTR);
EmitUInt((uint)((byte)callingConvention | (byte)callingConventionAttributes));
EmitUInt((uint)type.Signature.Length);
EmitTypeSignature(type.Signature.ReturnType, context);
for (int argIndex = 0; argIndex < type.Signature.Length; argIndex++)
{
EmitTypeSignature(type.Signature[argIndex], context);
}
}
private string GenerateArgumentsForTypeInfo(FunctionPointerType type)
{
var name = type.Name.AsString();
var lazyReturnType = $"_t_[{type.ReturnType.Name.AsString()}]"
.AsSingleLineLambda()
.WithTypeName("Type()");
var lazyParametersTypes = type.Parameters.Select(x => $"_t_[{x.Name.AsString()}]")
.AsArray()
.WithTypeName("Type[]").AsSingleLineLambda()
.WithTypeName("Type[]()");
return("\n" + name + ",\n" + lazyReturnType + ",\n" + lazyParametersTypes);
}
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();
}
private static string GetFriendlyFullFunctionPointerTypeName(this FunctionPointerType self, ILanguage language, bool includeNamespace = true)
/* End AGPL */
{
StringBuilder signature = new StringBuilder();
signature.Append(self.Function.Name);
signature.Append(" ");
/* AGPL */
signature.Append(self.Function.FixedReturnType.GetFriendlyFullName(language, includeNamespace));
/* End AGPL */
signature.Append(" *");
/* AGPL */
self.MethodSignatureFriendlyFullName(language, signature, false, includeNamespace);
/* End AGPL */
return(signature.ToString());
}
private FunctionPointerType ToFunctionPointer(ModuleDefinition module)
{
var fptr = new FunctionPointerType()
{
ReturnType = GetTypeReference(module, ReturnType),
HasThis = HasThis,
ExplicitThis = ExplicitThis,
CallingConvention = (MethodCallingConvention)CallingConvention - 1
};
foreach (var param in Parameters)
{
fptr.Parameters.Add(new ParameterDefinition(GetTypeReference(module, param)));
}
return(fptr);
}
public override void AppendName(StringBuilder sb, FunctionPointerType type)
{
MethodSignature signature = type.Signature;
AppendName(sb, signature.ReturnType);
sb.Append(" (");
for (int i = 0; i < signature.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
AppendName(sb, signature[i]);
}
sb.Append(')');
}
public override void AppendName(StringBuilder sb, FunctionPointerType type)
{
sb.Append(" ");
AppendName(sb, type.Signature.ReturnType);
sb.Append(" *");
sb.Append("(");
for (int i = 0; i < type.Signature.Length; i++)
{
var parameter = type.Signature[i];
if (i > 0)
{
sb.Append(",");
}
AppendName(sb, parameter);
}
sb.Append(")");
}
private bool IsAssignableToCore(FunctionPointerType self, IType type)
{
if (type is FunctionPointerType func)
{
//covariant
if (!IsAssignableTo(self.ReturnType, func.ReturnType))
{
return(false);
}
if (self.Parameters.Length != func.Parameters.Length)
{
return(false);
}
return(self.Parameters
.Zip(func.Parameters, (sPar, tPar) => (sPar, tPar))
//contravariant
.All(x => IsAssignableTo(x.tPar, x.sPar)));
}
return(false);
}
public override IType VisitFunctionPointerType(FunctionPointerType type)
{
builder.Append("method ");
type.ReturnType.AcceptVisitor(this);
builder.Append(" *(");
bool first = true;
foreach (var p in type.ParameterTypes)
{
if (first)
{
first = false;
}
else
{
builder.Append(", ");
}
p.AcceptVisitor(this);
}
builder.Append(')');
return(type);
}
public Type MakeFunctionPointer(__StandAloneMethodSig sig)
{
return(FunctionPointerType.Make(this, sig));
}
public override bool VisitFunctionPointerType(FunctionPointerType functionPointerType)
{
return(true);
}
private void EncodeType(BlobBuilder blobBuilder, TypeDesc type)
{
if (type.IsPrimitive)
{
SignatureTypeCode primitiveCode;
switch (type.Category)
{
case TypeFlags.Void:
primitiveCode = SignatureTypeCode.Void;
break;
case TypeFlags.Boolean:
primitiveCode = SignatureTypeCode.Boolean;
break;
case TypeFlags.Char:
primitiveCode = SignatureTypeCode.Char;
break;
case TypeFlags.SByte:
primitiveCode = SignatureTypeCode.SByte;
break;
case TypeFlags.Byte:
primitiveCode = SignatureTypeCode.Byte;
break;
case TypeFlags.Int16:
primitiveCode = SignatureTypeCode.Int16;
break;
case TypeFlags.UInt16:
primitiveCode = SignatureTypeCode.UInt16;
break;
case TypeFlags.Int32:
primitiveCode = SignatureTypeCode.Int32;
break;
case TypeFlags.UInt32:
primitiveCode = SignatureTypeCode.UInt32;
break;
case TypeFlags.Int64:
primitiveCode = SignatureTypeCode.Int64;
break;
case TypeFlags.UInt64:
primitiveCode = SignatureTypeCode.UInt64;
break;
case TypeFlags.IntPtr:
primitiveCode = SignatureTypeCode.IntPtr;
break;
case TypeFlags.UIntPtr:
primitiveCode = SignatureTypeCode.UIntPtr;
break;
case TypeFlags.Single:
primitiveCode = SignatureTypeCode.Single;
break;
case TypeFlags.Double:
primitiveCode = SignatureTypeCode.Double;
break;
default:
throw new Exception("Unknown primitive type");
}
blobBuilder.WriteByte((byte)primitiveCode);
}
else if (type.IsSzArray)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.SZArray);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsArray)
{
var arrayType = (ArrayType)type;
blobBuilder.WriteByte((byte)SignatureTypeCode.Array);
EncodeType(blobBuilder, type.GetParameterType());
var shapeEncoder = new ArrayShapeEncoder(blobBuilder);
// TODO Add support for non-standard array shapes
shapeEncoder.Shape(arrayType.Rank, default(ImmutableArray <int>), default(ImmutableArray <int>));
}
else if (type.IsPointer)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Pointer);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsFunctionPointer)
{
FunctionPointerType fnptrType = (FunctionPointerType)type;
EncodeMethodSignature(blobBuilder, fnptrType.Signature);
}
else if (type.IsByRef)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.ByReference);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsObject)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Object);
}
else if (type.IsString)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.String);
}
else if (type.IsWellKnownType(WellKnownType.TypedReference))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.TypedReference);
}
else if (type.IsWellKnownType(WellKnownType.Void))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Void);
}
else if (type is SignatureVariable)
{
SignatureVariable sigVar = (SignatureVariable)type;
SignatureTypeCode code = sigVar.IsMethodSignatureVariable ? SignatureTypeCode.GenericMethodParameter : SignatureTypeCode.GenericTypeParameter;
blobBuilder.WriteByte((byte)code);
blobBuilder.WriteCompressedInteger(sigVar.Index);
}
else if (type is InstantiatedType)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.GenericTypeInstance);
EncodeType(blobBuilder, type.GetTypeDefinition());
blobBuilder.WriteCompressedInteger(type.Instantiation.Length);
foreach (var instantiationArg in type.Instantiation)
{
EncodeType(blobBuilder, instantiationArg);
}
}
else if (type is MetadataType)
{
var metadataType = (MetadataType)type;
// Must be class or valuetype
blobBuilder.WriteByte(type.IsValueType ? (byte)SignatureTypeKind.ValueType : (byte)SignatureTypeKind.Class);
int codedIndex = CodedIndex.TypeDefOrRef(GetTypeRef(metadataType));
blobBuilder.WriteCompressedInteger(codedIndex);
}
else
{
throw new Exception("Unexpected type");
}
}
/// <summary>
/// Default ctor
/// </summary>
internal FunctionPointerTypeMethodReference(FunctionPointerType type)
{
this.type = type;
}
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).Append(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("``").Append(paramOrder);
}
else
{
CurrPath.Append("`").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.IsValueType)
// {
// // parameter is passed by reference
// CurrPath.Append(GetXmlDocParameterPath((tpType as ReferenceType).ElementType, false));
// CurrPath.Append("@");
// }
// else if (tpType is ModifierOptional)
// {
// // parameter has optional modifier
// ModifierOptional thisModOpt = tpType as ModifierOptional;
//
// CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ElementType, ExplicitMode));
// CurrPath.Append("!");
// CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ModifierType, ExplicitMode));
// }
// else if (tpType is ModifierRequired)
// {
// // parameter has required modifier
// ModifierRequired thisModReq = tpType as ModifierRequired;
//
// 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).Append(
((CanAppendSpecialExplicitChar() && ExplicitMode) ? tpType.Name.Replace(".", "#") : tpType.Name));
}
}
public static TypeReference InflateGenericType(GenericInstanceType genericInstanceProvider, TypeReference typeToInflate)
{
if (typeToInflate is ArrayType arrayType)
{
var inflatedElementType = InflateGenericType(genericInstanceProvider, arrayType.ElementType);
if (inflatedElementType != arrayType.ElementType)
{
return(new ArrayType(inflatedElementType, arrayType.Rank));
}
return(arrayType);
}
if (typeToInflate is GenericInstanceType genericInst)
{
return(MakeGenericType(genericInstanceProvider, genericInst));
}
if (typeToInflate is GenericParameter genericParameter)
{
if (genericParameter.Owner is MethodReference)
{
return(genericParameter);
}
var elementType = genericInstanceProvider.ElementType.Resolve();
var parameter = elementType.GenericParameters.Single(p => p == genericParameter);
return(genericInstanceProvider.GenericArguments[parameter.Position]);
}
if (typeToInflate is FunctionPointerType functionPointerType)
{
var result = new FunctionPointerType {
ReturnType = InflateGenericType(genericInstanceProvider, functionPointerType.ReturnType)
};
for (int i = 0; i < functionPointerType.Parameters.Count; i++)
{
var inflatedParameterType = InflateGenericType(genericInstanceProvider, functionPointerType.Parameters[i].ParameterType);
result.Parameters.Add(new ParameterDefinition(inflatedParameterType));
}
return(result);
}
if (typeToInflate is IModifierType modifierType)
{
var modifier = InflateGenericType(genericInstanceProvider, modifierType.ModifierType);
var elementType = InflateGenericType(genericInstanceProvider, modifierType.ElementType);
if (modifierType is OptionalModifierType)
{
return(new OptionalModifierType(modifier, elementType));
}
return(new RequiredModifierType(modifier, elementType));
}
if (typeToInflate is PinnedType pinnedType)
{
var elementType = InflateGenericType(genericInstanceProvider, pinnedType.ElementType);
if (elementType != pinnedType.ElementType)
{
return(new PinnedType(elementType));
}
return(pinnedType);
}
if (typeToInflate is PointerType pointerType)
{
var elementType = InflateGenericType(genericInstanceProvider, pointerType.ElementType);
if (elementType != pointerType.ElementType)
{
return(new PointerType(elementType));
}
return(pointerType);
}
if (typeToInflate is ByReferenceType byReferenceType)
{
var elementType = InflateGenericType(genericInstanceProvider, byReferenceType.ElementType);
if (elementType != byReferenceType.ElementType)
{
return(new ByReferenceType(elementType));
}
return(byReferenceType);
}
if (typeToInflate is SentinelType sentinelType)
{
var elementType = InflateGenericType(genericInstanceProvider, sentinelType.ElementType);
if (elementType != sentinelType.ElementType)
{
return(new SentinelType(elementType));
}
return(sentinelType);
}
return(typeToInflate);
}
