public EXPRMETHODINFO CreateMethodInfo(MethodSymbol method, AggregateType methodType, TypeArray methodParameters)
{
Debug.Assert(method != null);
Debug.Assert(methodType != null);
EXPRMETHODINFO methodInfo = new EXPRMETHODINFO();
CType type;
if (method.IsConstructor())
{
type = GetTypes().GetOptPredefAgg(PredefinedType.PT_CONSTRUCTORINFO).getThisType();
}
else
{
type = GetTypes().GetOptPredefAgg(PredefinedType.PT_METHODINFO).getThisType();
}
methodInfo.kind = ExpressionKind.EK_METHODINFO;
methodInfo.type = type;
methodInfo.flags = 0;
methodInfo.Method = new MethWithInst(method, methodType, methodParameters);
return(methodInfo);
}
/////////////////////////////////////////////////////////////////////////////////
private MethodInfo GetMethodInfoFromExpr(EXPRMETHODINFO methinfo)
{
// To do this, we need to construct a type array of the parameter types,
// get the parent constructed type, and get the method from it.
AggregateType aggType = methinfo.Method.Ats;
MethodSymbol methSym = methinfo.Method.Meth();
TypeArray genericParams = _typeManager.SubstTypeArray(methSym.Params, aggType, methSym.typeVars);
CType genericReturn = _typeManager.SubstType(methSym.RetType, aggType, methSym.typeVars);
Type type = aggType.AssociatedSystemType;
MethodInfo methodInfo = methSym.AssociatedMemberInfo as MethodInfo;
// This is to ensure that for embedded nopia types, we have the
// appropriate local type from the member itself; this is possible
// because nopia types are not generic or nested.
if (!type.GetTypeInfo().IsGenericType && !type.IsNested)
{
type = methodInfo.DeclaringType;
}
// We need to find the associated methodinfo on the instantiated type.
foreach (MethodInfo m in type.GetRuntimeMethods())
{
#if UNSUPPORTEDAPI
if ((m.MetadataToken != methodInfo.MetadataToken) || (m.Module != methodInfo.Module))
#else
if (!m.HasSameMetadataDefinitionAs(methodInfo))
#endif
{
continue;
}
Debug.Assert((m.Name == methodInfo.Name) &&
(m.GetParameters().Length == genericParams.size) &&
(TypesAreEqual(m.ReturnType, genericReturn.AssociatedSystemType)));
bool bMatch = true;
ParameterInfo[] parameters = m.GetParameters();
for (int i = 0; i < genericParams.size; i++)
{
if (!TypesAreEqual(parameters[i].ParameterType, genericParams.Item(i).AssociatedSystemType))
{
bMatch = false;
break;
}
}
if (bMatch)
{
if (m.IsGenericMethod)
{
int size = methinfo.Method.TypeArgs != null ? methinfo.Method.TypeArgs.size : 0;
Type[] typeArgs = new Type[size];
if (size > 0)
{
for (int i = 0; i < methinfo.Method.TypeArgs.size; i++)
{
typeArgs[i] = methinfo.Method.TypeArgs[i].AssociatedSystemType;
}
}
return m.MakeGenericMethod(typeArgs);
}
return m;
}
}
Debug.Assert(false, "Could not find matching method");
throw Error.InternalCompilerError();
}
/////////////////////////////////////////////////////////////////////////////////
private ConstructorInfo GetConstructorInfoFromExpr(EXPRMETHODINFO methinfo)
{
// To do this, we need to construct a type array of the parameter types,
// get the parent constructed type, and get the method from it.
AggregateType aggType = methinfo.Method.Ats;
MethodSymbol methSym = methinfo.Method.Meth();
TypeArray genericInstanceParams = _typeManager.SubstTypeArray(methSym.Params, aggType);
Type type = aggType.AssociatedSystemType;
ConstructorInfo ctorInfo = (ConstructorInfo)methSym.AssociatedMemberInfo;
// This is to ensure that for embedded nopia types, we have the
// appropriate local type from the member itself; this is possible
// because nopia types are not generic or nested.
if (!type.GetTypeInfo().IsGenericType && !type.IsNested)
{
type = ctorInfo.DeclaringType;
}
foreach (ConstructorInfo c in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static))
{
#if UNSUPPORTEDAPI
if ((c.MetadataToken != ctorInfo.MetadataToken) || (c.Module != ctorInfo.Module))
#else
if (!c.HasSameMetadataDefinitionAs(ctorInfo))
#endif
{
continue;
}
Debug.Assert(c.GetParameters() == null || c.GetParameters().Length == genericInstanceParams.size);
bool bMatch = true;
ParameterInfo[] parameters = c.GetParameters();
for (int i = 0; i < genericInstanceParams.size; i++)
{
if (!TypesAreEqual(parameters[i].ParameterType, genericInstanceParams.Item(i).AssociatedSystemType))
{
bMatch = false;
break;
}
}
if (bMatch)
{
return c;
}
}
Debug.Assert(false, "Could not find matching constructor");
throw Error.InternalCompilerError();
}
protected virtual EXPR VisitMETHODINFO(EXPRMETHODINFO pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitMETHODINFO(EXPRMETHODINFO pExpr)
{
return(VisitEXPR(pExpr));
}
public EXPRMETHODINFO CreateMethodInfo(MethodSymbol method, AggregateType methodType, TypeArray methodParameters)
{
Debug.Assert(method != null);
Debug.Assert(methodType != null);
EXPRMETHODINFO methodInfo = new EXPRMETHODINFO();
CType type;
if (method.IsConstructor())
{
type = GetTypes().GetOptPredefAgg(PredefinedType.PT_CONSTRUCTORINFO).getThisType();
}
else
{
type = GetTypes().GetOptPredefAgg(PredefinedType.PT_METHODINFO).getThisType();
}
methodInfo.kind = ExpressionKind.EK_METHODINFO;
methodInfo.type = type;
methodInfo.flags = 0;
methodInfo.Method = new MethWithInst(method, methodType, methodParameters);
return methodInfo;
}
