public bool Lookup(CType typeSrc, Expr obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.Type != null);
Debug.Assert(typeSrc is AggregateType);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_typeSrc = typeSrc;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
_typeQual = (_flags & MemLookFlags.Ctor) != 0 ? _typeSrc : obj?.Type;
// Determine what to search.
AggregateType typeCls1;
AggregateType typeIface;
TypeArray ifaces;
if (typeSrc.IsInterfaceType)
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeCls1 = null;
typeIface = (AggregateType)typeSrc;
ifaces = typeIface.IfacesAll;
}
else
{
typeCls1 = (AggregateType)typeSrc;
typeIface = null;
ifaces = TypeArray.Empty;
}
AggregateType typeCls2 = typeIface != null || ifaces.Count > 0
? SymbolLoader.GetPredefindType(PredefinedType.PT_OBJECT)
: null;
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.Count > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.IsPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
return(!FError());
}
/******************************************************************************
* Lookup in a class and its bases (until *ptypeEnd is hit).
*
* ptypeEnd [in/out] - *ptypeEnd should be either null or object. If we find
* something here that would hide members of object, this sets *ptypeEnd
* to null.
*
* Returns true when searching should continue to the interfaces.
******************************************************************************/
private bool LookupInClass(AggregateType typeStart, ref AggregateType ptypeEnd)
{
Debug.Assert(!_swtFirst || _fMulti);
Debug.Assert(typeStart != null && !typeStart.isInterfaceType() && (ptypeEnd == null || typeStart != ptypeEnd));
AggregateType typeEnd = ptypeEnd;
AggregateType typeCur;
// Loop through types. Loop until we hit typeEnd (object or null).
for (typeCur = typeStart; typeCur != typeEnd && typeCur != null; typeCur = typeCur.GetBaseClass())
{
Debug.Assert(!typeCur.isInterfaceType());
bool fHideByName = false;
SearchSingleType(typeCur, out fHideByName);
_flags &= ~MemLookFlags.TypeVarsAllowed;
if (_swtFirst && !_fMulti)
{
// Everything below this type and in interfaces is hidden.
return(false);
}
if (fHideByName)
{
// This hides everything below it and in object, but not in the interfaces!
ptypeEnd = null;
// Return true to indicate that it's ok to search additional types.
return(true);
}
if ((_flags & MemLookFlags.Ctor) != 0)
{
// If we're looking for a constructor, don't check base classes or interfaces.
return(false);
}
}
Debug.Assert(typeCur == typeEnd);
return(true);
}
/***************************************************************************************************
* Lookup must be called before anything else can be called.
*
* typeSrc - Must be an AggregateType or TypeParameterType.
* obj - the expression through which the member is being accessed. This is used for accessibility
* of protected members and for constructing a MEMGRP from the results of the lookup.
* It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
* will not be used for MEMGRP construction.
* symWhere - the symbol from with the name is being accessed (for checking accessibility).
* name - the name to look for.
* arity - the number of type args specified. Only members that support this arity are found.
* Note that when arity is zero, all methods are considered since we do type argument
* inferencing.
*
* flags - See MemLookFlags.
* TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
{
_typeQual = null;
}
else if ((_flags & MemLookFlags.Ctor) != 0)
{
_typeQual = _typeSrc;
}
else if (obj != null)
{
_typeQual = (CType)obj.type;
}
else
{
_typeQual = null;
}
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
{
typeCls1 = null;
}
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
{
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
}
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return(!FError());
}
/******************************************************************************
* Returns true if searching should continue to object.
******************************************************************************/
private bool LookupInInterfaces(AggregateType typeStart, TypeArray types)
{
Debug.Assert(!_swtFirst || _fMulti);
Debug.Assert(typeStart == null || typeStart.isInterfaceType());
Debug.Assert(typeStart != null || types.size != 0);
// Clear all the hidden flags. Anything found in a class hides any other
// kind of member in all the interfaces.
if (typeStart != null)
{
typeStart.fAllHidden = false;
typeStart.fDiffHidden = (_swtFirst != null);
}
for (int i = 0; i < types.size; i++)
{
AggregateType type = types.Item(i).AsAggregateType();
Debug.Assert(type.isInterfaceType());
type.fAllHidden = false;
type.fDiffHidden = !!_swtFirst;
}
bool fHideObject = false;
AggregateType typeCur = typeStart;
int itypeNext = 0;
if (typeCur == null)
{
typeCur = types.Item(itypeNext++).AsAggregateType();
}
Debug.Assert(typeCur != null);
// Loop through the interfaces.
for (; ;)
{
Debug.Assert(typeCur != null && typeCur.isInterfaceType());
bool fHideByName = false;
if (!typeCur.fAllHidden && SearchSingleType(typeCur, out fHideByName))
{
fHideByName |= !_fMulti;
// Mark base interfaces appropriately.
TypeArray ifaces = typeCur.GetIfacesAll();
for (int i = 0; i < ifaces.size; i++)
{
AggregateType type = ifaces.Item(i).AsAggregateType();
Debug.Assert(type.isInterfaceType());
if (fHideByName)
{
type.fAllHidden = true;
}
type.fDiffHidden = true;
}
// If we hide all base types, that includes object!
if (fHideByName)
{
fHideObject = true;
}
}
_flags &= ~MemLookFlags.TypeVarsAllowed;
if (itypeNext >= types.size)
{
return(!fHideObject);
}
// Substitution has already been done.
typeCur = types.Item(itypeNext++).AsAggregateType();
}
}
/***************************************************************************************************
* Lookup must be called before anything else can be called.
*
* typeSrc - Must be an AggregateType or TypeParameterType.
* obj - the expression through which the member is being accessed. This is used for accessibility
* of protected members and for constructing a MEMGRP from the results of the lookup.
* It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
* will not be used for MEMGRP construction.
* symWhere - the symbol from with the name is being accessed (for checking accessibility).
* name - the name to look for.
* arity - the number of type args specified. Only members that support this arity are found.
* Note that when arity is zero, all methods are considered since we do type argument
* inferencing.
*
* flags - See MemLookFlags.
* TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, Expr obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.Type != null);
Debug.Assert(typeSrc is AggregateType);
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.SymbolLoader;
_typeSrc = typeSrc;
_obj = obj is ExprClass ? null : obj;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
_typeQual = (_flags & MemLookFlags.Ctor) != 0 ? _typeSrc : obj?.Type;
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (!typeSrc.IsInterfaceType)
{
typeCls1 = (AggregateType)typeSrc;
if (typeCls1.IsWindowsRuntimeType)
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = (AggregateType)typeSrc;
ifaces = typeIface.IfacesAll;
}
if (typeIface != null || ifaces.Count > 0)
{
typeCls2 = GetSymbolLoader().GetPredefindType(PredefinedType.PT_OBJECT);
}
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.Count > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.IsPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
return(!FError());
}
////////////////////////////////////////////////////////////////////////////////
// Binds a call to a method, return type is an error or an EXPRCALL.
//
// tree - ParseTree for error messages
// pObject - pObject to call method on
// pmwi - Meth to bind to. This will be morphed when we remap to an override.
// args - arguments
// exprFlags - Flags to put on the generated expr
internal EXPRCALL BindToMethod(MethWithInst mwi, EXPR pArguments, EXPRMEMGRP pMemGroup, MemLookFlags flags)
{
Debug.Assert(mwi.Sym != null && mwi.Sym.IsMethodSymbol() && (!mwi.Meth().isOverride || mwi.Meth().isHideByName));
Debug.Assert(pMemGroup != null);
bool fConstrained;
bool bIsMatchingStatic;
EXPR pObject = pMemGroup.GetOptionalObject();
CType callingObjectType = pObject != null ? pObject.type : null;
PostBindMethod((flags & MemLookFlags.BaseCall) != 0, ref mwi, pObject);
pObject = AdjustMemberObject(mwi, pObject, out fConstrained, out bIsMatchingStatic);
pMemGroup.SetOptionalObject(pObject);
CType pReturnType = null;
if ((flags & (MemLookFlags.Ctor | MemLookFlags.NewObj)) == (MemLookFlags.Ctor | MemLookFlags.NewObj))
{
pReturnType = mwi.Ats;
}
else
{
pReturnType = GetTypes().SubstType(mwi.Meth().RetType, mwi.GetType(), mwi.TypeArgs);
}
EXPRCALL pResult = GetExprFactory().CreateCall(0, pReturnType, pArguments, pMemGroup, mwi);
if (!bIsMatchingStatic)
{
pResult.SetMismatchedStaticBit();
}
if (!pResult.isOK())
{
return pResult;
}
// Set the return type and flags for constructors.
if ((flags & MemLookFlags.Ctor) != 0)
{
if ((flags & MemLookFlags.NewObj) != 0)
{
pResult.flags |= EXPRFLAG.EXF_NEWOBJCALL | EXPRFLAG.EXF_CANTBENULL;
}
else
{
Debug.Assert(pResult.type == getVoidType());
}
}
if ((flags & MemLookFlags.BaseCall) != 0)
{
pResult.flags |= EXPRFLAG.EXF_BASECALL;
}
else if (fConstrained && pObject != null)
{
// Use the constrained prefix.
pResult.flags |= EXPRFLAG.EXF_CONSTRAINED;
}
verifyMethodArgs(pResult, callingObjectType);
return pResult;
}
/***************************************************************************************************
Lookup must be called before anything else can be called.
typeSrc - Must be an AggregateType or TypeParameterType.
obj - the expression through which the member is being accessed. This is used for accessibility
of protected members and for constructing a MEMGRP from the results of the lookup.
It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
will not be used for MEMGRP construction.
symWhere - the symbol from with the name is being accessed (for checking accessibility).
name - the name to look for.
arity - the number of type args specified. Only members that support this arity are found.
Note that when arity is zero, all methods are considered since we do type argument
inferencing.
flags - See MemLookFlags.
TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
_typeQual = null;
else if ((_flags & MemLookFlags.Ctor) != 0)
_typeQual = _typeSrc;
else if (obj != null)
_typeQual = (CType)obj.type;
else
_typeQual = null;
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
typeCls1 = null;
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return !FError();
}
/******************************************************************************
Returns true if searching should continue to object.
******************************************************************************/
private bool LookupInInterfaces(AggregateType typeStart, TypeArray types)
{
Debug.Assert(!_swtFirst || _fMulti);
Debug.Assert(typeStart == null || typeStart.isInterfaceType());
Debug.Assert(typeStart != null || types.size != 0);
// Clear all the hidden flags. Anything found in a class hides any other
// kind of member in all the interfaces.
if (typeStart != null)
{
typeStart.fAllHidden = false;
typeStart.fDiffHidden = (_swtFirst != null);
}
for (int i = 0; i < types.size; i++)
{
AggregateType type = types.Item(i).AsAggregateType();
Debug.Assert(type.isInterfaceType());
type.fAllHidden = false;
type.fDiffHidden = !!_swtFirst;
}
bool fHideObject = false;
AggregateType typeCur = typeStart;
int itypeNext = 0;
if (typeCur == null)
{
typeCur = types.Item(itypeNext++).AsAggregateType();
}
Debug.Assert(typeCur != null);
// Loop through the interfaces.
for (; ;)
{
Debug.Assert(typeCur != null && typeCur.isInterfaceType());
bool fHideByName = false;
if (!typeCur.fAllHidden && SearchSingleType(typeCur, out fHideByName))
{
fHideByName |= !_fMulti;
// Mark base interfaces appropriately.
TypeArray ifaces = typeCur.GetIfacesAll();
for (int i = 0; i < ifaces.size; i++)
{
AggregateType type = ifaces.Item(i).AsAggregateType();
Debug.Assert(type.isInterfaceType());
if (fHideByName)
type.fAllHidden = true;
type.fDiffHidden = true;
}
// If we hide all base types, that includes object!
if (fHideByName)
fHideObject = true;
}
_flags &= ~MemLookFlags.TypeVarsAllowed;
if (itypeNext >= types.size)
return !fHideObject;
// Substitution has already been done.
typeCur = types.Item(itypeNext++).AsAggregateType();
}
}
/******************************************************************************
Lookup in a class and its bases (until *ptypeEnd is hit).
ptypeEnd [in/out] - *ptypeEnd should be either null or object. If we find
something here that would hide members of object, this sets *ptypeEnd
to null.
Returns true when searching should continue to the interfaces.
******************************************************************************/
private bool LookupInClass(AggregateType typeStart, ref AggregateType ptypeEnd)
{
Debug.Assert(!_swtFirst || _fMulti);
Debug.Assert(typeStart != null && !typeStart.isInterfaceType() && (ptypeEnd == null || typeStart != ptypeEnd));
AggregateType typeEnd = ptypeEnd;
AggregateType typeCur;
// Loop through types. Loop until we hit typeEnd (object or null).
for (typeCur = typeStart; typeCur != typeEnd && typeCur != null; typeCur = typeCur.GetBaseClass())
{
Debug.Assert(!typeCur.isInterfaceType());
bool fHideByName = false;
SearchSingleType(typeCur, out fHideByName);
_flags &= ~MemLookFlags.TypeVarsAllowed;
if (_swtFirst && !_fMulti)
{
// Everything below this type and in interfaces is hidden.
return false;
}
if (fHideByName)
{
// This hides everything below it and in object, but not in the interfaces!
ptypeEnd = null;
// Return true to indicate that it's ok to search additional types.
return true;
}
if ((_flags & MemLookFlags.Ctor) != 0)
{
// If we're looking for a constructor, don't check base classes or interfaces.
return false;
}
}
Debug.Assert(typeCur == typeEnd);
return true;
}
