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; }