diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Index/Analyzer.cpp')
-rw-r--r-- | contrib/llvm/tools/clang/lib/Index/Analyzer.cpp | 470 |
1 files changed, 470 insertions, 0 deletions
diff --git a/contrib/llvm/tools/clang/lib/Index/Analyzer.cpp b/contrib/llvm/tools/clang/lib/Index/Analyzer.cpp new file mode 100644 index 0000000..f77e6ef --- /dev/null +++ b/contrib/llvm/tools/clang/lib/Index/Analyzer.cpp @@ -0,0 +1,470 @@ +//===--- Analyzer.cpp - Analysis for indexing information -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the Analyzer interface. +// +//===----------------------------------------------------------------------===// + +#include "clang/Index/Analyzer.h" +#include "clang/Index/Entity.h" +#include "clang/Index/TranslationUnit.h" +#include "clang/Index/Handlers.h" +#include "clang/Index/ASTLocation.h" +#include "clang/Index/GlobalSelector.h" +#include "clang/Index/DeclReferenceMap.h" +#include "clang/Index/SelectorMap.h" +#include "clang/Index/IndexProvider.h" +#include "clang/AST/DeclObjC.h" +#include "clang/AST/ExprObjC.h" +#include "llvm/ADT/SmallSet.h" +using namespace clang; +using namespace idx; + +namespace { + +//===----------------------------------------------------------------------===// +// DeclEntityAnalyzer Implementation +//===----------------------------------------------------------------------===// + +class DeclEntityAnalyzer : public TranslationUnitHandler { + Entity Ent; + TULocationHandler &TULocHandler; + +public: + DeclEntityAnalyzer(Entity ent, TULocationHandler &handler) + : Ent(ent), TULocHandler(handler) { } + + virtual void Handle(TranslationUnit *TU) { + assert(TU && "Passed null translation unit"); + + Decl *D = Ent.getDecl(TU->getASTContext()); + assert(D && "Couldn't resolve Entity"); + + for (Decl::redecl_iterator I = D->redecls_begin(), + E = D->redecls_end(); I != E; ++I) + TULocHandler.Handle(TULocation(TU, ASTLocation(*I))); + } +}; + +//===----------------------------------------------------------------------===// +// RefEntityAnalyzer Implementation +//===----------------------------------------------------------------------===// + +class RefEntityAnalyzer : public TranslationUnitHandler { + Entity Ent; + TULocationHandler &TULocHandler; + +public: + RefEntityAnalyzer(Entity ent, TULocationHandler &handler) + : Ent(ent), TULocHandler(handler) { } + + virtual void Handle(TranslationUnit *TU) { + assert(TU && "Passed null translation unit"); + + Decl *D = Ent.getDecl(TU->getASTContext()); + assert(D && "Couldn't resolve Entity"); + NamedDecl *ND = dyn_cast<NamedDecl>(D); + if (!ND) + return; + + DeclReferenceMap &RefMap = TU->getDeclReferenceMap(); + for (DeclReferenceMap::astlocation_iterator + I = RefMap.refs_begin(ND), E = RefMap.refs_end(ND); I != E; ++I) + TULocHandler.Handle(TULocation(TU, *I)); + } +}; + +//===----------------------------------------------------------------------===// +// RefSelectorAnalyzer Implementation +//===----------------------------------------------------------------------===// + +/// \brief Accepts an ObjC method and finds all message expressions that this +/// method may respond to. +class RefSelectorAnalyzer : public TranslationUnitHandler { + Program &Prog; + TULocationHandler &TULocHandler; + + // The original ObjCInterface associated with the method. + Entity IFaceEnt; + GlobalSelector GlobSel; + bool IsInstanceMethod; + + /// \brief Super classes of the ObjCInterface. + typedef llvm::SmallSet<Entity, 16> EntitiesSetTy; + EntitiesSetTy HierarchyEntities; + +public: + RefSelectorAnalyzer(ObjCMethodDecl *MD, + Program &prog, TULocationHandler &handler) + : Prog(prog), TULocHandler(handler) { + assert(MD); + + // FIXME: Protocol methods. + assert(!isa<ObjCProtocolDecl>(MD->getDeclContext()) && + "Protocol methods not supported yet"); + + ObjCInterfaceDecl *IFD = MD->getClassInterface(); + assert(IFD); + IFaceEnt = Entity::get(IFD, Prog); + GlobSel = GlobalSelector::get(MD->getSelector(), Prog); + IsInstanceMethod = MD->isInstanceMethod(); + + for (ObjCInterfaceDecl *Cls = IFD->getSuperClass(); + Cls; Cls = Cls->getSuperClass()) + HierarchyEntities.insert(Entity::get(Cls, Prog)); + } + + virtual void Handle(TranslationUnit *TU) { + assert(TU && "Passed null translation unit"); + + ASTContext &Ctx = TU->getASTContext(); + // Null means it doesn't exist in this translation unit. + ObjCInterfaceDecl *IFace = + cast_or_null<ObjCInterfaceDecl>(IFaceEnt.getDecl(Ctx)); + Selector Sel = GlobSel.getSelector(Ctx); + + SelectorMap &SelMap = TU->getSelectorMap(); + for (SelectorMap::astlocation_iterator + I = SelMap.refs_begin(Sel), E = SelMap.refs_end(Sel); I != E; ++I) { + if (ValidReference(*I, IFace)) + TULocHandler.Handle(TULocation(TU, *I)); + } + } + + /// \brief Determines whether the given message expression is likely to end + /// up at the given interface decl. + /// + /// It returns true "eagerly", meaning it will return false only if it can + /// "prove" statically that the interface cannot accept this message. + bool ValidReference(ASTLocation ASTLoc, ObjCInterfaceDecl *IFace) { + assert(ASTLoc.isStmt()); + + // FIXME: Finding @selector references should be through another Analyzer + // method, like FindSelectors. + if (isa<ObjCSelectorExpr>(ASTLoc.AsStmt())) + return false; + + ObjCInterfaceDecl *MsgD = 0; + ObjCMessageExpr *Msg = cast<ObjCMessageExpr>(ASTLoc.AsStmt()); + + switch (Msg->getReceiverKind()) { + case ObjCMessageExpr::Instance: { + const ObjCObjectPointerType *OPT = + Msg->getInstanceReceiver()->getType()->getAsObjCInterfacePointerType(); + + // Can be anything! Accept it as a possibility.. + if (!OPT || OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()) + return true; + + // Expecting class method. + if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) + return !IsInstanceMethod; + + MsgD = OPT->getInterfaceDecl(); + assert(MsgD); + + // Should be an instance method. + if (!IsInstanceMethod) + return false; + break; + } + + case ObjCMessageExpr::Class: { + // Expecting class method. + if (IsInstanceMethod) + return false; + + MsgD = Msg->getClassReceiver()->getAs<ObjCObjectType>()->getInterface(); + break; + } + + case ObjCMessageExpr::SuperClass: + // Expecting class method. + if (IsInstanceMethod) + return false; + + MsgD = Msg->getSuperType()->getAs<ObjCObjectType>()->getInterface(); + break; + + case ObjCMessageExpr::SuperInstance: + // Expecting instance method. + if (!IsInstanceMethod) + return false; + + MsgD = Msg->getSuperType()->getAs<ObjCObjectPointerType>() + ->getInterfaceDecl(); + break; + } + + assert(MsgD); + + // Same interface ? We have a winner! + if (declaresSameEntity(MsgD, IFace)) + return true; + + // If the message interface is a superclass of the original interface, + // accept this message as a possibility. + if (HierarchyEntities.count(Entity::get(MsgD, Prog))) + return true; + + // If the message interface is a subclass of the original interface, accept + // the message unless there is a subclass in the hierarchy that will + // "steal" the message (thus the message "will go" to the subclass and not + /// the original interface). + if (IFace) { + Selector Sel = Msg->getSelector(); + for (ObjCInterfaceDecl *Cls = MsgD; Cls; Cls = Cls->getSuperClass()) { + if (declaresSameEntity(Cls, IFace)) + return true; + if (Cls->getMethod(Sel, IsInstanceMethod)) + return false; + } + } + + // The interfaces are unrelated, don't accept the message. + return false; + } +}; + +//===----------------------------------------------------------------------===// +// MessageAnalyzer Implementation +//===----------------------------------------------------------------------===// + +/// \brief Accepts an ObjC message expression and finds all methods that may +/// respond to it. +class MessageAnalyzer : public TranslationUnitHandler { + Program &Prog; + TULocationHandler &TULocHandler; + + // The ObjCInterface associated with the message. Can be null/invalid. + Entity MsgIFaceEnt; + GlobalSelector GlobSel; + bool CanBeInstanceMethod; + bool CanBeClassMethod; + + /// \brief Super classes of the ObjCInterface. + typedef llvm::SmallSet<Entity, 16> EntitiesSetTy; + EntitiesSetTy HierarchyEntities; + + /// \brief The interface in the message interface hierarchy that "intercepts" + /// the selector. + Entity ReceiverIFaceEnt; + +public: + MessageAnalyzer(ObjCMessageExpr *Msg, + Program &prog, TULocationHandler &handler) + : Prog(prog), TULocHandler(handler), + CanBeInstanceMethod(false), + CanBeClassMethod(false) { + + assert(Msg); + + ObjCInterfaceDecl *MsgD = 0; + + while (true) { + switch (Msg->getReceiverKind()) { + case ObjCMessageExpr::Instance: { + const ObjCObjectPointerType *OPT = + Msg->getInstanceReceiver()->getType() + ->getAsObjCInterfacePointerType(); + + if (!OPT || OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()) { + CanBeInstanceMethod = CanBeClassMethod = true; + break; + } + + if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { + CanBeClassMethod = true; + break; + } + + MsgD = OPT->getInterfaceDecl(); + assert(MsgD); + CanBeInstanceMethod = true; + break; + } + + case ObjCMessageExpr::Class: + CanBeClassMethod = true; + MsgD = Msg->getClassReceiver()->getAs<ObjCObjectType>()->getInterface(); + break; + + case ObjCMessageExpr::SuperClass: + CanBeClassMethod = true; + MsgD = Msg->getSuperType()->getAs<ObjCObjectType>()->getInterface(); + break; + + case ObjCMessageExpr::SuperInstance: + CanBeInstanceMethod = true; + MsgD = Msg->getSuperType()->getAs<ObjCObjectPointerType>() + ->getInterfaceDecl(); + break; + } + } + + assert(CanBeInstanceMethod || CanBeClassMethod); + + Selector sel = Msg->getSelector(); + assert(!sel.isNull()); + + MsgIFaceEnt = Entity::get(MsgD, Prog); + GlobSel = GlobalSelector::get(sel, Prog); + + if (MsgD) { + for (ObjCInterfaceDecl *Cls = MsgD->getSuperClass(); + Cls; Cls = Cls->getSuperClass()) + HierarchyEntities.insert(Entity::get(Cls, Prog)); + + // Find the interface in the hierarchy that "receives" the message. + for (ObjCInterfaceDecl *Cls = MsgD; Cls; Cls = Cls->getSuperClass()) { + bool isReceiver = false; + + ObjCInterfaceDecl::lookup_const_iterator Meth, MethEnd; + for (llvm::tie(Meth, MethEnd) = Cls->lookup(sel); + Meth != MethEnd; ++Meth) { + if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth)) + if ((MD->isInstanceMethod() && CanBeInstanceMethod) || + (MD->isClassMethod() && CanBeClassMethod)) { + isReceiver = true; + break; + } + } + + if (isReceiver) { + ReceiverIFaceEnt = Entity::get(Cls, Prog); + break; + } + } + } + } + + virtual void Handle(TranslationUnit *TU) { + assert(TU && "Passed null translation unit"); + ASTContext &Ctx = TU->getASTContext(); + + // Null means it doesn't exist in this translation unit or there was no + // interface that was determined to receive the original message. + ObjCInterfaceDecl *ReceiverIFace = + cast_or_null<ObjCInterfaceDecl>(ReceiverIFaceEnt.getDecl(Ctx)); + + // No subclass for the original receiver interface, so it remains the + // receiver. + if (ReceiverIFaceEnt.isValid() && ReceiverIFace == 0) + return; + + // Null means it doesn't exist in this translation unit or there was no + // interface associated with the message in the first place. + ObjCInterfaceDecl *MsgIFace = + cast_or_null<ObjCInterfaceDecl>(MsgIFaceEnt.getDecl(Ctx)); + + Selector Sel = GlobSel.getSelector(Ctx); + SelectorMap &SelMap = TU->getSelectorMap(); + for (SelectorMap::method_iterator + I = SelMap.methods_begin(Sel), E = SelMap.methods_end(Sel); + I != E; ++I) { + ObjCMethodDecl *D = *I; + if (ValidMethod(D, MsgIFace, ReceiverIFace)) { + for (ObjCMethodDecl::redecl_iterator + RI = D->redecls_begin(), RE = D->redecls_end(); RI != RE; ++RI) + TULocHandler.Handle(TULocation(TU, ASTLocation(*RI))); + } + } + } + + /// \brief Determines whether the given method is likely to accept the + /// original message. + /// + /// It returns true "eagerly", meaning it will return false only if it can + /// "prove" statically that the method cannot accept the original message. + bool ValidMethod(ObjCMethodDecl *D, ObjCInterfaceDecl *MsgIFace, + ObjCInterfaceDecl *ReceiverIFace) { + assert(D); + + // FIXME: Protocol methods ? + if (isa<ObjCProtocolDecl>(D->getDeclContext())) + return false; + + // No specific interface associated with the message. Can be anything. + if (MsgIFaceEnt.isInvalid()) + return true; + + if ((!CanBeInstanceMethod && D->isInstanceMethod()) || + (!CanBeClassMethod && D->isClassMethod())) + return false; + + ObjCInterfaceDecl *IFace = D->getClassInterface(); + assert(IFace); + + // If the original message interface is the same or a superclass of the + // given interface, accept the method as a possibility. + if (MsgIFace && MsgIFace->isSuperClassOf(IFace)) + return true; + + if (ReceiverIFace) { + // The given interface, "overrides" the receiver. + if (ReceiverIFace->isSuperClassOf(IFace)) + return true; + } else { + // No receiver was found for the original message. + assert(ReceiverIFaceEnt.isInvalid()); + + // If the original message interface is a subclass of the given interface, + // accept the message. + if (HierarchyEntities.count(Entity::get(IFace, Prog))) + return true; + } + + // The interfaces are unrelated, or the receiver interface wasn't + // "overriden". + return false; + } +}; + +} // end anonymous namespace + +//===----------------------------------------------------------------------===// +// Analyzer Implementation +//===----------------------------------------------------------------------===// + +void Analyzer::FindDeclarations(Decl *D, TULocationHandler &Handler) { + assert(D && "Passed null declaration"); + Entity Ent = Entity::get(D, Prog); + if (Ent.isInvalid()) + return; + + DeclEntityAnalyzer DEA(Ent, Handler); + Idxer.GetTranslationUnitsFor(Ent, DEA); +} + +void Analyzer::FindReferences(Decl *D, TULocationHandler &Handler) { + assert(D && "Passed null declaration"); + if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { + RefSelectorAnalyzer RSA(MD, Prog, Handler); + GlobalSelector Sel = GlobalSelector::get(MD->getSelector(), Prog); + Idxer.GetTranslationUnitsFor(Sel, RSA); + return; + } + + Entity Ent = Entity::get(D, Prog); + if (Ent.isInvalid()) + return; + + RefEntityAnalyzer REA(Ent, Handler); + Idxer.GetTranslationUnitsFor(Ent, REA); +} + +/// \brief Find methods that may respond to the given message and pass them +/// to Handler. +void Analyzer::FindObjCMethods(ObjCMessageExpr *Msg, + TULocationHandler &Handler) { + assert(Msg); + MessageAnalyzer MsgAnalyz(Msg, Prog, Handler); + GlobalSelector GlobSel = GlobalSelector::get(Msg->getSelector(), Prog); + Idxer.GetTranslationUnitsFor(GlobSel, MsgAnalyz); +} |