public MethodSpec MakeGenericMethod (IMemberContext context, params TypeSpec[] targs)
{
if (targs == null)
throw new ArgumentNullException ();
// TODO MemberCache
// if (generic_intances != null && generic_intances.TryGetValue (targs, out ginstance))
// return ginstance;
//if (generic_intances == null)
// generic_intances = new Dictionary<TypeSpec[], Method> (TypeSpecArrayComparer.Default);
var inflator = new TypeParameterInflator (context, DeclaringType, GenericDefinition.TypeParameters, targs);
var inflated = (MethodSpec) MemberwiseClone ();
inflated.declaringType = inflator.TypeInstance;
inflated.returnType = inflator.Inflate (returnType);
inflated.parameters = parameters.Inflate (inflator);
inflated.targs = targs;
inflated.constraints = TypeParameterSpec.InflateConstraints (inflator, constraints ?? GenericDefinition.TypeParameters);
inflated.state |= StateFlags.PendingMakeMethod;
// if (inflated.parent == null)
// inflated.parent = parent;
//generic_intances.Add (targs, inflated);
return inflated;
}
public override MemberSpec InflateMember (TypeParameterInflator inflator)
{
var fs = (FieldSpec) base.InflateMember (inflator);
fs.memberType = inflator.Inflate (memberType);
return fs;
}
public override MemberSpec InflateMember (TypeParameterInflator inflator)
{
var ps = (PropertySpec) base.InflateMember (inflator);
ps.memberType = inflator.Inflate (memberType);
return ps;
}
public override MemberSpec InflateMember (TypeParameterInflator inflator)
{
var ms = (MethodSpec) base.InflateMember (inflator);
ms.inflatedMetaInfo = null;
ms.returnType = inflator.Inflate (returnType);
ms.parameters = parameters.Inflate (inflator);
if (IsGeneric)
ms.constraints = TypeParameterSpec.InflateConstraints (inflator, Constraints);
return ms;
}
public AParametersCollection Inflate (TypeParameterInflator inflator)
{
TypeSpec[] inflated_types = null;
bool default_value = false;
for (int i = 0; i < Count; ++i) {
var inflated_param = inflator.Inflate (types[i]);
if (inflated_types == null) {
if (inflated_param == types[i])
continue;
default_value |= FixedParameters[i].HasDefaultValue;
inflated_types = new TypeSpec[types.Length];
Array.Copy (types, inflated_types, types.Length);
} else {
if (inflated_param == types[i])
continue;
default_value |= FixedParameters[i].HasDefaultValue;
}
inflated_types[i] = inflated_param;
}
if (inflated_types == null)
return this;
var clone = (AParametersCollection) MemberwiseClone ();
clone.types = inflated_types;
//
// Default expression is original expression from the parameter
// declaration context which can be of nested enum in generic class type.
// In such case we end up with expression type of G<T>.E and e.g. parameter
// type of G<int>.E and conversion would fail without inflate in this
// context.
//
if (default_value) {
clone.parameters = new IParameterData[Count];
for (int i = 0; i < Count; ++i) {
var fp = FixedParameters[i];
clone.FixedParameters[i] = fp;
if (!fp.HasDefaultValue)
continue;
var expr = fp.DefaultValue;
if (inflated_types[i] == expr.Type)
continue;
var c = expr as Constant;
if (c != null) {
//
// It may fail we are inflating before type validation is done
//
c = Constant.ExtractConstantFromValue (inflated_types[i], c.GetValue (), expr.Location);
if (c == null)
expr = new DefaultValueExpression (new TypeExpression (inflated_types[i], expr.Location), expr.Location);
else
expr = c;
} else if (expr is DefaultValueExpression)
expr = new DefaultValueExpression (new TypeExpression (inflated_types[i], expr.Location), expr.Location);
clone.FixedParameters[i] = new ParameterData (fp.Name, fp.ModFlags, expr);
}
}
return clone;
}
public override MemberSpec InflateMember (TypeParameterInflator inflator)
{
var es = (EventSpec) base.InflateMember (inflator);
es.MemberType = inflator.Inflate (MemberType);
if (backing_field != null)
es.backing_field = (FieldSpec) backing_field.InflateMember (inflator);
return es;
}
public AParametersCollection Inflate (TypeParameterInflator inflator)
{
TypeSpec[] inflated_types = null;
bool default_value = false;
for (int i = 0; i < Count; ++i) {
var inflated_param = inflator.Inflate (types[i]);
if (inflated_types == null) {
if (inflated_param == types[i])
continue;
default_value |= FixedParameters[i] is DefaultValueExpression;
inflated_types = new TypeSpec[types.Length];
Array.Copy (types, inflated_types, types.Length);
}
inflated_types[i] = inflated_param;
}
if (inflated_types == null)
return this;
var clone = (AParametersCollection) MemberwiseClone ();
clone.types = inflated_types;
if (default_value) {
for (int i = 0; i < Count; ++i) {
var dve = clone.FixedParameters[i] as DefaultValueExpression;
if (dve != null) {
throw new NotImplementedException ("net");
// clone.FixedParameters [i].DefaultValue = new DefaultValueExpression ();
}
}
}
return clone;
}
public override MemberSpec InflateMember (TypeParameterInflator inflator)
{
var es = (EventSpec) base.InflateMember (inflator);
es.MemberType = inflator.Inflate (MemberType);
return es;
}
public void InflateConstraints (TypeParameterInflator inflator, TypeParameterSpec tps)
{
tps.BaseType = inflator.Inflate (BaseType);
if (ifaces != null) {
tps.ifaces = new List<TypeSpec> (ifaces.Count);
for (int i = 0; i < ifaces.Count; ++i)
tps.ifaces.Add (inflator.Inflate (ifaces[i]));
}
if (targs != null) {
tps.targs = new TypeSpec[targs.Length];
for (int i = 0; i < targs.Length; ++i)
tps.targs[i] = inflator.Inflate (targs[i]);
}
}
protected override void InitializeMemberCache (bool onlyTypes)
{
if (cache == null)
cache = new MemberCache (onlyTypes ? open_type.MemberCacheTypes : open_type.MemberCache);
TypeParameterSpec[] tparams_full;
TypeSpec[] targs_full = targs;
if (IsNested) {
//
// Special case is needed when we are inflating an open type (nested type definition)
// on inflated parent. Consider following case
//
// Foo<T>.Bar<U> => Foo<string>.Bar<U>
//
// Any later inflation of Foo<string>.Bar<U> has to also inflate T if used inside Bar<U>
//
List<TypeSpec> merged_targs = null;
List<TypeParameterSpec> merged_tparams = null;
var type = DeclaringType;
do {
if (type.TypeArguments.Length > 0) {
if (merged_targs == null) {
merged_targs = new List<TypeSpec> ();
merged_tparams = new List<TypeParameterSpec> ();
if (targs.Length > 0) {
merged_targs.AddRange (targs);
merged_tparams.AddRange (open_type.MemberDefinition.TypeParameters);
}
}
merged_tparams.AddRange (type.MemberDefinition.TypeParameters);
merged_targs.AddRange (type.TypeArguments);
}
type = type.DeclaringType;
} while (type != null);
if (merged_targs != null) {
// Type arguments are not in the right order but it should not matter in this case
targs_full = merged_targs.ToArray ();
tparams_full = merged_tparams.ToArray ();
} else if (targs.Length == 0) {
tparams_full = TypeParameterSpec.EmptyTypes;
} else {
tparams_full = open_type.MemberDefinition.TypeParameters;
}
} else if (targs.Length == 0) {
tparams_full = TypeParameterSpec.EmptyTypes;
} else {
tparams_full = open_type.MemberDefinition.TypeParameters;
}
var inflator = new TypeParameterInflator (this, tparams_full, targs_full);
//
// Two stage inflate due to possible nested types recursive
// references
//
// class A<T> {
// B b;
// class B {
// T Value;
// }
// }
//
// When resolving type of `b' members of `B' cannot be
// inflated because are not yet available in membercache
//
if ((state & StateFlags.PendingMemberCacheMembers) == 0) {
open_type.MemberCacheTypes.InflateTypes (cache, inflator);
//
// Inflate any implemented interfaces
//
if (open_type.Interfaces != null) {
ifaces = new List<TypeSpec> (open_type.Interfaces.Count);
foreach (var iface in open_type.Interfaces) {
var iface_inflated = inflator.Inflate (iface);
AddInterface (iface_inflated);
}
}
//
// Handles the tricky case of recursive nested base generic type
//
// class A<T> : Base<A<T>.Nested> {
// class Nested {}
// }
//
// When inflating A<T>. base type is not yet known, secondary
// inflation is required (not common case) once base scope
// is known
//
if (open_type.BaseType == null) {
if (IsClass)
state |= StateFlags.PendingBaseTypeInflate;
} else {
BaseType = inflator.Inflate (open_type.BaseType);
}
} else if ((state & StateFlags.PendingBaseTypeInflate) != 0) {
BaseType = inflator.Inflate (open_type.BaseType);
state &= ~StateFlags.PendingBaseTypeInflate;
}
if (onlyTypes) {
state |= StateFlags.PendingMemberCacheMembers;
return;
}
var tc = open_type.MemberDefinition as TypeContainer;
if (tc != null && !tc.HasMembersDefined)
throw new InternalErrorException ("Inflating MemberCache with undefined members");
if ((state & StateFlags.PendingBaseTypeInflate) != 0) {
BaseType = inflator.Inflate (open_type.BaseType);
state &= ~StateFlags.PendingBaseTypeInflate;
}
state &= ~StateFlags.PendingMemberCacheMembers;
open_type.MemberCache.InflateMembers (cache, open_type, inflator);
}
public override MemberSpec InflateMember(TypeParameterInflator inflator)
{
var tps = (TypeParameterSpec) MemberwiseClone ();
tps.BaseType = inflator.Inflate (BaseType);
if (ifaces != null) {
tps.ifaces = new TypeSpec[ifaces.Count];
for (int i = 0; i < ifaces.Count; ++i)
tps.ifaces[i] = inflator.Inflate (ifaces[i]);
}
if (targs != null) {
tps.targs = new TypeSpec[targs.Length];
for (int i = 0; i < targs.Length; ++i)
tps.targs[i] = inflator.Inflate (targs[i]);
}
return tps;
}
