/// Returns the property that shadowed by PropImpl if one exists and /// nullptr otherwise. const ObjCPropertyDecl *ObjCDeallocChecker::findShadowedPropertyDecl( const ObjCPropertyImplDecl *PropImpl) const { const ObjCPropertyDecl *PropDecl = PropImpl->getPropertyDecl(); // Only readwrite properties can shadow. if (PropDecl->isReadOnly()) return nullptr; auto *CatDecl = dyn_cast<ObjCCategoryDecl>(PropDecl->getDeclContext()); // Only class extensions can contain shadowing properties. if (!CatDecl || !CatDecl->IsClassExtension()) return nullptr; IdentifierInfo *ID = PropDecl->getIdentifier(); DeclContext::lookup_result R = CatDecl->getClassInterface()->lookup(ID); for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) { auto *ShadowedPropDecl = dyn_cast<ObjCPropertyDecl>(*I); if (!ShadowedPropDecl) continue; if (ShadowedPropDecl->isInstanceProperty()) { assert(ShadowedPropDecl->isReadOnly()); return ShadowedPropDecl; } } return nullptr; }
std::vector<const NamedDecl *> CXXRecordDecl::lookupDependentName( const DeclarationName &Name, llvm::function_ref<bool(const NamedDecl *ND)> Filter) { std::vector<const NamedDecl *> Results; // Lookup in the class. DeclContext::lookup_result DirectResult = lookup(Name); if (!DirectResult.empty()) { for (const NamedDecl *ND : DirectResult) { if (Filter(ND)) Results.push_back(ND); } return Results; } // Perform lookup into our base classes. CXXBasePaths Paths; Paths.setOrigin(this); if (!lookupInBases( [&](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) { return CXXRecordDecl::FindOrdinaryMemberInDependentClasses( Specifier, Path, Name); }, Paths, /*LookupInDependent=*/true)) return Results; for (const NamedDecl *ND : Paths.front().Decls) { if (Filter(ND)) Results.push_back(ND); } return Results; }
bool RemoveNamespace::hasNameConflict(const NamedDecl *ND, const DeclContext *ParentCtx) { // we cannot lookup names from LinkageSpecDecl, e.g., // extern "C++" { ... } if (dyn_cast<LinkageSpecDecl>(ParentCtx)) return false; DeclarationName Name = ND->getDeclName(); DeclContext::lookup_result Result = ParentCtx->lookup(Name); return !Result.empty(); }
DeclContextLookupResult MultiplexExternalSemaSource:: FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) { StoredDeclsList DeclsFound; for(size_t i = 0; i < Sources.size(); ++i) { DeclContext::lookup_result R = Sources[i]->FindExternalVisibleDeclsByName(DC, Name); for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) { if (!DeclsFound.HandleRedeclaration(*I)) DeclsFound.AddSubsequentDecl(*I); } } return DeclsFound.getLookupResult(); }
/// Returns the value stored in the 'success_' field of the passed-in /// AssertionResult instance. SVal GTestChecker::getAssertionResultSuccessFieldValue( const CXXRecordDecl *AssertionResultDecl, SVal Instance, ProgramStateRef State) const { DeclContext::lookup_result Result = AssertionResultDecl->lookup(SuccessII); if (Result.empty()) return UnknownVal(); auto *SuccessField = dyn_cast<FieldDecl>(Result.front()); if (!SuccessField) return UnknownVal(); Optional<Loc> FieldLoc = State->getLValue(SuccessField, Instance).getAs<Loc>(); if (!FieldLoc.hasValue()) return UnknownVal(); return State->getSVal(*FieldLoc); }
bool ASTImportSource::Import(DeclContext::lookup_result lookup_result, ASTContext &from_ASTContext, ASTContext &to_ASTContext, const DeclContext *childCurrentDeclContext, DeclarationName &childDeclName, DeclarationName &parentDeclName) { // Prepare to import the Decl(Context) we found in the // child interpreter by getting the file managers from // each interpreter. FileManager &child_FM = m_child_Interp->getCI()->getFileManager(); FileManager &parent_FM = m_parent_Interp->getCI()->getFileManager(); // Clang's ASTImporter ASTImporter importer(to_ASTContext, child_FM, from_ASTContext, parent_FM, /*MinimalImport : ON*/ true); for (DeclContext::lookup_iterator I = lookup_result.begin(), E = lookup_result.end(); I != E; ++I) { // Check if this Name we are looking for is // a DeclContext (for example a Namespace, function etc.). if (DeclContext *declContextToImport = llvm::dyn_cast<DeclContext>(*I)) { ImportDeclContext(declContextToImport, importer, childDeclName, parentDeclName, childCurrentDeclContext); } else if (Decl *declToImport = llvm::dyn_cast<Decl>(*I)) { // else it is a Decl ImportDecl(declToImport, importer, childDeclName, parentDeclName, childCurrentDeclContext); } } return true; }
NamespaceDecl *Sema::ActOnRogerNamespaceHeaderPart(DeclContext *DeclContext, IdentifierInfo *II, SourceLocation IdentLoc, AttributeList *AttrList) { // set CurContext SourceLocation NamespaceLoc; SourceLocation InlineLoc; SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc; assert(II); SourceLocation Loc = IdentLoc; bool IsInline = false; bool IsInvalid = false; bool IsStd = false; bool AddToKnown = false; //Scope *DeclRegionScope = NamespcScope->getParent(); NamespaceDecl *PrevNS = 0; // C++ [namespace.def]p2: // The identifier in an original-namespace-definition shall not // have been previously defined in the declarative region in // which the original-namespace-definition appears. The // identifier in an original-namespace-definition is the name of // the namespace. Subsequently in that declarative region, it is // treated as an original-namespace-name. // // Since namespace names are unique in their scope, and we don't // look through using directives, just look for any ordinary names. const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member | Decl::IDNS_Type | Decl::IDNS_Using | Decl::IDNS_Tag | Decl::IDNS_Namespace; NamedDecl *PrevDecl = 0; DeclContext::lookup_result R = DeclContext->getRedeclContext()->lookup(II); for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) { if ((*I)->getIdentifierNamespace() & IDNS) { PrevDecl = *I; break; } } PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl); if (PrevNS) { // This is an extended namespace definition. if (IsInline != PrevNS->isInline()) { // DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II, // &IsInline, PrevNS); assert(false && "need to implement this"); } return PrevNS; } else if (PrevDecl) { // This is an invalid name redefinition. Diag(Loc, diag::err_redefinition_different_kind) << II; Diag(PrevDecl->getLocation(), diag::note_previous_definition); IsInvalid = true; // Continue on to push Namespc as current DeclContext and return it. } else if (II->isStr("std") && DeclContext->getRedeclContext()->isTranslationUnit()) { // This is the first "real" definition of the namespace "std", so update // our cache of the "std" namespace to point at this definition. PrevNS = getStdNamespace(); IsStd = true; AddToKnown = !IsInline; } else { // We've seen this namespace for the first time. AddToKnown = !IsInline; } NamespaceDecl *Namespc = NamespaceDecl::Create(Context, DeclContext, IsInline, StartLoc, Loc, II, PrevNS); Namespc->IsRogerNamespace = true; if (IsInvalid) Namespc->setInvalidDecl(); //ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList); // FIXME: Should we be merging attributes? if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>()) PushNamespaceVisibilityAttr(Attr, Loc); if (IsStd) StdNamespace = Namespc; if (AddToKnown) KnownNamespaces[Namespc] = false; DeclContext->addDecl(Namespc); if (PrevNS) { return PrevNS; } else { return Namespc; } }