public static RuntimeBinderException ReportAccessError(SymWithType swtBad, Symbol symWhere, CType typeQual)
{
Debug.Assert(!CheckAccess(swtBad.Sym, swtBad.GetType(), symWhere, typeQual) ||
!CheckTypeAccess(swtBad.GetType(), symWhere));
return(CheckAccess2(swtBad.Sym, swtBad.GetType(), symWhere, typeQual)
== ACCESSERROR.ACCESSERROR_NOACCESSTHRU
? ErrorHandling.Error(ErrorCode.ERR_BadProtectedAccess, swtBad, typeQual, symWhere)
: ErrorHandling.Error(ErrorCode.ERR_BadAccess, swtBad));
}
public void ReportAccessError(SymWithType swtBad, Symbol symWhere, CType typeQual)
{
Debug.Assert(!CheckAccess(swtBad.Sym, swtBad.GetType(), symWhere, typeQual) ||
!CheckTypeAccess(swtBad.GetType(), symWhere));
if (CheckAccess2(swtBad.Sym, swtBad.GetType(), symWhere, typeQual) == ACCESSERROR.ACCESSERROR_NOACCESSTHRU)
{
ErrorContext.Error(ErrorCode.ERR_BadProtectedAccess, swtBad, typeQual, symWhere);
}
else
{
ErrorContext.ErrorRef(ErrorCode.ERR_BadAccess, swtBad);
}
}
private void ReportBogus(SymWithType swt)
{
Debug.Assert(swt.Sym.hasBogus() && swt.Sym.checkBogus());
switch (swt.Sym.getKind())
{
case SYMKIND.SK_EventSymbol:
break;
case SYMKIND.SK_PropertySymbol:
if (swt.Prop().useMethInstead)
{
MethodSymbol meth1 = swt.Prop().methGet;
MethodSymbol meth2 = swt.Prop().methSet;
ReportBogusForEventsAndProperties(swt, meth1, meth2);
return;
}
break;
case SYMKIND.SK_MethodSymbol:
if (swt.Meth().name == NameManager.GetPredefinedName(PredefinedName.PN_INVOKE) && swt.Meth().getClass().IsDelegate())
{
swt.Set(swt.Meth().getClass(), swt.GetType());
}
break;
default:
break;
}
// Generic bogus error.
GetErrorContext().ErrorRef(ErrorCode.ERR_BindToBogus, swt);
}
private static RuntimeBinderException ReportBogus(SymWithType swt)
{
Debug.Assert(CSemanticChecker.CheckBogus(swt.Sym));
MethodSymbol meth1 = swt.Prop().GetterMethod;
MethodSymbol meth2 = swt.Prop().SetterMethod;
Debug.Assert((meth1 ?? meth2) != null);
return(meth1 == null | meth2 == null
? ErrorHandling.Error(
ErrorCode.ERR_BindToBogusProp1, swt.Sym.name, new SymWithType(meth1 ?? meth2, swt.GetType()),
new ErrArgRefOnly(swt.Sym))
: ErrorHandling.Error(
ErrorCode.ERR_BindToBogusProp2, swt.Sym.name, new SymWithType(meth1, swt.GetType()),
new SymWithType(meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym)));
}
private void ReportBogus(SymWithType swt)
{
Debug.Assert(CSemanticChecker.CheckBogus(swt.Sym));
MethodSymbol meth1 = swt.Prop().GetterMethod;
MethodSymbol meth2 = swt.Prop().SetterMethod;
Debug.Assert((meth1 ?? meth2) != null);
if (meth1 == null | meth2 == null)
{
GetErrorContext().Error(
ErrorCode.ERR_BindToBogusProp1, swt.Sym.name, new SymWithType(meth1 ?? meth2, swt.GetType()),
new ErrArgRefOnly(swt.Sym));
}
else
{
GetErrorContext().Error(
ErrorCode.ERR_BindToBogusProp2, swt.Sym.name, new SymWithType(meth1, swt.GetType()),
new SymWithType(meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym));
}
}
private void ReportBogusForEventsAndProperties(SymWithType swt, MethodSymbol meth1, MethodSymbol meth2)
{
if (meth1 != null && meth2 != null)
{
GetErrorContext().Error(ErrorCode.ERR_BindToBogusProp2, swt.Sym.name, new SymWithType(meth1, swt.GetType()), new SymWithType(meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym));
return;
}
if (meth1 != null || meth2 != null)
{
GetErrorContext().Error(ErrorCode.ERR_BindToBogusProp1, swt.Sym.name, new SymWithType(meth1 != null ? meth1 : meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym));
return;
}
throw Error.InternalCompilerError();
}
public void ReportAccessError(SymWithType swtBad, Symbol symWhere, CType typeQual)
{
Debug.Assert(!CheckAccess(swtBad.Sym, swtBad.GetType(), symWhere, typeQual) ||
!CheckTypeAccess(swtBad.GetType(), symWhere));
if (CheckAccess2(swtBad.Sym, swtBad.GetType(), symWhere, typeQual) == ACCESSERROR.ACCESSERROR_NOACCESSTHRU)
{
ErrorContext.Error(ErrorCode.ERR_BadProtectedAccess, swtBad, typeQual, symWhere);
}
else
{
ErrorContext.ErrorRef(ErrorCode.ERR_BadAccess, swtBad);
}
}
/////////////////////////////////////////////////////////////////////////////////
private EXPREVENT CreateEvent(
SymWithType swt,
EXPR callingObject)
{
EventSymbol eventSymbol = swt.Event();
EXPREVENT e = _exprFactory.CreateEvent(eventSymbol.type, callingObject, new EventWithType(eventSymbol, swt.GetType()));
return e;
}
/////////////////////////////////////////////////////////////////////////////////
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;
}
/////////////////////////////////////////////////////////////////////////////////
private EXPR CreateIndexer(SymWithType swt, EXPR callingObject, EXPR arguments, BindingFlag bindFlags)
{
IndexerSymbol index = swt.Sym as IndexerSymbol;
AggregateType ctype = swt.GetType();
EXPRMEMGRP memgroup = CreateMemberGroupEXPR(index.name.Text, null, callingObject, SYMKIND.SK_PropertySymbol);
EXPR result = _binder.BindMethodGroupToArguments(bindFlags, memgroup, arguments);
return ReorderArgumentsForNamedAndOptional(callingObject, result);
}
/////////////////////////////////////////////////////////////////////////////////
private EXPR CreateProperty(
SymWithType swt,
EXPR callingObject,
BindingFlag flags)
{
// For a property, we simply create the EXPRPROP for the thing, call the
// expression tree rewriter, rewrite it, and send it on its way.
PropertySymbol property = swt.Prop();
AggregateType propertyType = swt.GetType();
PropWithType pwt = new PropWithType(property, propertyType);
EXPRMEMGRP pMemGroup = CreateMemberGroupEXPR(property.name.Text, null, callingObject, SYMKIND.SK_PropertySymbol);
return _binder.BindToProperty(// For a static property instance, don't set the object.
callingObject.isCLASS() ? null : callingObject, pwt, flags, null, null, pMemGroup);
}
private EXPR AdjustMemberObject(SymWithType swt, EXPR pObject, out bool pfConstrained, out bool pIsMatchingStatic)
{
// Assert that the type is present and is an instantiation of the member's parent.
Debug.Assert(swt.GetType() != null && swt.GetType().getAggregate() == swt.Sym.parent.AsAggregateSymbol());
bool bIsMatchingStatic = IsMatchingStatic(swt, pObject);
pIsMatchingStatic = bIsMatchingStatic;
pfConstrained = false;
bool isStatic = swt.Sym.isStatic;
// If our static doesn't match, bail out of here.
if (!bIsMatchingStatic)
{
if (isStatic)
{
// If we have a mismatched static, a static method, and the binding flag
// that tells us we're binding simple names, then insert a type here instead.
if ((pObject.flags & EXPRFLAG.EXF_SIMPLENAME) != 0)
{
// We've made the static match now.
pIsMatchingStatic = true;
return null;
}
else
{
ErrorContext.ErrorRef(ErrorCode.ERR_ObjectProhibited, swt);
return null;
}
}
else
{
ErrorContext.ErrorRef(ErrorCode.ERR_ObjectRequired, swt);
return pObject;
}
}
// At this point, all errors for static invocations have been reported, and
// the object has been nulled out. So return out of here.
if (isStatic)
{
return null;
}
// If we're in a constructor, then bail.
if (swt.Sym.IsMethodSymbol() && swt.Meth().IsConstructor())
{
return pObject;
}
if (pObject == null)
{
if (InFieldInitializer() && !InStaticMethod() && ContainingAgg() == swt.Sym.parent)
{
ErrorContext.ErrorRef(ErrorCode.ERR_FieldInitRefNonstatic, swt); // give better error message for common mistake <BUGNUM>See VS7:119218</BUGNUM>
}
else if (InAnonymousMethod() && !InStaticMethod() && ContainingAgg() == swt.Sym.parent && ContainingAgg().IsStruct())
{
ErrorContext.Error(ErrorCode.ERR_ThisStructNotInAnonMeth);
}
else
{
return null;
}
// For fields or structs, make a this pointer for us to use.
EXPRTHISPOINTER thisExpr = GetExprFactory().CreateThis(Context.GetThisPointer(), true);
thisExpr.SetMismatchedStaticBit();
if (thisExpr.type == null)
{
thisExpr.setType(GetTypes().GetErrorSym());
}
return thisExpr;
}
CType typeObj = pObject.type;
CType typeTmp;
if (typeObj.IsNullableType() && (typeTmp = typeObj.AsNullableType().GetAts(GetErrorContext())) != null && typeTmp != swt.GetType())
{
typeObj = typeTmp;
}
if (typeObj.IsTypeParameterType() || typeObj.IsAggregateType())
{
AggregateSymbol aggCalled = null;
aggCalled = swt.Sym.parent.AsAggregateSymbol();
Debug.Assert(swt.GetType().getAggregate() == aggCalled);
// If we're invoking code on a struct-valued field, mark the struct as assigned (to
// avoid warning CS0649).
if (pObject.isFIELD() && !pObject.asFIELD().fwt.Field().isAssigned && !swt.Sym.IsFieldSymbol() &&
typeObj.isStructType() && !typeObj.isPredefined())
{
pObject.asFIELD().fwt.Field().isAssigned = true;
}
if (pfConstrained &&
(typeObj.IsTypeParameterType() ||
typeObj.isStructType() && swt.GetType().IsRefType() && swt.Sym.IsVirtual()))
{
// For calls on type parameters or virtual calls on struct types (not enums),
// use the constrained prefix.
pfConstrained = true;
}
EXPR objNew = tryConvert(pObject, swt.GetType(), CONVERTTYPE.NOUDC);
// This check ensures that we do not bind to methods in an outer class
// which are visible, but whose this pointer is of an incorrect type...
// ... also handles case of calling an pObject method on a RefAny value.
// WE don't give a great message for this, but it'll do.
if (objNew == null)
{
if (!pObject.type.isSpecialByRefType())
{
ErrorContext.Error(ErrorCode.ERR_WrongNestedThis, swt.GetType(), pObject.type);
}
else
{
ErrorContext.Error(ErrorCode.ERR_NoImplicitConv, pObject.type, swt.GetType());
}
}
pObject = objNew;
}
return pObject;
}
private void ReportBogusForEventsAndProperties(SymWithType swt, MethodSymbol meth1, MethodSymbol meth2)
{
if (meth1 != null && meth2 != null)
{
GetErrorContext().Error(ErrorCode.ERR_BindToBogusProp2, swt.Sym.name, new SymWithType(meth1, swt.GetType()), new SymWithType(meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym));
return;
}
if (meth1 != null || meth2 != null)
{
GetErrorContext().Error(ErrorCode.ERR_BindToBogusProp1, swt.Sym.name, new SymWithType(meth1 != null ? meth1 : meth2, swt.GetType()), new ErrArgRefOnly(swt.Sym));
return;
}
throw Error.InternalCompilerError();
}
private void ReportBogus(SymWithType swt)
{
Debug.Assert(swt.Sym.hasBogus() && swt.Sym.checkBogus());
switch (swt.Sym.getKind())
{
case SYMKIND.SK_EventSymbol:
break;
case SYMKIND.SK_PropertySymbol:
if (swt.Prop().useMethInstead)
{
MethodSymbol meth1 = swt.Prop().methGet;
MethodSymbol meth2 = swt.Prop().methSet;
ReportBogusForEventsAndProperties(swt, meth1, meth2);
return;
}
break;
case SYMKIND.SK_MethodSymbol:
if (swt.Meth().name == GetSymbolLoader().GetNameManager().GetPredefName(PredefinedName.PN_INVOKE) && swt.Meth().getClass().IsDelegate())
{
swt.Set(swt.Meth().getClass(), swt.GetType());
}
break;
default:
break;
}
// Generic bogus error.
GetErrorContext().ErrorRef(ErrorCode.ERR_BindToBogus, swt);
}