public void Substitute(GenericParameterCollection methodParams)
{
if (ReturnType != null)
{
ReturnType.Resolve(ref ReturnType, ParentType.GenericParameters, methodParams);
}
Parameters.ForEach(p => p.Substitute());
Locals.ForEach(l => l.Substitute());
Instructions.ForEach(i => i.Substitute());
}
public void Substitute(GenericParameterCollection typeParams, GenericParameterCollection methodParams)
{
for (int i = 0; i < mParams.Count; i++)
{
IRType t = mParams[i];
t.Resolve(ref t, typeParams, methodParams);
mParams[i] = t;
}
mHashCodeCache = null;
mResolvedCache = null;
}
/// <summary>
/// Resolve any generic types used in this type.
/// </summary>
/// <param name="selfReference"></param>
/// <param name="typeParams"></param>
/// <param name="methodParams"></param>
public void Resolve(ref IRType selfReference, GenericParameterCollection typeParams, GenericParameterCollection methodParams)
{
if (!Resolved)
{
if (IsGeneric)
{
if (IsTemporaryVar)
{
selfReference = typeParams[this.TemporaryVarOrMVarIndex];
}
else if (IsTemporaryMVar)
{
selfReference = methodParams[this.TemporaryVarOrMVarIndex];
}
else if (IsArrayType)
{
IRType elemType = ArrayType;
elemType.Resolve(ref elemType, typeParams, methodParams);
selfReference = Assembly.AppDomain.GetArrayType(elemType);
}
else if (this.GenericParameters.Resolved)
{
IRType tp = null;
if (!GenericTypes.TryGetValue(this, out tp))
{
tp = this.GenericType.Clone();
tp.GenericParameters.Substitute(typeParams, methodParams);
GenericTypes[tp] = tp;
for (int i = 0; i < tp.GenericParameters.Count; i++)
{
tp.GenericParameters[i] = this.GenericParameters[i];
}
for (int i = 0; i < tp.Methods.Count; i++)
{
tp.Methods[i] = tp.Methods[i].Resolved ? tp.Methods[i] : tp.Methods[i].Clone(tp);
}
tp.Substitute(typeParams, methodParams);
}
selfReference = tp;
}
else
{
#warning Need to do the rest of this resolution.
}
}
else
{
Substitute(GenericParameterCollection.Empty, GenericParameterCollection.Empty);
}
}
}
/// <summary>
/// Resolves generic parameters within this type.
/// </summary>
/// <param name="typeParams"></param>
/// <param name="methodParams"></param>
public void Substitute(GenericParameterCollection typeParams, GenericParameterCollection methodParams)
{
this.GenericParameters.Substitute(typeParams, methodParams);
if (!GenericParameters.Resolved)
{
return;
}
if (this.BaseType != null)
{
this.BaseType.Resolve(ref this.BaseType, this.GenericParameters, GenericParameterCollection.Empty);
}
this.Fields.ForEach(f => f.Substitute());
this.Methods.ForEach(m => m.Substitute(GenericParameterCollection.Empty));
}
public void Resolve(GenericParameterCollection typeParams, GenericParameterCollection methodParams)
{
}
