BCSYM*
Bindable::BasesIter::GetFirst()
{
BCSYM *Base = NULL;
m_LinkToCurrentBase = NULL;
if (m_ClassOrInterface->IsClass())
{
Base = m_ClassOrInterface->PClass()->GetBaseClass();
if (Base &&
(Base->IsBad() || !Base->IsClass()))
{
Base = NULL;
}
}
else if (m_ClassOrInterface->IsInterface())
{
m_LinkToCurrentBase = m_ClassOrInterface->PInterface()->GetFirstImplements();
Base = GetBaseInterface(m_LinkToCurrentBase);
}
return Base;
}
bool TypeExtensionIterator::MoveNext()
{
BCSYM_NamedRoot * pNamed = NULL;
do
{
pNamed = m_childIterator.GetNext();
if (pNamed && pNamed->IsContainer())
{
BCSYM_Container *pContainer = pNamed->PContainer();
// Perf: We are only interested in looking at types marked as containing extension methods. So only load the
// type's children if the type says it contains extension methods.
BCSYM *pContainerAfterDiggingThroughAlias = pContainer->DigThroughAlias();
if (pContainerAfterDiggingThroughAlias->IsClass())
{
if (pContainerAfterDiggingThroughAlias->PClass()->ContainsExtensionMethods())
{
pContainer->EnsureChildrenLoaded();
}
}
else if (!pContainer->GetCompilerFile() ||
(pContainer->GetCompilerFile()->IsMetaDataFile() && pContainer->GetCompilerFile()->ContainsExtensionMethods()))
{
pContainer->EnsureChildrenLoaded();
}
}
}
while (pNamed && ! pNamed->IsTypeExtension());
if (pNamed)
{
m_pCurrent = pNamed->PClass();
}
else
{
m_pCurrent = NULL;
}
return m_pCurrent;
}
BCSYM_Property*
Bindable::GetEventSourceProperty
(
BCSYM *TypeOfWithEventsVar,
_In_z_ STRING *PropertyName
)
{
// Need to find a property that sources an event
// To handle events on subobjects, (internal use only), you must supply a Class
// type for the WithEvents variable. But for completeness with respect to generics,
// adding support type parameters with class constraints too.
BCSYM *TypeToFindEventSourcePropertyIn;
if (TypeOfWithEventsVar->IsGenericParam())
{
//
TypeToFindEventSourcePropertyIn =
GetClassConstraint(
TypeOfWithEventsVar->PGenericParam(),
CurrentCompilerHost(),
CurrentAllocator(),
false, // don't ReturnArraysAs"System.Array"
true // ReturnValuesAs"System.ValueType"or"System.Enum"
);
}
else
{
TypeToFindEventSourcePropertyIn = TypeOfWithEventsVar;
}
if (!TypeToFindEventSourcePropertyIn ||
!TypeToFindEventSourcePropertyIn->IsClass())
{
return NULL;
}
// ---- attributes on all symbols in the TypeOfWithEventsVar container. This is needed
// in order to verify if a property is an EventSource which is determined by
// an attribute on the property.
//
----AttributesOnAllSymbolsInContainer(TypeToFindEventSourcePropertyIn->PClass(), m_CompilationCaches);
BCSYM_NamedRoot *Property =
TypeToFindEventSourcePropertyIn->PClass()->SimpleBind(NULL, PropertyName);
while (Property && Property->IsProperty())
{
if (ValidEventSourceProperty(Property->PProperty()) &&
IsAccessible(
Property->PProperty()->GetProperty(),
TypeToFindEventSourcePropertyIn->IsGenericBinding() ?
TypeToFindEventSourcePropertyIn->PGenericBinding() :
NULL,
CurrentContainer(),
TypeOfWithEventsVar))
{
return Property->PProperty(); // found it
}
Property = Property->GetNextOfSameName();
// Note:
// - we don't support finding the Property if it is overloaded
// across classes.
// - Also note that we don't support digging into bases. This was
// how the previous impl. was.
// Given that this is not a user feature, we don't bother doing
// this extra work.
}
return NULL;
}