From d15bb30dba1a657590e574a0d21ca22434f7c93c Mon Sep 17 00:00:00 2001 From: Dmitri Gribenko Date: Wed, 23 Jan 2013 17:25:27 +0000 Subject: [PATCH] libclang: change return type of getCursorDecl() to 'const Decl *' llvm-svn: 173278 --- clang/tools/libclang/CIndex.cpp | 209 ++++++++++++++++++----------------- clang/tools/libclang/CIndexCXX.cpp | 18 +-- clang/tools/libclang/CIndexHigh.cpp | 27 ++--- clang/tools/libclang/CIndexUSRs.cpp | 2 +- clang/tools/libclang/CXCursor.cpp | 20 ++-- clang/tools/libclang/CXCursor.h | 9 +- clang/tools/libclang/CXType.cpp | 34 +++--- clang/tools/libclang/CursorVisitor.h | 7 +- 8 files changed, 167 insertions(+), 159 deletions(-) diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index 64904fa..5d49241 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -165,7 +165,7 @@ bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { return false; if (clang_isDeclaration(Cursor.kind)) { - Decl *D = getCursorDecl(Cursor); + const Decl *D = getCursorDecl(Cursor); if (!D) { assert(0 && "Invalid declaration cursor"); return true; // abort. @@ -463,7 +463,7 @@ bool CursorVisitor::VisitChildren(CXCursor Cursor) { SetParentRAII SetParent(Parent, StmtParent, Cursor); if (clang_isDeclaration(Cursor.kind)) { - Decl *D = getCursorDecl(Cursor); + Decl *D = const_cast(getCursorDecl(Cursor)); if (!D) return false; @@ -2966,17 +2966,17 @@ unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file) { // CXCursor Operations. //===----------------------------------------------------------------------===// -static Decl *getDeclFromExpr(Stmt *E) { - if (ImplicitCastExpr *CE = dyn_cast(E)) +static const Decl *getDeclFromExpr(const Stmt *E) { + if (const ImplicitCastExpr *CE = dyn_cast(E)) return getDeclFromExpr(CE->getSubExpr()); - if (DeclRefExpr *RefExpr = dyn_cast(E)) + if (const DeclRefExpr *RefExpr = dyn_cast(E)) return RefExpr->getDecl(); - if (MemberExpr *ME = dyn_cast(E)) + if (const MemberExpr *ME = dyn_cast(E)) return ME->getMemberDecl(); - if (ObjCIvarRefExpr *RE = dyn_cast(E)) + if (const ObjCIvarRefExpr *RE = dyn_cast(E)) return RE->getDecl(); - if (ObjCPropertyRefExpr *PRE = dyn_cast(E)) { + if (const ObjCPropertyRefExpr *PRE = dyn_cast(E)) { if (PRE->isExplicitProperty()) return PRE->getExplicitProperty(); // It could be messaging both getter and setter as in: @@ -2987,26 +2987,26 @@ static Decl *getDeclFromExpr(Stmt *E) { return PRE->getImplicitPropertySetter(); return PRE->getImplicitPropertyGetter(); } - if (PseudoObjectExpr *POE = dyn_cast(E)) + if (const PseudoObjectExpr *POE = dyn_cast(E)) return getDeclFromExpr(POE->getSyntacticForm()); - if (OpaqueValueExpr *OVE = dyn_cast(E)) + if (const OpaqueValueExpr *OVE = dyn_cast(E)) if (Expr *Src = OVE->getSourceExpr()) return getDeclFromExpr(Src); - if (CallExpr *CE = dyn_cast(E)) + if (const CallExpr *CE = dyn_cast(E)) return getDeclFromExpr(CE->getCallee()); - if (CXXConstructExpr *CE = dyn_cast(E)) + if (const CXXConstructExpr *CE = dyn_cast(E)) if (!CE->isElidable()) return CE->getConstructor(); - if (ObjCMessageExpr *OME = dyn_cast(E)) + if (const ObjCMessageExpr *OME = dyn_cast(E)) return OME->getMethodDecl(); - if (ObjCProtocolExpr *PE = dyn_cast(E)) + if (const ObjCProtocolExpr *PE = dyn_cast(E)) return PE->getProtocol(); - if (SubstNonTypeTemplateParmPackExpr *NTTP + if (const SubstNonTypeTemplateParmPackExpr *NTTP = dyn_cast(E)) return NTTP->getParameterPack(); - if (SizeOfPackExpr *SizeOfPack = dyn_cast(E)) + if (const SizeOfPackExpr *SizeOfPack = dyn_cast(E)) if (isa(SizeOfPack->getPack()) || isa(SizeOfPack->getPack())) return SizeOfPack->getPack(); @@ -3081,27 +3081,28 @@ unsigned clang_visitChildrenWithBlock(CXCursor parent, return clang_visitChildren(parent, visitWithBlock, block); } -static CXString getDeclSpelling(Decl *D) { +static CXString getDeclSpelling(const Decl *D) { if (!D) return createCXString(""); - NamedDecl *ND = dyn_cast(D); + const NamedDecl *ND = dyn_cast(D); if (!ND) { - if (ObjCPropertyImplDecl *PropImpl =dyn_cast(D)) + if (const ObjCPropertyImplDecl *PropImpl = + dyn_cast(D)) if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) return createCXString(Property->getIdentifier()->getName()); - if (ImportDecl *ImportD = dyn_cast(D)) + if (const ImportDecl *ImportD = dyn_cast(D)) if (Module *Mod = ImportD->getImportedModule()) return createCXString(Mod->getFullModuleName()); return createCXString(""); } - if (ObjCMethodDecl *OMD = dyn_cast(ND)) + if (const ObjCMethodDecl *OMD = dyn_cast(ND)) return createCXString(OMD->getSelector().getAsString()); - if (ObjCCategoryImplDecl *CIMP = dyn_cast(ND)) + if (const ObjCCategoryImplDecl *CIMP = dyn_cast(ND)) // No, this isn't the same as the code below. getIdentifier() is non-virtual // and returns different names. NamedDecl returns the class name and // ObjCCategoryImplDecl returns the category name. @@ -3177,12 +3178,12 @@ CXString clang_getCursorSpelling(CXCursor C) { case CXCursor_OverloadedDeclRef: { OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; - if (Decl *D = Storage.dyn_cast()) { - if (NamedDecl *ND = dyn_cast(D)) + if (const Decl *D = Storage.dyn_cast()) { + if (const NamedDecl *ND = dyn_cast(D)) return createCXString(ND->getNameAsString()); return createCXString(""); } - if (OverloadExpr *E = Storage.dyn_cast()) + if (const OverloadExpr *E = Storage.dyn_cast()) return createCXString(E->getName().getAsString()); OverloadedTemplateStorage *Ovl = Storage.get(); @@ -3204,7 +3205,7 @@ CXString clang_getCursorSpelling(CXCursor C) { } if (clang_isExpression(C.kind)) { - Decl *D = getDeclFromExpr(getCursorExpr(C)); + const Decl *D = getDeclFromExpr(getCursorExpr(C)); if (D) return getDeclSpelling(D); return createCXString(""); @@ -3275,7 +3276,7 @@ CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, if (C.kind == CXCursor_ObjCInstanceMethodDecl || C.kind == CXCursor_ObjCClassMethodDecl) { - if (ObjCMethodDecl * + if (const ObjCMethodDecl * MD = dyn_cast_or_null(getCursorDecl(C))) { if (pieceIndex >= MD->getNumSelectorLocs()) return clang_getNullRange(); @@ -3287,10 +3288,10 @@ CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, C.kind == CXCursor_ObjCCategoryImplDecl) { if (pieceIndex > 0) return clang_getNullRange(); - if (ObjCCategoryDecl * + if (const ObjCCategoryDecl * CD = dyn_cast_or_null(getCursorDecl(C))) return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); - if (ObjCCategoryImplDecl * + if (const ObjCCategoryImplDecl * CID = dyn_cast_or_null(getCursorDecl(C))) return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); } @@ -3298,7 +3299,8 @@ CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, if (C.kind == CXCursor_ModuleImportDecl) { if (pieceIndex > 0) return clang_getNullRange(); - if (ImportDecl *ImportD = dyn_cast_or_null(getCursorDecl(C))) { + if (const ImportDecl *ImportD = + dyn_cast_or_null(getCursorDecl(C))) { ArrayRef Locs = ImportD->getIdentifierLocs(); if (!Locs.empty()) return cxloc::translateSourceRange(Ctx, @@ -3330,15 +3332,15 @@ CXString clang_getCursorDisplayName(CXCursor C) { if (!clang_isDeclaration(C.kind)) return clang_getCursorSpelling(C); - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); if (!D) return createCXString(""); PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); - if (FunctionTemplateDecl *FunTmpl = dyn_cast(D)) + if (const FunctionTemplateDecl *FunTmpl = dyn_cast(D)) D = FunTmpl->getTemplatedDecl(); - if (FunctionDecl *Function = dyn_cast(D)) { + if (const FunctionDecl *Function = dyn_cast(D)) { SmallString<64> Str; llvm::raw_svector_ostream OS(Str); OS << *Function; @@ -3360,7 +3362,7 @@ CXString clang_getCursorDisplayName(CXCursor C) { return createCXString(OS.str()); } - if (ClassTemplateDecl *ClassTemplate = dyn_cast(D)) { + if (const ClassTemplateDecl *ClassTemplate = dyn_cast(D)) { SmallString<64> Str; llvm::raw_svector_ostream OS(Str); OS << *ClassTemplate; @@ -3391,7 +3393,7 @@ CXString clang_getCursorDisplayName(CXCursor C) { return createCXString(OS.str()); } - if (ClassTemplateSpecializationDecl *ClassSpec + if (const ClassTemplateSpecializationDecl *ClassSpec = dyn_cast(D)) { // If the type was explicitly written, use that. if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) @@ -3738,12 +3740,12 @@ static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, if (clang_isDeclaration(cursor.kind)) { // Avoid having the implicit methods override the property decls. - if (ObjCMethodDecl *MD + if (const ObjCMethodDecl *MD = dyn_cast_or_null(getCursorDecl(cursor))) { if (MD->isImplicit()) return CXChildVisit_Break; - } else if (ObjCInterfaceDecl *ID + } else if (const ObjCInterfaceDecl *ID = dyn_cast_or_null(getCursorDecl(cursor))) { // Check that when we have multiple @class references in the same line, // that later ones do not override the previous ones. @@ -3753,7 +3755,7 @@ static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, // 'Foo' even though the cursor location was at 'Foo'. if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || BestCursor->kind == CXCursor_ObjCClassRef) - if (ObjCInterfaceDecl *PrevID + if (const ObjCInterfaceDecl *PrevID = dyn_cast_or_null(getCursorDecl(*BestCursor))){ if (PrevID != ID && !PrevID->isThisDeclarationADefinition() && @@ -3761,7 +3763,7 @@ static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, return CXChildVisit_Break; } - } else if (DeclaratorDecl *DD + } else if (const DeclaratorDecl *DD = dyn_cast_or_null(getCursorDecl(cursor))) { SourceLocation StartLoc = DD->getSourceRange().getBegin(); // Check that when we have multiple declarators in the same line, @@ -3774,7 +3776,7 @@ static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, return CXChildVisit_Break; Data->VisitedDeclaratorDeclStartLoc = StartLoc; - } else if (ObjCPropertyImplDecl *PropImp + } else if (const ObjCPropertyImplDecl *PropImp = dyn_cast_or_null(getCursorDecl(cursor))) { (void)PropImp; // Check that when we have multiple @synthesize in the same line, @@ -3791,7 +3793,7 @@ static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, if (clang_isExpression(cursor.kind) && clang_isDeclaration(BestCursor->kind)) { - if (Decl *D = getCursorDecl(*BestCursor)) { + if (const Decl *D = getCursorDecl(*BestCursor)) { // Avoid having the cursor of an expression replace the declaration cursor // when the expression source range overlaps the declaration range. // This can happen for C++ constructor expressions whose range generally @@ -4064,7 +4066,7 @@ CXSourceLocation clang_getCursorLocation(CXCursor C) { if (!clang_isDeclaration(C.kind)) return clang_getNullLocation(); - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); if (!D) return clang_getNullLocation(); @@ -4074,13 +4076,13 @@ CXSourceLocation clang_getCursorLocation(CXCursor C) { // ranges when accounting for the type-specifier. We use context // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, // and if so, whether it is the first decl. - if (VarDecl *VD = dyn_cast(D)) { + if (const VarDecl *VD = dyn_cast(D)) { if (!cxcursor::isFirstInDeclGroup(C)) Loc = VD->getLocation(); } // For ObjC methods, give the start location of the method name. - if (ObjCMethodDecl *MD = dyn_cast(D)) + if (const ObjCMethodDecl *MD = dyn_cast(D)) Loc = MD->getSelectorStartLoc(); return cxloc::translateSourceLocation(getCursorContext(C), Loc); @@ -4197,7 +4199,7 @@ static SourceRange getRawCursorExtent(CXCursor C) { } if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (!D) return SourceRange(); @@ -4207,7 +4209,7 @@ static SourceRange getRawCursorExtent(CXCursor C) { // ranges when accounting for the type-specifier. We use context // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, // and if so, whether it is the first decl. - if (VarDecl *VD = dyn_cast(D)) { + if (const VarDecl *VD = dyn_cast(D)) { if (!cxcursor::isFirstInDeclGroup(C)) R.setBegin(VD->getLocation()); } @@ -4220,7 +4222,7 @@ static SourceRange getRawCursorExtent(CXCursor C) { /// the decl-specifier-seq for declarations. static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (!D) return SourceRange(); @@ -4232,7 +4234,7 @@ static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { if (const DeclaratorDecl *DD = dyn_cast(D)) { if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) StartLoc = TI->getTypeLoc().getLocStart(); - } else if (TypedefDecl *Typedef = dyn_cast(D)) { + } else if (const TypedefDecl *Typedef = dyn_cast(D)) { if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) StartLoc = TI->getTypeLoc().getLocStart(); } @@ -4246,7 +4248,7 @@ static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { // ranges when accounting for the type-specifier. We use context // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, // and if so, whether it is the first decl. - if (VarDecl *VD = dyn_cast(D)) { + if (const VarDecl *VD = dyn_cast(D)) { if (!cxcursor::isFirstInDeclGroup(C)) R.setBegin(VD->getLocation()); } @@ -4273,12 +4275,13 @@ CXCursor clang_getCursorReferenced(CXCursor C) { CXTranslationUnit tu = getCursorTU(C); if (clang_isDeclaration(C.kind)) { - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); if (!D) return clang_getNullCursor(); - if (UsingDecl *Using = dyn_cast(D)) + if (const UsingDecl *Using = dyn_cast(D)) return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); - if (ObjCPropertyImplDecl *PropImpl =dyn_cast(D)) + if (const ObjCPropertyImplDecl *PropImpl = + dyn_cast(D)) if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) return MakeCXCursor(Property, tu); @@ -4286,8 +4289,8 @@ CXCursor clang_getCursorReferenced(CXCursor C) { } if (clang_isExpression(C.kind)) { - Expr *E = getCursorExpr(C); - Decl *D = getDeclFromExpr(E); + const Expr *E = getCursorExpr(C); + const Decl *D = getDeclFromExpr(E); if (D) { CXCursor declCursor = MakeCXCursor(D, tu); declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), @@ -4295,7 +4298,7 @@ CXCursor clang_getCursorReferenced(CXCursor C) { return declCursor; } - if (OverloadExpr *Ovl = dyn_cast_or_null(E)) + if (const OverloadExpr *Ovl = dyn_cast_or_null(E)) return MakeCursorOverloadedDeclRef(Ovl, tu); return clang_getNullCursor(); @@ -4395,7 +4398,7 @@ CXCursor clang_getCursorDefinition(CXCursor C) { if (!clang_isDeclaration(C.kind)) return clang_getNullCursor(); - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); if (!D) return clang_getNullCursor(); @@ -4468,7 +4471,7 @@ CXCursor clang_getCursorDefinition(CXCursor C) { case Decl::Var: { // Ask the variable if it has a definition. - if (VarDecl *Def = cast(D)->getDefinition()) + if (const VarDecl *Def = cast(D)->getDefinition()) return MakeCXCursor(Def, TU); return clang_getNullCursor(); } @@ -4498,14 +4501,14 @@ CXCursor clang_getCursorDefinition(CXCursor C) { TU)); case Decl::ObjCMethod: { - ObjCMethodDecl *Method = cast(D); + const ObjCMethodDecl *Method = cast(D); if (Method->isThisDeclarationADefinition()) return C; // Dig out the method definition in the associated // @implementation, if we have it. // FIXME: The ASTs should make finding the definition easier. - if (ObjCInterfaceDecl *Class + if (const ObjCInterfaceDecl *Class = dyn_cast(Method->getDeclContext())) if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), @@ -4523,7 +4526,7 @@ CXCursor clang_getCursorDefinition(CXCursor C) { return clang_getNullCursor(); case Decl::ObjCProtocol: - if (ObjCProtocolDecl *Def = cast(D)->getDefinition()) + if (const ObjCProtocolDecl *Def = cast(D)->getDefinition()) return MakeCXCursor(Def, TU); return clang_getNullCursor(); @@ -4533,9 +4536,9 @@ CXCursor clang_getCursorDefinition(CXCursor C) { // reference to an Objective-C class, produce the @interface as // the definition; when we were provided with the interface, // produce the @implementation as the definition. - ObjCInterfaceDecl *IFace = cast(D); + const ObjCInterfaceDecl *IFace = cast(D); if (WasReference) { - if (ObjCInterfaceDecl *Def = IFace->getDefinition()) + if (const ObjCInterfaceDecl *Def = IFace->getDefinition()) return MakeCXCursor(Def, TU); } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) return MakeCXCursor(Impl, TU); @@ -4548,9 +4551,9 @@ CXCursor clang_getCursorDefinition(CXCursor C) { return clang_getNullCursor(); case Decl::ObjCCompatibleAlias: - if (ObjCInterfaceDecl *Class + if (const ObjCInterfaceDecl *Class = cast(D)->getClassInterface()) - if (ObjCInterfaceDecl *Def = Class->getDefinition()) + if (const ObjCInterfaceDecl *Def = Class->getDefinition()) return MakeCXCursor(Def, TU); return clang_getNullCursor(); @@ -4580,13 +4583,13 @@ CXCursor clang_getCanonicalCursor(CXCursor C) { if (!clang_isDeclaration(C.kind)) return C; - if (Decl *D = getCursorDecl(C)) { - if (ObjCCategoryImplDecl *CatImplD = dyn_cast(D)) + if (const Decl *D = getCursorDecl(C)) { + if (const ObjCCategoryImplDecl *CatImplD = dyn_cast(D)) if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) return MakeCXCursor(CatD, getCursorTU(C)); - if (ObjCImplDecl *ImplD = dyn_cast(D)) - if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) + if (const ObjCImplDecl *ImplD = dyn_cast(D)) + if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) return MakeCXCursor(IFD, getCursorTU(C)); return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); @@ -4604,15 +4607,15 @@ unsigned clang_getNumOverloadedDecls(CXCursor C) { return 0; OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; - if (OverloadExpr *E = Storage.dyn_cast()) + if (const OverloadExpr *E = Storage.dyn_cast()) return E->getNumDecls(); if (OverloadedTemplateStorage *S = Storage.dyn_cast()) return S->size(); - Decl *D = Storage.get(); - if (UsingDecl *Using = dyn_cast(D)) + const Decl *D = Storage.get(); + if (const UsingDecl *Using = dyn_cast(D)) return Using->shadow_size(); return 0; @@ -4627,15 +4630,15 @@ CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { CXTranslationUnit TU = getCursorTU(cursor); OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; - if (OverloadExpr *E = Storage.dyn_cast()) + if (const OverloadExpr *E = Storage.dyn_cast()) return MakeCXCursor(E->decls_begin()[index], TU); if (OverloadedTemplateStorage *S = Storage.dyn_cast()) return MakeCXCursor(S->begin()[index], TU); - Decl *D = Storage.get(); - if (UsingDecl *Using = dyn_cast(D)) { + const Decl *D = Storage.get(); + if (const UsingDecl *Using = dyn_cast(D)) { // FIXME: This is, unfortunately, linear time. UsingDecl::shadow_iterator Pos = Using->shadow_begin(); std::advance(Pos, index); @@ -4653,8 +4656,7 @@ void clang_getDefinitionSpellingAndExtent(CXCursor C, unsigned *endLine, unsigned *endColumn) { assert(getCursorDecl(C) && "CXCursor has null decl"); - NamedDecl *ND = static_cast(getCursorDecl(C)); - FunctionDecl *FD = dyn_cast(ND); + const FunctionDecl *FD = dyn_cast(getCursorDecl(C)); CompoundStmt *Body = dyn_cast(FD->getBody()); SourceManager &SM = FD->getASTContext().getSourceManager(); @@ -5067,20 +5069,20 @@ AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { if (!HasContextSensitiveKeywords) { // Objective-C properties can have context-sensitive keywords. if (cursor.kind == CXCursor_ObjCPropertyDecl) { - if (ObjCPropertyDecl *Property + if (const ObjCPropertyDecl *Property = dyn_cast_or_null(getCursorDecl(cursor))) HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; } // Objective-C methods can have context-sensitive keywords. else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || cursor.kind == CXCursor_ObjCClassMethodDecl) { - if (ObjCMethodDecl *Method + if (const ObjCMethodDecl *Method = dyn_cast_or_null(getCursorDecl(cursor))) { if (Method->getObjCDeclQualifier()) HasContextSensitiveKeywords = true; else { - for (ObjCMethodDecl::param_iterator P = Method->param_begin(), - PEnd = Method->param_end(); + for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(), + PEnd = Method->param_end(); P != PEnd; ++P) { if ((*P)->getObjCDeclQualifier()) { HasContextSensitiveKeywords = true; @@ -5092,7 +5094,7 @@ AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { } // C++ methods can have context-sensitive keywords. else if (cursor.kind == CXCursor_CXXMethod) { - if (CXXMethodDecl *Method + if (const CXXMethodDecl *Method = dyn_cast_or_null(getCursorDecl(cursor))) { if (Method->hasAttr() || Method->hasAttr()) HasContextSensitiveKeywords = true; @@ -5103,7 +5105,7 @@ AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { cursor.kind == CXCursor_ClassDecl || cursor.kind == CXCursor_ClassTemplate || cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { - if (Decl *D = getCursorDecl(cursor)) + if (const Decl *D = getCursorDecl(cursor)) if (D->hasAttr()) HasContextSensitiveKeywords = true; } @@ -5497,7 +5499,7 @@ static void clang_annotateTokensImpl(void *UserData) { if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { IdentifierInfo *II = static_cast(Tokens[I].ptr_data); - if (ObjCPropertyDecl *Property + if (const ObjCPropertyDecl *Property = dyn_cast_or_null(getCursorDecl(Cursors[I]))) { if (Property->getPropertyAttributesAsWritten() != 0 && llvm::StringSwitch(II->getName()) @@ -5590,8 +5592,8 @@ CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { if (!clang_isDeclaration(cursor.kind)) return CXLinkage_Invalid; - Decl *D = cxcursor::getCursorDecl(cursor); - if (NamedDecl *ND = dyn_cast_or_null(D)) + const Decl *D = cxcursor::getCursorDecl(cursor); + if (const NamedDecl *ND = dyn_cast_or_null(D)) switch (ND->getLinkage()) { case NoLinkage: return CXLinkage_NoLinkage; case InternalLinkage: return CXLinkage_Internal; @@ -5660,7 +5662,7 @@ extern "C" { enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { if (clang_isDeclaration(cursor.kind)) - if (Decl *D = cxcursor::getCursorDecl(cursor)) { + if (const Decl *D = cxcursor::getCursorDecl(cursor)) { if (isa(D) && cast(D)->isDeleted()) return CXAvailability_Available; @@ -5717,7 +5719,7 @@ int clang_getCursorPlatformAvailability(CXCursor cursor, if (!clang_isDeclaration(cursor.kind)) return 0; - Decl *D = cxcursor::getCursorDecl(cursor); + const Decl *D = cxcursor::getCursorDecl(cursor); if (!D) return 0; @@ -5774,15 +5776,15 @@ CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { /// \brief If the given cursor is the "templated" declaration /// descibing a class or function template, return the class or /// function template. -static Decl *maybeGetTemplateCursor(Decl *D) { +static const Decl *maybeGetTemplateCursor(const Decl *D) { if (!D) return 0; - if (FunctionDecl *FD = dyn_cast(D)) + if (const FunctionDecl *FD = dyn_cast(D)) if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) return FunTmpl; - if (CXXRecordDecl *RD = dyn_cast(D)) + if (const CXXRecordDecl *RD = dyn_cast(D)) if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) return ClassTmpl; @@ -5791,8 +5793,8 @@ static Decl *maybeGetTemplateCursor(Decl *D) { CXCursor clang_getCursorSemanticParent(CXCursor cursor) { if (clang_isDeclaration(cursor.kind)) { - if (Decl *D = getCursorDecl(cursor)) { - DeclContext *DC = D->getDeclContext(); + if (const Decl *D = getCursorDecl(cursor)) { + const DeclContext *DC = D->getDeclContext(); if (!DC) return clang_getNullCursor(); @@ -5802,7 +5804,7 @@ CXCursor clang_getCursorSemanticParent(CXCursor cursor) { } if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { - if (Decl *D = getCursorDecl(cursor)) + if (const Decl *D = getCursorDecl(cursor)) return MakeCXCursor(D, getCursorTU(cursor)); } @@ -5811,8 +5813,8 @@ CXCursor clang_getCursorSemanticParent(CXCursor cursor) { CXCursor clang_getCursorLexicalParent(CXCursor cursor) { if (clang_isDeclaration(cursor.kind)) { - if (Decl *D = getCursorDecl(cursor)) { - DeclContext *DC = D->getLexicalDeclContext(); + if (const Decl *D = getCursorDecl(cursor)) { + const DeclContext *DC = D->getLexicalDeclContext(); if (!DC) return clang_getNullCursor(); @@ -5894,7 +5896,8 @@ CXComment clang_Cursor_getParsedComment(CXCursor C) { CXModule clang_Cursor_getModule(CXCursor C) { if (C.kind == CXCursor_ModuleImportDecl) { - if (ImportDecl *ImportD = dyn_cast_or_null(getCursorDecl(C))) + if (const ImportDecl *ImportD = + dyn_cast_or_null(getCursorDecl(C))) return ImportD->getImportedModule(); } @@ -5951,9 +5954,10 @@ unsigned clang_CXXMethod_isStatic(CXCursor C) { if (!clang_isDeclaration(C.kind)) return 0; - CXXMethodDecl *Method = 0; - Decl *D = cxcursor::getCursorDecl(C); - if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null(D)) + const CXXMethodDecl *Method = 0; + const Decl *D = cxcursor::getCursorDecl(C); + if (const FunctionTemplateDecl *FunTmpl = + dyn_cast_or_null(D)) Method = dyn_cast(FunTmpl->getTemplatedDecl()); else Method = dyn_cast_or_null(D); @@ -5964,9 +5968,10 @@ unsigned clang_CXXMethod_isVirtual(CXCursor C) { if (!clang_isDeclaration(C.kind)) return 0; - CXXMethodDecl *Method = 0; - Decl *D = cxcursor::getCursorDecl(C); - if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null(D)) + const CXXMethodDecl *Method = 0; + const Decl *D = cxcursor::getCursorDecl(C); + if (const FunctionTemplateDecl *FunTmpl = + dyn_cast_or_null(D)) Method = dyn_cast(FunTmpl->getTemplatedDecl()); else Method = dyn_cast_or_null(D); diff --git a/clang/tools/libclang/CIndexCXX.cpp b/clang/tools/libclang/CIndexCXX.cpp index d069d41..c68dde7 100644 --- a/clang/tools/libclang/CIndexCXX.cpp +++ b/clang/tools/libclang/CIndexCXX.cpp @@ -56,13 +56,13 @@ enum CXCursorKind clang_getTemplateCursorKind(CXCursor C) { switch (C.kind) { case CXCursor_ClassTemplate: case CXCursor_FunctionTemplate: - if (TemplateDecl *Template + if (const TemplateDecl *Template = dyn_cast_or_null(getCursorDecl(C))) return MakeCXCursor(Template->getTemplatedDecl(), getCursorTU(C)).kind; break; case CXCursor_ClassTemplatePartialSpecialization: - if (ClassTemplateSpecializationDecl *PartialSpec + if (const ClassTemplateSpecializationDecl *PartialSpec = dyn_cast_or_null( getCursorDecl(C))) { switch (PartialSpec->getTagKind()) { @@ -86,16 +86,16 @@ CXCursor clang_getSpecializedCursorTemplate(CXCursor C) { if (!clang_isDeclaration(C.kind)) return clang_getNullCursor(); - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); if (!D) return clang_getNullCursor(); Decl *Template = 0; - if (CXXRecordDecl *CXXRecord = dyn_cast(D)) { - if (ClassTemplatePartialSpecializationDecl *PartialSpec + if (const CXXRecordDecl *CXXRecord = dyn_cast(D)) { + if (const ClassTemplatePartialSpecializationDecl *PartialSpec = dyn_cast(CXXRecord)) Template = PartialSpec->getSpecializedTemplate(); - else if (ClassTemplateSpecializationDecl *ClassSpec + else if (const ClassTemplateSpecializationDecl *ClassSpec = dyn_cast(CXXRecord)) { llvm::PointerUnion Result @@ -107,14 +107,14 @@ CXCursor clang_getSpecializedCursorTemplate(CXCursor C) { } else Template = CXXRecord->getInstantiatedFromMemberClass(); - } else if (FunctionDecl *Function = dyn_cast(D)) { + } else if (const FunctionDecl *Function = dyn_cast(D)) { Template = Function->getPrimaryTemplate(); if (!Template) Template = Function->getInstantiatedFromMemberFunction(); - } else if (VarDecl *Var = dyn_cast(D)) { + } else if (const VarDecl *Var = dyn_cast(D)) { if (Var->isStaticDataMember()) Template = Var->getInstantiatedFromStaticDataMember(); - } else if (RedeclarableTemplateDecl *Tmpl + } else if (const RedeclarableTemplateDecl *Tmpl = dyn_cast(D)) Template = Tmpl->getInstantiatedFromMemberTemplate(); diff --git a/clang/tools/libclang/CIndexHigh.cpp b/clang/tools/libclang/CIndexHigh.cpp index a2c32fe..bf75f7b 100644 --- a/clang/tools/libclang/CIndexHigh.cpp +++ b/clang/tools/libclang/CIndexHigh.cpp @@ -21,8 +21,8 @@ using namespace cxcursor; using namespace cxindex; static void getTopOverriddenMethods(CXTranslationUnit TU, - Decl *D, - SmallVectorImpl &Methods) { + const Decl *D, + SmallVectorImpl &Methods) { if (!D) return; if (!isa(D) && !isa(D)) @@ -46,15 +46,15 @@ namespace { struct FindFileIdRefVisitData { CXTranslationUnit TU; FileID FID; - Decl *Dcl; + const Decl *Dcl; int SelectorIdIdx; CXCursorAndRangeVisitor visitor; - typedef SmallVector TopMethodsTy; + typedef SmallVector TopMethodsTy; TopMethodsTy TopMethods; FindFileIdRefVisitData(CXTranslationUnit TU, FileID FID, - Decl *D, int selectorIdIdx, + const Decl *D, int selectorIdIdx, CXCursorAndRangeVisitor visitor) : TU(TU), FID(FID), SelectorIdIdx(selectorIdIdx), visitor(visitor) { Dcl = getCanonical(D); @@ -76,24 +76,25 @@ struct FindFileIdRefVisitData { /// /// we consider the canonical decl of the constructor decl to be the class /// itself, so both 'C' can be highlighted. - Decl *getCanonical(Decl *D) const { + const Decl *getCanonical(const Decl *D) const { if (!D) return 0; D = D->getCanonicalDecl(); - if (ObjCImplDecl *ImplD = dyn_cast(D)) { + if (const ObjCImplDecl *ImplD = dyn_cast(D)) { if (ImplD->getClassInterface()) return getCanonical(ImplD->getClassInterface()); - } else if (CXXConstructorDecl *CXXCtorD = dyn_cast(D)) { + } else if (const CXXConstructorDecl *CXXCtorD = + dyn_cast(D)) { return getCanonical(CXXCtorD->getParent()); } return D; } - bool isHit(Decl *D) const { + bool isHit(const Decl *D) const { if (!D) return false; @@ -108,7 +109,7 @@ struct FindFileIdRefVisitData { } private: - bool isOverriddingMethod(Decl *D) const { + bool isOverriddingMethod(const Decl *D) const { if (std::find(TopMethods.begin(), TopMethods.end(), D) != TopMethods.end()) return true; @@ -150,7 +151,7 @@ static enum CXChildVisitResult findFileIdRefVisit(CXCursor cursor, if (!clang_isDeclaration(declCursor.kind)) return CXChildVisit_Recurse; - Decl *D = cxcursor::getCursorDecl(declCursor); + const Decl *D = cxcursor::getCursorDecl(declCursor); if (!D) return CXChildVisit_Continue; @@ -218,7 +219,7 @@ static void findIdRefsInFile(CXTranslationUnit TU, CXCursor declCursor, SourceManager &SM = Unit->getSourceManager(); FileID FID = SM.translateFile(File); - Decl *Dcl = cxcursor::getCursorDecl(declCursor); + const Decl *Dcl = cxcursor::getCursorDecl(declCursor); if (!Dcl) return; @@ -226,7 +227,7 @@ static void findIdRefsInFile(CXTranslationUnit TU, CXCursor declCursor, cxcursor::getSelectorIdentifierIndex(declCursor), Visitor); - if (DeclContext *DC = Dcl->getParentFunctionOrMethod()) { + if (const DeclContext *DC = Dcl->getParentFunctionOrMethod()) { clang_visitChildren(cxcursor::MakeCXCursor(cast(DC), TU), findFileIdRefVisit, &data); return; diff --git a/clang/tools/libclang/CIndexUSRs.cpp b/clang/tools/libclang/CIndexUSRs.cpp index 5942b42..16735f4 100644 --- a/clang/tools/libclang/CIndexUSRs.cpp +++ b/clang/tools/libclang/CIndexUSRs.cpp @@ -821,7 +821,7 @@ CXString clang_getCursorUSR(CXCursor C) { const CXCursorKind &K = clang_getCursorKind(C); if (clang_isDeclaration(K)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (!D) return createCXString(""); diff --git a/clang/tools/libclang/CXCursor.cpp b/clang/tools/libclang/CXCursor.cpp index 2b2ec39..b737eb7 100644 --- a/clang/tools/libclang/CXCursor.cpp +++ b/clang/tools/libclang/CXCursor.cpp @@ -730,7 +730,7 @@ cxcursor::getCursorLabelRef(CXCursor C) { reinterpret_cast(C.data[1]))); } -CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E, +CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E, CXTranslationUnit TU) { assert(E && TU && "Invalid arguments!"); OverloadedDeclRefStorage Storage(E); @@ -742,7 +742,7 @@ CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E, return C; } -CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D, +CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D, SourceLocation Loc, CXTranslationUnit TU) { assert(D && TU && "Invalid arguments!"); @@ -777,8 +777,8 @@ cxcursor::getCursorOverloadedDeclRef(CXCursor C) { reinterpret_cast(C.data[1]))); } -Decl *cxcursor::getCursorDecl(CXCursor Cursor) { - return static_cast(const_cast(Cursor.data[0])); +const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { + return static_cast(Cursor.data[0]); } Expr *cxcursor::getCursorExpr(CXCursor Cursor) { @@ -943,7 +943,7 @@ CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { int clang_Cursor_getNumArguments(CXCursor C) { if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) return MD->param_size(); if (const FunctionDecl *FD = dyn_cast_or_null(D)) @@ -955,12 +955,12 @@ int clang_Cursor_getNumArguments(CXCursor C) { CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); - if (ObjCMethodDecl *MD = dyn_cast_or_null(D)) { + const Decl *D = cxcursor::getCursorDecl(C); + if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) { if (i < MD->param_size()) return cxcursor::MakeCXCursor(MD->param_begin()[i], cxcursor::getCursorTU(C)); - } else if (FunctionDecl *FD = dyn_cast_or_null(D)) { + } else if (const FunctionDecl *FD = dyn_cast_or_null(D)) { if (i < FD->param_size()) return cxcursor::MakeCXCursor(FD->param_begin()[i], cxcursor::getCursorTU(C)); @@ -1039,8 +1039,8 @@ unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { enum CXCursorKind kind = clang_getCursorKind(cursor); if (clang_isDeclaration(kind)) { - Decl *decl = getCursorDecl(cursor); - if (NamedDecl *namedDecl = dyn_cast_or_null(decl)) { + const Decl *decl = getCursorDecl(cursor); + if (const NamedDecl *namedDecl = dyn_cast_or_null(decl)) { ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(namedDecl); CodeCompletionString *String diff --git a/clang/tools/libclang/CXCursor.h b/clang/tools/libclang/CXCursor.h index 880b664..d7e1b5d 100644 --- a/clang/tools/libclang/CXCursor.h +++ b/clang/tools/libclang/CXCursor.h @@ -219,10 +219,11 @@ CXCursor MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, std::pair getCursorLabelRef(CXCursor C); /// \brief Create a overloaded declaration reference cursor for an expression. -CXCursor MakeCursorOverloadedDeclRef(OverloadExpr *E, CXTranslationUnit TU); +CXCursor MakeCursorOverloadedDeclRef(const OverloadExpr *E, + CXTranslationUnit TU); /// \brief Create a overloaded declaration reference cursor for a declaration. -CXCursor MakeCursorOverloadedDeclRef(Decl *D, SourceLocation Location, +CXCursor MakeCursorOverloadedDeclRef(const Decl *D, SourceLocation Location, CXTranslationUnit TU); /// \brief Create a overloaded declaration reference cursor for a template name. @@ -231,7 +232,7 @@ CXCursor MakeCursorOverloadedDeclRef(TemplateName Template, CXTranslationUnit TU); /// \brief Internal storage for an overloaded declaration reference cursor; -typedef llvm::PointerUnion3 OverloadedDeclRefStorage; @@ -240,7 +241,7 @@ typedef llvm::PointerUnion3 getCursorOverloadedDeclRef(CXCursor C); -Decl *getCursorDecl(CXCursor Cursor); +const Decl *getCursorDecl(CXCursor Cursor); Expr *getCursorExpr(CXCursor Cursor); Stmt *getCursorStmt(CXCursor Cursor); Attr *getCursorAttr(CXCursor Cursor); diff --git a/clang/tools/libclang/CXType.cpp b/clang/tools/libclang/CXType.cpp index d7751d2..a574aa4 100644 --- a/clang/tools/libclang/CXType.cpp +++ b/clang/tools/libclang/CXType.cpp @@ -141,19 +141,19 @@ CXType clang_getCursorType(CXCursor C) { } if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (!D) return MakeCXType(QualType(), TU); - if (TypeDecl *TD = dyn_cast(D)) + if (const TypeDecl *TD = dyn_cast(D)) return MakeCXType(Context.getTypeDeclType(TD), TU); - if (ObjCInterfaceDecl *ID = dyn_cast(D)) + if (const ObjCInterfaceDecl *ID = dyn_cast(D)) return MakeCXType(Context.getObjCInterfaceType(ID), TU); - if (ValueDecl *VD = dyn_cast(D)) + if (const ValueDecl *VD = dyn_cast(D)) return MakeCXType(VD->getType(), TU); - if (ObjCPropertyDecl *PD = dyn_cast(D)) + if (const ObjCPropertyDecl *PD = dyn_cast(D)) return MakeCXType(PD->getType(), TU); - if (FunctionDecl *FD = dyn_cast(D)) + if (const FunctionDecl *FD = dyn_cast(D)) return MakeCXType(FD->getType(), TU); return MakeCXType(QualType(), TU); } @@ -205,9 +205,9 @@ CXType clang_getTypedefDeclUnderlyingType(CXCursor C) { CXTranslationUnit TU = cxcursor::getCursorTU(C); if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); - if (TypedefNameDecl *TD = dyn_cast_or_null(D)) { + if (const TypedefNameDecl *TD = dyn_cast_or_null(D)) { QualType T = TD->getUnderlyingType(); return MakeCXType(T, TU); } @@ -223,9 +223,9 @@ CXType clang_getEnumDeclIntegerType(CXCursor C) { CXTranslationUnit TU = cxcursor::getCursorTU(C); if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); - if (EnumDecl *TD = dyn_cast_or_null(D)) { + if (const EnumDecl *TD = dyn_cast_or_null(D)) { QualType T = TD->getIntegerType(); return MakeCXType(T, TU); } @@ -240,9 +240,9 @@ long long clang_getEnumConstantDeclValue(CXCursor C) { using namespace cxcursor; if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); - if (EnumConstantDecl *TD = dyn_cast_or_null(D)) { + if (const EnumConstantDecl *TD = dyn_cast_or_null(D)) { return TD->getInitVal().getSExtValue(); } @@ -256,9 +256,9 @@ unsigned long long clang_getEnumConstantDeclUnsignedValue(CXCursor C) { using namespace cxcursor; if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); - if (EnumConstantDecl *TD = dyn_cast_or_null(D)) { + if (const EnumConstantDecl *TD = dyn_cast_or_null(D)) { return TD->getInitVal().getZExtValue(); } @@ -272,9 +272,9 @@ int clang_getFieldDeclBitWidth(CXCursor C) { using namespace cxcursor; if (clang_isDeclaration(C.kind)) { - Decl *D = getCursorDecl(C); + const Decl *D = getCursorDecl(C); - if (FieldDecl *FD = dyn_cast_or_null(D)) { + if (const FieldDecl *FD = dyn_cast_or_null(D)) { if (FD->isBitField()) return FD->getBitWidthValue(getCursorContext(C)); } @@ -536,7 +536,7 @@ CXType clang_getResultType(CXType X) { CXType clang_getCursorResultType(CXCursor C) { if (clang_isDeclaration(C.kind)) { - Decl *D = cxcursor::getCursorDecl(C); + const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) return MakeCXType(MD->getResultType(), cxcursor::getCursorTU(C)); diff --git a/clang/tools/libclang/CursorVisitor.h b/clang/tools/libclang/CursorVisitor.h index fa978b7..563081e 100644 --- a/clang/tools/libclang/CursorVisitor.h +++ b/clang/tools/libclang/CursorVisitor.h @@ -69,7 +69,7 @@ private: /// \brief The declaration that serves at the parent of any statement or /// expression nodes. - Decl *StmtParent; + const Decl *StmtParent; /// \brief The visitor function. CXCursorVisitor Visitor; @@ -119,11 +119,12 @@ private: class SetParentRAII { CXCursor &Parent; - Decl *&StmtParent; + const Decl *&StmtParent; CXCursor OldParent; public: - SetParentRAII(CXCursor &Parent, Decl *&StmtParent, CXCursor NewParent) + SetParentRAII(CXCursor &Parent, const Decl *&StmtParent, + CXCursor NewParent) : Parent(Parent), StmtParent(StmtParent), OldParent(Parent) { Parent = NewParent; -- 2.7.4