internal static bool HasIsExternalInitModifier(MethWithType mwtSet)
{
var types = (mwtSet.Meth()?.AssociatedMemberInfo as MethodInfo)?.ReturnParameter.GetRequiredCustomModifiers();
return(types != null &&
types.Any(type => type.Name == "IsExternalInit" && !type.IsNested && type.Namespace == "System.Runtime.CompilerServices"));
}
// Value
public EXPR BindValue(EXPR exprSrc)
{
Debug.Assert(exprSrc != null && exprSrc.type.IsNullableType());
// For new T?(x), the answer is x.
if (CNullable.IsNullableConstructor(exprSrc))
{
Debug.Assert(exprSrc.asCALL().GetOptionalArguments() != null && !exprSrc.asCALL().GetOptionalArguments().isLIST());
return(exprSrc.asCALL().GetOptionalArguments());
}
CType typeBase = exprSrc.type.AsNullableType().GetUnderlyingType();
AggregateType ats = exprSrc.type.AsNullableType().GetAts(GetErrorContext());
if (ats == null)
{
EXPRPROP rval = GetExprFactory().CreateProperty(typeBase, exprSrc);
rval.SetError();
return(rval);
}
// UNDONE: move this to transform pass ...
PropertySymbol prop = GetSymbolLoader().getBSymmgr().propNubValue;
if (prop == null)
{
prop = GetSymbolLoader().getPredefinedMembers().GetProperty(PREDEFPROP.PP_G_OPTIONAL_VALUE);
GetSymbolLoader().getBSymmgr().propNubValue = prop;
}
PropWithType pwt = new PropWithType(prop, ats);
MethWithType mwt = new MethWithType(prop != null ? prop.methGet : null, ats);
MethPropWithInst mpwi = new MethPropWithInst(prop, ats);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(exprSrc, mpwi);
EXPRPROP exprRes = GetExprFactory().CreateProperty(typeBase, null, null, pMemGroup, pwt, mwt, null);
if (prop == null)
{
exprRes.SetError();
}
return(exprRes);
}
// Value
public Expr BindValue(Expr exprSrc)
{
Debug.Assert(exprSrc != null && exprSrc.Type.IsNullableType());
// For new T?(x), the answer is x.
if (IsNullableConstructor(exprSrc, out ExprCall call))
{
var args = call.OptionalArguments;
Debug.Assert(args != null && !(args is ExprList));
return(args);
}
CType typeBase = exprSrc.Type.AsNullableType().GetUnderlyingType();
AggregateType ats = exprSrc.Type.AsNullableType().GetAts(GetErrorContext());
if (ats == null)
{
ExprProperty rval = GetExprFactory().CreateProperty(typeBase, exprSrc);
rval.SetError();
return(rval);
}
PropertySymbol prop = GetSymbolLoader().getBSymmgr().propNubValue;
if (prop == null)
{
prop = GetSymbolLoader().getPredefinedMembers().GetProperty(PREDEFPROP.PP_G_OPTIONAL_VALUE);
GetSymbolLoader().getBSymmgr().propNubValue = prop;
}
PropWithType pwt = new PropWithType(prop, ats);
MethWithType mwt = new MethWithType(prop?.methGet, ats);
MethPropWithInst mpwi = new MethPropWithInst(prop, ats);
ExprMemberGroup pMemGroup = GetExprFactory().CreateMemGroup(exprSrc, mpwi);
ExprProperty exprRes = GetExprFactory().CreateProperty(typeBase, null, null, pMemGroup, pwt, mwt, null);
if (prop == null)
{
exprRes.SetError();
}
return(exprRes);
}
// If we have this.prop = 123, but the implementation of the property is in the
// base class, then the object is of the base class type. Note that to get
// the object, we must go through the MEMGRP.
//
// "throughObject" is
// of the type we are actually calling through. (We need to know the
// "through" type to ensure that protected semantics are correctly enforced.)
public ExprProperty(CType type, Expr pOptionalObjectThrough, Expr pOptionalArguments, ExprMemberGroup pMemberGroup, PropWithType pwtSlot, MethWithType mwtSet)
: base(ExpressionKind.Property, type)
{
OptionalObjectThrough = pOptionalObjectThrough;
OptionalArguments = pOptionalArguments;
MemberGroup = pMemberGroup;
if (pwtSlot != null)
{
PropWithTypeSlot = pwtSlot;
}
if (mwtSet != null)
{
MethWithTypeSet = mwtSet;
if (!HasIsExternalInitModifier(mwtSet))
{
Flags = EXPRFLAG.EXF_LVALUE;
}
}
}
public static ExprProperty CreateProperty(CType type, Expr optionalObjectThrough, Expr arguments, ExprMemberGroup memberGroup, PropWithType property, MethWithType setMethod) => new ExprProperty(type, optionalObjectThrough, arguments, memberGroup, property, setMethod);
public EXPRPROP CreateProperty(CType pType, EXPR pOptionalObjectThrough, EXPR pOptionalArguments, EXPRMEMGRP pMemberGroup, PropWithType pwtSlot, MethWithType mwtGet, MethWithType mwtSet)
{
EXPRPROP rval = new EXPRPROP();
rval.kind = ExpressionKind.EK_PROP;
rval.type = pType;
rval.flags = 0;
rval.SetOptionalObjectThrough(pOptionalObjectThrough);
rval.SetOptionalArguments(pOptionalArguments);
rval.SetMemberGroup(pMemberGroup);
if (pwtSlot != null)
{
rval.pwtSlot = pwtSlot;
}
if (mwtSet != null)
{
rval.mwtSet = mwtSet;
}
Debug.Assert(rval != null);
return(rval);
}
public ExprProperty CreateProperty(CType pType, Expr pOptionalObjectThrough, Expr pOptionalArguments, ExprMemberGroup pMemberGroup, PropWithType pwtSlot, MethWithType mwtGet, MethWithType mwtSet)
{
ExprProperty rval = new ExprProperty();
rval.Kind = ExpressionKind.EK_PROP;
rval.Type = pType;
rval.Flags = 0;
rval.OptionalObjectThrough = pOptionalObjectThrough;
rval.OptionalArguments = pOptionalArguments;
rval.MemberGroup = pMemberGroup;
if (pwtSlot != null)
{
rval.PropWithTypeSlot = pwtSlot;
}
if (mwtSet != null)
{
rval.MethWithTypeSet = mwtSet;
}
Debug.Assert(rval != null);
return(rval);
}
public GroupToArgsBinder(ExpressionBinder exprBinder, BindingFlag bindFlags, EXPRMEMGRP grp, ArgInfos args, ArgInfos originalArgs, bool bHasNamedArguments, AggregateType atsDelegate)
{
Debug.Assert(grp != null);
Debug.Assert(exprBinder != null);
Debug.Assert(args != null);
_pExprBinder = exprBinder;
_fCandidatesUnsupported = false;
_fBindFlags = bindFlags;
_pGroup = grp;
_pArguments = args;
_pOriginalArguments = originalArgs;
_bHasNamedArguments = bHasNamedArguments;
_pDelegate = atsDelegate;
_pCurrentType = null;
_pCurrentSym = null;
_pCurrentTypeArgs = null;
_pCurrentParameters = null;
_pBestParameters = null;
_nArgBest = -1;
_nWrongCount = 0;
_bIterateToEndOfNsList = false;
_bBindingCollectionAddArgs = false;
_results = new GroupToArgsBinderResult();
_methList = new List<CandidateFunctionMember>();
_mpwiParamTypeConstraints = new MethPropWithInst();
_mpwiBogus = new MethPropWithInst();
_mpwiCantInferInstArg = new MethPropWithInst();
_mwtBadArity = new MethWithType();
_HiddenTypes = new List<CType>();
}
private void ReportErrorsOnFailure()
{
// First and foremost, report if the user specified a name more than once.
if (_pDuplicateSpecifiedName != null)
{
GetErrorContext().Error(ErrorCode.ERR_DuplicateNamedArgument, _pDuplicateSpecifiedName);
return;
}
Debug.Assert(_methList.IsEmpty());
// Report inaccessible.
if (_results.GetInaccessibleResult())
{
// We might have called this, but it is inaccesable...
GetSemanticChecker().ReportAccessError(_results.GetInaccessibleResult(), _pExprBinder.ContextForMemberLookup(), GetTypeQualifier(_pGroup));
return;
}
// Report bogus.
if (_mpwiBogus)
{
// We might have called this, but it is bogus...
GetErrorContext().ErrorRef(ErrorCode.ERR_BindToBogus, _mpwiBogus);
return;
}
bool bUseDelegateErrors = false;
Name nameErr = _pGroup.name;
// Check for an invoke.
if (_pGroup.GetOptionalObject() != null &&
_pGroup.GetOptionalObject().type != null &&
_pGroup.GetOptionalObject().type.isDelegateType() &&
_pGroup.name == GetSymbolLoader().GetNameManager().GetPredefName(PredefinedName.PN_INVOKE))
{
Debug.Assert(!_results.GetBestResult() || _results.GetBestResult().MethProp().getClass().IsDelegate());
Debug.Assert(!_results.GetBestResult() || _results.GetBestResult().GetType().getAggregate().IsDelegate());
bUseDelegateErrors = true;
nameErr = _pGroup.GetOptionalObject().type.getAggregate().name;
}
if (_results.GetBestResult())
{
// If we had some invalid arguments for best matching.
ReportErrorsForBestMatching(bUseDelegateErrors, nameErr);
}
else if (_results.GetUninferrableResult() || _mpwiCantInferInstArg)
{
if (!_results.GetUninferrableResult())
{
//copy the extension method for which instacne argument type inference failed
_results.GetUninferrableResult().Set(_mpwiCantInferInstArg.Sym.AsMethodSymbol(), _mpwiCantInferInstArg.GetType(), _mpwiCantInferInstArg.TypeArgs);
}
Debug.Assert(_results.GetUninferrableResult().Sym.IsMethodSymbol());
MethodSymbol sym = _results.GetUninferrableResult().Meth();
TypeArray pCurrentParameters = sym.Params;
// if we tried to bind to an extensionmethod and the instance argument Type Inference failed then the method does not exist
// on the type at all. this is treated as a lookup error
CType type = null;
if (_pGroup.GetOptionalObject() != null)
{
type = _pGroup.GetOptionalObject().type;
}
else if (_pGroup.GetOptionalLHS() != null)
{
type = _pGroup.GetOptionalLHS().type;
}
MethWithType mwtCantInfer = new MethWithType();
mwtCantInfer.Set(_results.GetUninferrableResult().Meth(), _results.GetUninferrableResult().GetType());
GetErrorContext().Error(ErrorCode.ERR_CantInferMethTypeArgs, mwtCantInfer);
}
else if (_mwtBadArity)
{
int cvar = _mwtBadArity.Meth().typeVars.size;
GetErrorContext().ErrorRef(cvar > 0 ? ErrorCode.ERR_BadArity : ErrorCode.ERR_HasNoTypeVars, _mwtBadArity, new ErrArgSymKind(_mwtBadArity.Meth()), _pArguments.carg);
}
else if (_mpwiParamTypeConstraints)
{
// This will always report an error
TypeBind.CheckMethConstraints(GetSemanticChecker(), GetErrorContext(), new MethWithInst(_mpwiParamTypeConstraints));
}
else if (_pInvalidSpecifiedName != null)
{
// Give a better message for delegate invoke.
if (_pGroup.GetOptionalObject() != null &&
_pGroup.GetOptionalObject().type.IsAggregateType() &&
_pGroup.GetOptionalObject().type.AsAggregateType().GetOwningAggregate().IsDelegate())
{
GetErrorContext().Error(ErrorCode.ERR_BadNamedArgumentForDelegateInvoke, _pGroup.GetOptionalObject().type.AsAggregateType().GetOwningAggregate().name, _pInvalidSpecifiedName);
}
else
{
GetErrorContext().Error(ErrorCode.ERR_BadNamedArgument, _pGroup.name, _pInvalidSpecifiedName);
}
}
else if (_pNameUsedInPositionalArgument != null)
{
GetErrorContext().Error(ErrorCode.ERR_NamedArgumentUsedInPositional, _pNameUsedInPositionalArgument);
}
else
{
CParameterizedError error;
if (_pDelegate != null)
{
GetErrorContext().MakeError(out error, ErrorCode.ERR_MethDelegateMismatch, nameErr, _pDelegate);
GetErrorContext().AddRelatedTypeLoc(error, _pDelegate);
}
else
{
// The number of arguments must be wrong.
if (_fCandidatesUnsupported)
{
GetErrorContext().MakeError(out error, ErrorCode.ERR_BindToBogus, nameErr);
}
else if (bUseDelegateErrors)
{
Debug.Assert(0 == (_pGroup.flags & EXPRFLAG.EXF_CTOR));
GetErrorContext().MakeError(out error, ErrorCode.ERR_BadDelArgCount, nameErr, _pArguments.carg);
}
else
{
if (0 != (_pGroup.flags & EXPRFLAG.EXF_CTOR))
{
Debug.Assert(!_pGroup.GetParentType().IsTypeParameterType());
GetErrorContext().MakeError(out error, ErrorCode.ERR_BadCtorArgCount, _pGroup.GetParentType(), _pArguments.carg);
}
else
{
GetErrorContext().MakeError(out error, ErrorCode.ERR_BadArgCount, nameErr, _pArguments.carg);
}
}
}
// Report possible matches (same name and is accesible). We stored these in m_swtWrongCount.
for (int i = 0; i < _nWrongCount; i++)
{
if (GetSemanticChecker().CheckAccess(
_swtWrongCount[i].Sym,
_swtWrongCount[i].GetType(),
_pExprBinder.ContextForMemberLookup(),
GetTypeQualifier(_pGroup)))
{
GetErrorContext().AddRelatedSymLoc(error, _swtWrongCount[i].Sym);
}
}
GetErrorContext().SubmitError(error);
}
}
protected void PostBindProperty(bool fBaseCall, PropWithType pwt, EXPR pObject, out MethWithType pmwtGet, out MethWithType pmwtSet)
{
pmwtGet = new MethWithType();
pmwtSet = new MethWithType();
// Get the accessors.
if (pwt.Prop().methGet != null)
{
pmwtGet.Set(pwt.Prop().methGet, pwt.GetType());
}
else
{
pmwtGet.Clear();
}
if (pwt.Prop().methSet != null)
{
pmwtSet.Set(pwt.Prop().methSet, pwt.GetType());
}
else
{
pmwtSet.Clear();
}
// If it is virtual, find a remap of the method to something more specific. This
// may alter where the accessors are found.
if (fBaseCall && pObject != null)
{
if (pmwtGet)
{
RemapToOverride(GetSymbolLoader(), pmwtGet, pObject.type);
}
if (pmwtSet)
{
RemapToOverride(GetSymbolLoader(), pmwtSet, pObject.type);
}
}
if (pwt.Prop().RetType != null)
{
checkUnsafe(pwt.Prop().RetType);
}
}
protected bool CheckPropertyAccess(MethWithType mwt, PropWithType pwtSlot, CType type)
{
ACCESSERROR error = SemanticChecker.CheckAccess2(mwt.Meth(), mwt.GetType(), ContextForMemberLookup(), type);
if (error == ACCESSERROR.ACCESSERROR_NOACCESSTHRU)
{
ErrorContext.Error(ErrorCode.ERR_BadProtectedAccess, pwtSlot, type, ContextForMemberLookup());
return false;
}
else if (error == ACCESSERROR.ACCESSERROR_NOACCESS)
{
ErrorContext.Error(mwt.Meth().isSetAccessor() ? ErrorCode.ERR_InaccessibleSetter : ErrorCode.ERR_InaccessibleGetter, pwtSlot);
return false;
}
return true;
}
// Value
public EXPR BindValue(EXPR exprSrc)
{
Debug.Assert(exprSrc != null && exprSrc.type.IsNullableType());
// For new T?(x), the answer is x.
if (CNullable.IsNullableConstructor(exprSrc))
{
Debug.Assert(exprSrc.asCALL().GetOptionalArguments() != null && !exprSrc.asCALL().GetOptionalArguments().isLIST());
return exprSrc.asCALL().GetOptionalArguments();
}
CType typeBase = exprSrc.type.AsNullableType().GetUnderlyingType();
AggregateType ats = exprSrc.type.AsNullableType().GetAts(GetErrorContext());
if (ats == null)
{
EXPRPROP rval = GetExprFactory().CreateProperty(typeBase, exprSrc);
rval.SetError();
return rval;
}
PropertySymbol prop = GetSymbolLoader().getBSymmgr().propNubValue;
if (prop == null)
{
prop = GetSymbolLoader().getPredefinedMembers().GetProperty(PREDEFPROP.PP_G_OPTIONAL_VALUE);
GetSymbolLoader().getBSymmgr().propNubValue = prop;
}
PropWithType pwt = new PropWithType(prop, ats);
MethWithType mwt = new MethWithType(prop != null ? prop.methGet : null, ats);
MethPropWithInst mpwi = new MethPropWithInst(prop, ats);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(exprSrc, mpwi);
EXPRPROP exprRes = GetExprFactory().CreateProperty(typeBase, null, null, pMemGroup, pwt, mwt, null);
if (prop == null)
{
exprRes.SetError();
}
return exprRes;
}
public ExprProperty CreateProperty(CType pType, Expr pOptionalObjectThrough, Expr pOptionalArguments, ExprMemberGroup pMemberGroup, PropWithType pwtSlot, MethWithType mwtGet, MethWithType mwtSet)
{
ExprProperty rval = new ExprProperty(pType);
rval.OptionalObjectThrough = pOptionalObjectThrough;
rval.OptionalArguments = pOptionalArguments;
rval.MemberGroup = pMemberGroup;
if (pwtSlot != null)
{
rval.PropWithTypeSlot = pwtSlot;
}
if (mwtSet != null)
{
rval.MethWithTypeSet = mwtSet;
}
return(rval);
}
public EXPRPROP CreateProperty(CType pType, EXPR pOptionalObjectThrough, EXPR pOptionalArguments, EXPRMEMGRP pMemberGroup, PropWithType pwtSlot, MethWithType mwtGet, MethWithType mwtSet)
{
EXPRPROP rval = new EXPRPROP();
rval.kind = ExpressionKind.EK_PROP;
rval.type = pType;
rval.flags = 0;
rval.SetOptionalObjectThrough(pOptionalObjectThrough);
rval.SetOptionalArguments(pOptionalArguments);
rval.SetMemberGroup(pMemberGroup);
if (pwtSlot != null)
{
rval.pwtSlot = pwtSlot;
}
if (mwtSet != null)
{
rval.mwtSet = mwtSet;
}
Debug.Assert(rval != null);
return (rval);
}