public EXPRMETHODINFO CreateMethodInfo(MethPropWithInst mwi)
{
return(CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs));
}
public static ExprMethodInfo CreateMethodInfo(MethPropWithInst mwi) => CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs);
public ExprMethodInfo CreateMethodInfo(MethPropWithInst mwi)
{
return(CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs));
}
private EXPRCALL BindUDUnopCall(EXPR arg, CType typeArg, MethPropWithInst mpwi)
{
CType typeRet = GetTypes().SubstType(mpwi.Meth().RetType, mpwi.GetType());
checkUnsafe(typeRet); // added to the binder so we don't bind to pointer ops
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, mpwi);
EXPRCALL call = GetExprFactory().CreateCall(0, typeRet, mustConvert(arg, typeArg), pMemGroup, null);
call.mwi = new MethWithInst(mpwi);
verifyMethodArgs(call, mpwi.GetType());
return call;
}
private EXPRCALL BindLiftedUDUnop(EXPR arg, CType typeArg, MethPropWithInst mpwi)
{
CType typeRaw = typeArg.StripNubs();
if (!arg.type.IsNullableType() || !canConvert(arg.type.StripNubs(), typeRaw, CONVERTTYPE.NOUDC))
{
// Convert then lift.
arg = mustConvert(arg, typeArg);
}
Debug.Assert(arg.type.IsNullableType());
CType typeRet = GetTypes().SubstType(mpwi.Meth().RetType, mpwi.GetType());
if (!typeRet.IsNullableType())
{
typeRet = GetTypes().GetNullable(typeRet);
}
// First bind the non-lifted version for errors.
EXPR nonLiftedArg = mustCast(arg, typeRaw);
EXPRCALL nonLiftedResult = BindUDUnopCall(nonLiftedArg, typeRaw, mpwi);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, mpwi);
EXPRCALL call = GetExprFactory().CreateCall(0, typeRet, arg, pMemGroup, null);
call.mwi = new MethWithInst(mpwi);
call.castOfNonLiftedResultToLiftedType = mustCast(nonLiftedResult, typeRet, 0);
call.nubLiftKind = NullableCallLiftKind.Operator;
return call;
}
private EXPRCALL BindLiftedUDBinop(ExpressionKind ek, EXPR arg1, EXPR arg2, TypeArray Params, MethPropWithInst mpwi)
{
EXPR exprVal1 = arg1;
EXPR exprVal2 = arg2;
TypeArray paramsRaw;
CType typeRet;
CType typeRetRaw = GetTypes().SubstType(mpwi.Meth().RetType, mpwi.GetType());
// This is a lifted user defined operator. We know that both arguments
// go to the nullable formal parameter types, and that at least one
// of the arguments does not go to the non-nullable formal parameter type.
// (If both went to the non-nullable types then we would not be lifting.)
// We also know that the non-nullable type of the argument goes to the
// non-nullable type of formal parameter. However, if it does so only via
// a user-defined conversion then we should bind the conversion from the
// argument to the nullable formal parameter type first, before we then
// do the cast for the non-nullable call.
paramsRaw = GetTypes().SubstTypeArray(mpwi.Meth().Params, mpwi.GetType());
Debug.Assert(Params != paramsRaw);
Debug.Assert(paramsRaw.Item(0) == Params.Item(0).GetBaseOrParameterOrElementType());
Debug.Assert(paramsRaw.Item(1) == Params.Item(1).GetBaseOrParameterOrElementType());
if (!canConvert(arg1.type.StripNubs(), paramsRaw.Item(0), CONVERTTYPE.NOUDC))
{
exprVal1 = mustConvert(arg1, Params.Item(0));
}
if (!canConvert(arg2.type.StripNubs(), paramsRaw.Item(1), CONVERTTYPE.NOUDC))
{
exprVal2 = mustConvert(arg2, Params.Item(1));
}
EXPR nonLiftedArg1 = mustCast(exprVal1, paramsRaw.Item(0));
EXPR nonLiftedArg2 = mustCast(exprVal2, paramsRaw.Item(1));
switch (ek)
{
default:
typeRet = GetTypes().GetNullable(typeRetRaw);
break;
case ExpressionKind.EK_EQ:
case ExpressionKind.EK_NE:
Debug.Assert(paramsRaw.Item(0) == paramsRaw.Item(1));
Debug.Assert(typeRetRaw.isPredefType(PredefinedType.PT_BOOL));
// These ones don't lift the return type. Instead, if either side is null, the result is false.
typeRet = typeRetRaw;
break;
case ExpressionKind.EK_GT:
case ExpressionKind.EK_GE:
case ExpressionKind.EK_LT:
case ExpressionKind.EK_LE:
Debug.Assert(typeRetRaw.isPredefType(PredefinedType.PT_BOOL));
// These ones don't lift the return type. Instead, if either side is null, the result is false.
typeRet = typeRetRaw;
break;
}
// Now get the result for the pre-lifted call.
Debug.Assert(!(ek == ExpressionKind.EK_EQ || ek == ExpressionKind.EK_NE) || nonLiftedArg1.type == nonLiftedArg2.type);
EXPRCALL nonLiftedResult = BindUDBinopCall(nonLiftedArg1, nonLiftedArg2, paramsRaw, typeRetRaw, mpwi);
EXPRLIST args = GetExprFactory().CreateList(exprVal1, exprVal2);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, mpwi);
EXPRCALL call = GetExprFactory().CreateCall(0, typeRet, args, pMemGroup, null);
call.mwi = new MethWithInst(mpwi);
switch (ek)
{
case ExpressionKind.EK_EQ:
call.nubLiftKind = NullableCallLiftKind.EqualityOperator;
break;
case ExpressionKind.EK_NE:
call.nubLiftKind = NullableCallLiftKind.InequalityOperator;
break;
default:
call.nubLiftKind = NullableCallLiftKind.Operator;
break;
}
call.castOfNonLiftedResultToLiftedType = mustCast(nonLiftedResult, typeRet, 0);
return call;
}
public EXPRMETHODINFO CreateMethodInfo(MethPropWithInst mwi)
{
return CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs);
}
