|
public CreateMemGroup ( |
||
| pObject | ||
| mwi | ||
| return | Microsoft.CSharp.RuntimeBinder.Semantics.EXPRMEMGRP | |
/////////////////////////////////////////////////////////////////////////////////
// Expression types.
private ExprBinOp VisitBoundLambda(ExprBoundLambda anonmeth)
{
Debug.Assert(anonmeth != null);
MethodSymbol lambdaMethod = GetPreDefMethod(PREDEFMETH.PM_EXPRESSION_LAMBDA);
AggregateType delegateType = anonmeth.DelegateType;
TypeArray lambdaTypeParams = TypeArray.Allocate(delegateType);
AggregateType expressionType = SymbolLoader.GetPredefindType(PredefinedType.PT_EXPRESSION);
MethWithInst mwi = new MethWithInst(lambdaMethod, expressionType, lambdaTypeParams);
Expr createParameters = CreateWraps(anonmeth);
Debug.Assert(createParameters != null);
Debug.Assert(anonmeth.Expression != null);
Expr body = Visit(anonmeth.Expression);
Debug.Assert(anonmeth.ArgumentScope.nextChild == null);
Expr parameters = GenerateParamsArray(null, PredefinedType.PT_PARAMETEREXPRESSION);
Expr args = ExprFactory.CreateList(body, parameters);
CType typeRet = TypeManager.SubstType(mwi.Meth().RetType, mwi.GetType(), mwi.TypeArgs);
ExprMemberGroup pMemGroup = ExprFactory.CreateMemGroup(null, mwi);
ExprCall call = ExprFactory.CreateCall(0, typeRet, args, pMemGroup, mwi);
call.PredefinedMethod = PREDEFMETH.PM_EXPRESSION_LAMBDA;
return(ExprFactory.CreateSequence(createParameters, call));
}
// Create an expr for new T?(exprSrc) where T is exprSrc.type.
private static ExprCall BindNubNew(Expr exprSrc)
{
Debug.Assert(exprSrc != null);
NullableType pNubSourceType = TypeManager.GetNullable(exprSrc.Type);
AggregateType pSourceType = pNubSourceType.GetAts();
MethodSymbol meth = PredefinedMembers.GetMethod(PREDEFMETH.PM_G_OPTIONAL_CTOR);
MethWithInst methwithinst = new MethWithInst(meth, pSourceType, TypeArray.Empty);
ExprMemberGroup memgroup = ExprFactory.CreateMemGroup(null, methwithinst);
return(ExprFactory.CreateCall(EXPRFLAG.EXF_NEWOBJCALL | EXPRFLAG.EXF_CANTBENULL, pNubSourceType, exprSrc, memgroup, methwithinst));
}
private static ExprCall GenerateCall(PREDEFMETH pdm, Expr arg1, Expr arg2, Expr arg3, Expr arg4)
{
MethodSymbol method = GetPreDefMethod(pdm);
if (method == null)
{
return(null);
}
AggregateType expressionType = SymbolLoader.GetPredefindType(PredefinedType.PT_EXPRESSION);
Expr args = ExprFactory.CreateList(arg1, arg2, arg3, arg4);
MethWithInst mwi = new MethWithInst(method, expressionType);
ExprMemberGroup pMemGroup = ExprFactory.CreateMemGroup(null, mwi);
ExprCall call = ExprFactory.CreateCall(0, mwi.Meth().RetType, args, pMemGroup, mwi);
call.PredefinedMethod = pdm;
return(call);
}
private static ExprCall GenerateCall(PREDEFMETH pdm, Expr arg1)
{
MethodSymbol method = GetPreDefMethod(pdm);
// this should be enforced in an earlier pass and the transform pass should not
// be handling this error
if (method == null)
{
return(null);
}
AggregateType expressionType = SymbolLoader.GetPredefindType(PredefinedType.PT_EXPRESSION);
MethWithInst mwi = new MethWithInst(method, expressionType);
ExprMemberGroup pMemGroup = ExprFactory.CreateMemGroup(null, mwi);
ExprCall call = ExprFactory.CreateCall(0, mwi.Meth().RetType, arg1, pMemGroup, mwi);
call.PredefinedMethod = pdm;
return(call);
}
// Create an expr for exprSrc.Value where exprSrc.type is a NullableType.
private static Expr BindNubValue(Expr exprSrc)
{
Debug.Assert(exprSrc != null && exprSrc.Type is NullableType);
// For new T?(x), the answer is x.
if (IsNullableConstructor(exprSrc, out ExprCall call))
{
Expr args = call.OptionalArguments;
Debug.Assert(args != null && !(args is ExprList));
return(args);
}
NullableType nubSrc = (NullableType)exprSrc.Type;
CType typeBase = nubSrc.UnderlyingType;
AggregateType ats = nubSrc.GetAts();
PropertySymbol prop = PredefinedMembers.GetProperty(PREDEFPROP.PP_G_OPTIONAL_VALUE);
PropWithType pwt = new PropWithType(prop, ats);
MethPropWithInst mpwi = new MethPropWithInst(prop, ats);
ExprMemberGroup pMemGroup = ExprFactory.CreateMemGroup(exprSrc, mpwi);
return(ExprFactory.CreateProperty(typeBase, null, null, pMemGroup, pwt, null));
}
/***************************************************************************************************
* Called by BindImplicitConversion when the destination type is Nullable<T>. The following
* conversions are handled by this method:
*
* For S in { object, ValueType, interfaces implemented by underlying type} there is an explicit
* unboxing conversion S => T?
* System.Enum => T? there is an unboxing conversion if T is an enum type
* null => T? implemented as default(T?)
*
* Implicit T?* => T?+ implemented by either wrapping or calling GetValueOrDefault the
* appropriate number of times.
* If imp/exp S => T then imp/exp S => T?+ implemented by converting to T then wrapping the
* appropriate number of times.
* If imp/exp S => T then imp/exp S?+ => T?+ implemented by calling GetValueOrDefault (m-1) times
* then calling HasValue, producing a null if it returns false, otherwise calling Value,
* converting to T then wrapping the appropriate number of times.
*
* The 3 rules above can be summarized with the following recursive rules:
*
* If imp/exp S => T? then imp/exp S? => T? implemented as
* qs.HasValue ? (T?)(qs.Value) : default(T?)
* If imp/exp S => T then imp/exp S => T? implemented as new T?((T)s)
*
* This method also handles calling bindUserDefinedConverion. This method does NOT handle
* the following conversions:
*
* Implicit boxing conversion from S? to { object, ValueType, Enum, ifaces implemented by S }. (Handled by BindImplicitConversion.)
* If imp/exp S => T then explicit S?+ => T implemented by calling Value the appropriate number
* of times. (Handled by BindExplicitConversion.)
*
* The recursive equivalent is:
*
* If imp/exp S => T and T is not nullable then explicit S? => T implemented as qs.Value
*
* Some nullable conversion are NOT standard conversions. In particular, if S => T is implicit
* then S? => T is not standard. Similarly if S => T is not implicit then S => T? is not standard.
***************************************************************************************************/
private bool BindNubConversion(NullableType nubDst)
{
// This code assumes that STANDARD and ISEXPLICIT are never both set.
// bindUserDefinedConversion should ensure this!
Debug.Assert(0 != (~_flags & (CONVERTTYPE.STANDARD | CONVERTTYPE.ISEXPLICIT)));
Debug.Assert(_exprSrc == null || _exprSrc.Type == _typeSrc);
Debug.Assert(!_needsExprDest || _exprSrc != null);
Debug.Assert(_typeSrc != nubDst); // BindImplicitConversion should have taken care of this already.
AggregateType atsDst = nubDst.GetAts();
// Check for the unboxing conversion. This takes precedence over the wrapping conversions.
if (SymbolLoader.HasBaseConversion(nubDst.UnderlyingType, _typeSrc) && !CConversions.FWrappingConv(_typeSrc, nubDst))
{
// These should be different! Fix the caller if typeSrc is an AggregateType of Nullable.
Debug.Assert(atsDst != _typeSrc);
// typeSrc is a base type of the destination nullable type so there is an explicit
// unboxing conversion.
if (0 == (_flags & CONVERTTYPE.ISEXPLICIT))
{
return(false);
}
if (_needsExprDest)
{
_binder.bindSimpleCast(_exprSrc, _typeDest, out _exprDest, EXPRFLAG.EXF_UNBOX);
}
return(true);
}
bool dstWasNullable;
bool srcWasNullable;
CType typeDstBase = nubDst.StripNubs(out dstWasNullable);
CType typeSrcBase = _typeSrc.StripNubs(out srcWasNullable);
ConversionFunc pfn = (_flags & CONVERTTYPE.ISEXPLICIT) != 0 ?
(ConversionFunc)_binder.BindExplicitConversion :
(ConversionFunc)_binder.BindImplicitConversion;
if (!srcWasNullable)
{
Debug.Assert(_typeSrc == typeSrcBase);
// The null type can be implicitly converted to T? as the default value.
if (_typeSrc is NullType)
{
// If we have the constant null, generate it as a default value of T?. If we have
// some wacky expression which has been determined to be always null, like (null??null)
// keep it in its expression form and transform it in the nullable rewrite pass.
if (_needsExprDest)
{
_exprDest = _exprSrc is ExprConstant
? ExprFactory.CreateZeroInit(nubDst)
: ExprFactory.CreateCast(_typeDest, _exprSrc);
}
return(true);
}
Expr exprTmp = _exprSrc;
// If there is an implicit/explicit S => T then there is an implicit/explicit S => T?
if (_typeSrc == typeDstBase || pfn(_exprSrc, _typeSrc, typeDstBase, _needsExprDest, out exprTmp, _flags | CONVERTTYPE.NOUDC))
{
if (_needsExprDest)
{
ExprUserDefinedConversion exprUDC = exprTmp as ExprUserDefinedConversion;
if (exprUDC != null)
{
exprTmp = exprUDC.UserDefinedCall;
}
if (dstWasNullable)
{
ExprCall call = BindNubNew(exprTmp);
exprTmp = call;
call.NullableCallLiftKind = NullableCallLiftKind.NullableConversionConstructor;
}
if (exprUDC != null)
{
exprUDC.UserDefinedCall = exprTmp;
exprTmp = exprUDC;
}
Debug.Assert(exprTmp.Type == nubDst);
_exprDest = exprTmp;
}
return(true);
}
// No builtin conversion. Maybe there is a user defined conversion....
return(0 == (_flags & CONVERTTYPE.NOUDC) && _binder.bindUserDefinedConversion(_exprSrc, _typeSrc, nubDst, _needsExprDest, out _exprDest, 0 == (_flags & CONVERTTYPE.ISEXPLICIT)));
}
// Both are Nullable so there is only a conversion if there is a conversion between the base types.
// That is, if there is an implicit/explicit S => T then there is an implicit/explicit S?+ => T?+.
if (typeSrcBase != typeDstBase && !pfn(null, typeSrcBase, typeDstBase, false, out _exprDest, _flags | CONVERTTYPE.NOUDC))
{
// No builtin conversion. Maybe there is a user defined conversion....
return(0 == (_flags & CONVERTTYPE.NOUDC) && _binder.bindUserDefinedConversion(_exprSrc, _typeSrc, nubDst, _needsExprDest, out _exprDest, 0 == (_flags & CONVERTTYPE.ISEXPLICIT)));
}
if (_needsExprDest)
{
MethWithInst mwi = new MethWithInst(null, null);
ExprMemberGroup pMemGroup = ExprFactory.CreateMemGroup(null, mwi);
ExprCall exprDst = ExprFactory.CreateCall(0, nubDst, _exprSrc, pMemGroup, null);
// Here we want to first check whether or not the conversions work on the base types.
Expr arg1 = _binder.mustCast(_exprSrc, typeSrcBase);
bool convertible = (_flags & CONVERTTYPE.ISEXPLICIT) != 0
? _binder.BindExplicitConversion(
arg1, arg1.Type, typeDstBase, out arg1, _flags | CONVERTTYPE.NOUDC)
: _binder.BindImplicitConversion(
arg1, arg1.Type, typeDstBase, out arg1, _flags | CONVERTTYPE.NOUDC);
if (!convertible)
{
Debug.Fail("bind(Im|Ex)plicitConversion failed unexpectedly");
return(false);
}
exprDst.CastOfNonLiftedResultToLiftedType = _binder.mustCast(arg1, nubDst, 0);
exprDst.NullableCallLiftKind = NullableCallLiftKind.NullableConversion;
exprDst.PConversions = exprDst.CastOfNonLiftedResultToLiftedType;
_exprDest = exprDst;
}
return(true);
}
