public EXPRFIELD CreateField(EXPRFLAG nFlags, CType pType, EXPR pOptionalObject, uint nOffset, FieldWithType FWT, EXPR pOptionalLHS)
{
Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY)));
EXPRFIELD rval = new EXPRFIELD();
rval.kind = ExpressionKind.EK_FIELD;
rval.type = pType;
rval.flags = nFlags;
rval.SetOptionalObject(pOptionalObject);
if (FWT != null)
{
rval.fwt = FWT;
}
Debug.Assert(rval != null);
return (rval);
}
public EXPRFIELD CreateField(EXPRFLAG nFlags, CType pType, EXPR pOptionalObject, uint nOffset, FieldWithType FWT, EXPR pOptionalLHS)
{
Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY)));
EXPRFIELD rval = new EXPRFIELD();
rval.kind = ExpressionKind.EK_FIELD;
rval.type = pType;
rval.flags = nFlags;
rval.SetOptionalObject(pOptionalObject);
if (FWT != null)
{
rval.fwt = FWT;
}
Debug.Assert(rval != null);
return(rval);
}
public ExprField CreateField(CType type, Expr optionalObject, FieldWithType field, bool isLValue) => new ExprField(type, optionalObject, field, isLValue);
public ExprField CreateField(EXPRFLAG nFlags, CType pType, Expr pOptionalObject, uint nOffset, FieldWithType FWT, Expr pOptionalLHS)
{
Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY)));
ExprField rval = new ExprField();
rval.Kind = ExpressionKind.EK_FIELD;
rval.Type = pType;
rval.Flags = nFlags;
rval.OptionalObject = pOptionalObject;
if (FWT != null)
{
rval.FieldWithType = FWT;
}
Debug.Assert(rval != null);
return(rval);
}
/////////////////////////////////////////////////////////////////////////////////
private static EXPR GenerateOptionalArgument(
SymbolLoader symbolLoader,
ExprFactory exprFactory,
MethodOrPropertySymbol methprop,
CType type,
int index)
{
CType pParamType = type;
CType pRawParamType = type.IsNullableType() ? type.AsNullableType().GetUnderlyingType() : type;
EXPR optionalArgument = null;
if (methprop.HasDefaultParameterValue(index))
{
CType pConstValType = methprop.GetDefaultParameterValueConstValType(index);
CONSTVAL cv = methprop.GetDefaultParameterValue(index);
if (pConstValType.isPredefType(PredefinedType.PT_DATETIME) &&
(pRawParamType.isPredefType(PredefinedType.PT_DATETIME) || pRawParamType.isPredefType(PredefinedType.PT_OBJECT) || pRawParamType.isPredefType(PredefinedType.PT_VALUE)))
{
// This is the specific case where we want to create a DateTime
// but the constval that stores it is a long.
AggregateType dateTimeType = symbolLoader.GetReqPredefType(PredefinedType.PT_DATETIME);
optionalArgument = exprFactory.CreateConstant(dateTimeType, new CONSTVAL(DateTime.FromBinary(cv.longVal)));
}
else if (pConstValType.isSimpleOrEnumOrString())
{
// In this case, the constval is a simple type (all the numerics, including
// decimal), or an enum or a string. This covers all the substantial values,
// and everything else that can be encoded is just null or default(something).
// For enum parameters, we create a constant of the enum type. For everything
// else, we create the appropriate constant.
if (pRawParamType.isEnumType() && pConstValType == pRawParamType.underlyingType())
{
optionalArgument = exprFactory.CreateConstant(pRawParamType, cv);
}
else
{
optionalArgument = exprFactory.CreateConstant(pConstValType, cv);
}
}
else if ((pParamType.IsRefType() || pParamType.IsNullableType()) && cv.IsNullRef())
{
// We have an "= null" default value with a reference type or a nullable type.
optionalArgument = exprFactory.CreateNull();
}
else
{
// We have a default value that is encoded as a nullref, and that nullref is
// interpreted as default(something). For instance, the pParamType could be
// a type parameter type or a non-simple value type.
optionalArgument = exprFactory.CreateZeroInit(pParamType);
}
}
else
{
// There was no default parameter specified, so generally use default(T),
// except for some cases when the parameter type in metatdata is object.
if (pParamType.isPredefType(PredefinedType.PT_OBJECT))
{
if (methprop.MarshalAsObject(index))
{
// For [opt] parameters of type object, if we have marshal(iunknown),
// marshal(idispatch), or marshal(interface), then we emit a null.
optionalArgument = exprFactory.CreateNull();
}
else
{
// Otherwise, we generate Type.Missing
AggregateSymbol agg = symbolLoader.GetOptPredefAgg(PredefinedType.PT_MISSING);
Name name = symbolLoader.GetNameManager().GetPredefinedName(PredefinedName.PN_CAP_VALUE);
FieldSymbol field = symbolLoader.LookupAggMember(name, agg, symbmask_t.MASK_FieldSymbol).AsFieldSymbol();
FieldWithType fwt = new FieldWithType(field, agg.getThisType());
EXPRFIELD exprField = exprFactory.CreateField(0, agg.getThisType(), null, 0, fwt, null);
if (agg.getThisType() != type)
{
optionalArgument = exprFactory.CreateCast(0, type, exprField);
}
else
{
optionalArgument = exprField;
}
}
}
else
{
// Every type aside from object that doesn't have a default value gets
// its default value.
optionalArgument = exprFactory.CreateZeroInit(pParamType);
}
}
Debug.Assert(optionalArgument != null);
optionalArgument.IsOptionalArgument = true;
return optionalArgument;
}
/////////////////////////////////////////////////////////////////////////////////
private EXPR CreateField(
SymWithType swt,
EXPR callingObject)
{
// For a field, simply create the EXPRFIELD and our caller takes care of the rest.
FieldSymbol fieldSymbol = swt.Field();
CType returnType = fieldSymbol.GetType();
AggregateType fieldType = swt.GetType();
FieldWithType fwt = new FieldWithType(fieldSymbol, fieldType);
EXPR field = _binder.BindToField(callingObject.isCLASS() ? null : callingObject, fwt, 0);
return field;
}
////////////////////////////////////////////////////////////////////////////////
internal EXPR BindToField(EXPR pOptionalObject, FieldWithType fwt, BindingFlag bindFlags, EXPR pOptionalLHS)
{
Debug.Assert(fwt.GetType() != null && fwt.Field().getClass() == fwt.GetType().getAggregate());
CType pFieldType = GetTypes().SubstType(fwt.Field().GetType(), fwt.GetType());
if (pOptionalObject != null && !pOptionalObject.isOK())
{
EXPRFIELD pField = GetExprFactory().CreateField(0, pFieldType, pOptionalObject, 0, fwt, pOptionalLHS);
pField.SetError();
return pField;
}
EXPR pOriginalObject = pOptionalObject;
bool bIsMatchingStatic;
bool pfConstrained;
pOptionalObject = AdjustMemberObject(fwt, pOptionalObject, out pfConstrained, out bIsMatchingStatic);
checkUnsafe(pFieldType); // added to the binder so we don't bind to pointer ops
EXPRFIELD pResult;
{
bool isLValue = false;
if ((pOptionalObject != null && pOptionalObject.type.IsPointerType()) || objectIsLvalue(pOptionalObject))
{
isLValue = true;
}
// Exception: a readonly field is not an lvalue unless we're in the constructor/static constructor appropriate
// for the field.
if (RespectReadonly() && fwt.Field().isReadOnly)
{
if (ContainingAgg() == null ||
!InMethod() || !InConstructor() ||
fwt.Field().getClass() != ContainingAgg() ||
InStaticMethod() != fwt.Field().isStatic ||
(pOptionalObject != null && !isThisPointer(pOptionalObject)) ||
InAnonymousMethod())
{
isLValue = false;
}
}
pResult = GetExprFactory().CreateField(isLValue ? EXPRFLAG.EXF_LVALUE : 0, pFieldType, pOptionalObject, 0, fwt, pOptionalLHS);
if (!bIsMatchingStatic)
{
pResult.SetMismatchedStaticBit();
}
if (pFieldType.IsErrorType())
{
pResult.SetError();
}
Debug.Assert(BindingFlag.BIND_MEMBERSET == (BindingFlag)EXPRFLAG.EXF_MEMBERSET);
pResult.flags |= (EXPRFLAG)(bindFlags & BindingFlag.BIND_MEMBERSET);
}
// If this field is the backing field of a WindowsRuntime event then we need to bind to its
// invocationlist property which is a delegate containing all the handlers.
if (pResult.isFIELD() &&
fwt.Field().isEvent &&
fwt.Field().getEvent(GetSymbolLoader()) != null &&
fwt.Field().getEvent(GetSymbolLoader()).IsWindowsRuntimeEvent)
{
CType fieldType = fwt.Field().GetType();
if (fieldType.IsAggregateType())
{
// Access event backing field (EventRegistrationTokenTable<T>) using
// EventRegistrationTokenTable<T>.GetOrCreateEventRegistrationTokenTable()
// to ensure non-null
pResult.setType(GetTypes().GetParameterModifier(pResult.type, false));
Name getOrCreateMethodName = GetSymbolLoader().GetNameManager().GetPredefName(PredefinedName.PN_GETORCREATEEVENTREGISTRATIONTOKENTABLE);
GetSymbolLoader().RuntimeBinderSymbolTable.PopulateSymbolTableWithName(getOrCreateMethodName.Text, null, fieldType.AssociatedSystemType);
MethodSymbol getOrCreateMethod = GetSymbolLoader().LookupAggMember(getOrCreateMethodName, fieldType.getAggregate(), symbmask_t.MASK_MethodSymbol).AsMethodSymbol();
MethPropWithInst getOrCreatempwi = new MethPropWithInst(getOrCreateMethod, fieldType.AsAggregateType());
EXPRMEMGRP getOrCreateGrp = GetExprFactory().CreateMemGroup(null, getOrCreatempwi);
EXPR getOrCreateCall = BindToMethod(new MethWithInst(getOrCreatempwi),
pResult,
getOrCreateGrp,
(MemLookFlags)MemLookFlags.None);
AggregateSymbol fieldTypeSymbol = fieldType.AsAggregateType().GetOwningAggregate();
Name invocationListName = GetSymbolLoader().GetNameManager().GetPredefName(PredefinedName.PN_INVOCATIONLIST);
// InvocationList might not be populated in the symbol table as no one would have called it.
GetSymbolLoader().RuntimeBinderSymbolTable.PopulateSymbolTableWithName(invocationListName.Text, null, fieldType.AssociatedSystemType);
PropertySymbol invocationList = GetSymbolLoader().LookupAggMember(
invocationListName,
fieldTypeSymbol,
symbmask_t.MASK_PropertySymbol).AsPropertySymbol();
MethPropWithInst mpwi = new MethPropWithInst(invocationList, fieldType.AsAggregateType());
EXPRMEMGRP memGroup = GetExprFactory().CreateMemGroup(getOrCreateCall, mpwi);
PropWithType pwt = new PropWithType(invocationList, fieldType.AsAggregateType());
EXPR propertyExpr = BindToProperty(getOrCreateCall, pwt, bindFlags, null, null, memGroup);
return propertyExpr;
}
}
return pResult;
}
////////////////////////////////////////////////////////////////////////////////
// Construct the EXPR node which corresponds to a field expression
// for a given field and pObject pointer.
internal EXPR BindToField(EXPR pObject, FieldWithType fwt, BindingFlag bindFlags)
{
return BindToField(pObject, fwt, bindFlags, null/*OptionalLHS*/);
}
public ExprField CreateField(EXPRFLAG nFlags, CType pType, Expr pOptionalObject, FieldWithType FWT)
{
Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY)));
ExprField rval = new ExprField(pType);
rval.Flags = nFlags;
rval.OptionalObject = pOptionalObject;
rval.FieldWithType = FWT;
return(rval);
}