Index: include/clang/Analysis/Analyses/LiveVariables.h =================================================================== --- include/clang/Analysis/Analyses/LiveVariables.h (revision 167358) +++ include/clang/Analysis/Analyses/LiveVariables.h (working copy) @@ -77,17 +77,17 @@ /// Return true if a variable is live at the end of a /// specified block. - bool isLive(const CFGBlock *B, const VarDecl *D); + bool isLive(const CFGBlock *B, const VarDecl *D) const; /// Returns true if a variable is live at the beginning of the /// the statement. This query only works if liveness information /// has been recorded at the statement level (see runOnAllBlocks), and /// only returns liveness information for block-level expressions. - bool isLive(const Stmt *S, const VarDecl *D); + bool isLive(const Stmt *S, const VarDecl *D) const; /// Returns true the block-level expression "value" is live /// before the given block-level expression (see runOnAllBlocks). - bool isLive(const Stmt *Loc, const Stmt *StmtVal); + bool isLive(const Stmt *Loc, const Stmt *StmtVal) const; /// Print to stderr the liveness information associated with /// each basic block. Index: include/clang/Basic/Builtins.h =================================================================== --- include/clang/Basic/Builtins.h (revision 167358) +++ include/clang/Basic/Builtins.h (working copy) @@ -140,12 +140,12 @@ /// \brief Determine whether this builtin is like printf in its /// formatting rules and, if so, set the index to the format string /// argument and whether this function as a va_list argument. - bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg); + bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg) const; /// \brief Determine whether this builtin is like scanf in its /// formatting rules and, if so, set the index to the format string /// argument and whether this function as a va_list argument. - bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg); + bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg) const; /// \brief Return true if this function has no side effects and doesn't /// read memory, except for possibly errno. Index: include/clang/Frontend/ASTUnit.h =================================================================== --- include/clang/Frontend/ASTUnit.h (revision 167358) +++ include/clang/Frontend/ASTUnit.h (working copy) @@ -467,7 +467,7 @@ const FileSystemOptions &getFileSystemOpts() const { return FileSystemOpts; } - StringRef getOriginalSourceFileName() { + StringRef getOriginalSourceFileName() const { return OriginalSourceFile; } @@ -557,8 +557,8 @@ /// preamble, otherwise it returns \p Loc. SourceLocation mapLocationToPreamble(SourceLocation Loc); - bool isInPreambleFileID(SourceLocation Loc); - bool isInMainFileID(SourceLocation Loc); + bool isInPreambleFileID(SourceLocation Loc) const; + bool isInMainFileID(SourceLocation Loc) const; SourceLocation getStartOfMainFileID(); SourceLocation getEndOfPreambleFileID(); @@ -633,7 +633,7 @@ /// \brief Returns true if the ASTUnit was constructed from a serialized /// module file. - bool isModuleFile(); + bool isModuleFile() const; llvm::MemoryBuffer *getBufferForFile(StringRef Filename, std::string *ErrorStr = 0); Index: include/clang/Lex/Lexer.h =================================================================== --- include/clang/Lex/Lexer.h (revision 167358) +++ include/clang/Lex/Lexer.h (working copy) @@ -574,7 +574,7 @@ bool isCodeCompletionPoint(const char *CurPtr) const; void cutOffLexing() { BufferPtr = BufferEnd; } - bool isHexaLiteral(const char *Start, const LangOptions &LangOpts); + bool isHexaLiteral(const char *Start, const LangOptions &LangOpts) const; }; Index: include/clang/Lex/Preprocessor.h =================================================================== --- include/clang/Lex/Preprocessor.h (revision 167358) +++ include/clang/Lex/Preprocessor.h (working copy) @@ -1286,7 +1286,7 @@ /// isNextPPTokenLParen - Determine whether the next preprocessor token to be /// lexed is a '('. If so, consume the token and return true, if not, this /// method should have no observable side-effect on the lexed tokens. - bool isNextPPTokenLParen(); + bool isNextPPTokenLParen() const; /// ReadFunctionLikeMacroArgs - After reading "MACRO(", this method is /// invoked to read all of the formal arguments specified for the macro Index: include/clang/Sema/DeclSpec.h =================================================================== --- include/clang/Sema/DeclSpec.h (revision 167358) +++ include/clang/Sema/DeclSpec.h (working copy) @@ -702,7 +702,7 @@ /// \brief Checks if this DeclSpec can stand alone, without a Declarator. /// /// Only tag declspecs can stand alone. - bool isMissingDeclaratorOk(); + bool isMissingDeclaratorOk() const; }; /// \brief Captures information about "declaration specifiers" specific to Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h (revision 167358) +++ include/clang/Sema/Sema.h (working copy) @@ -1173,7 +1173,7 @@ bool WantNontrivialTypeSourceInfo = false, IdentifierInfo **CorrectedII = 0); TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S); - bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S); + bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) const; bool DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, @@ -1627,7 +1627,7 @@ /// whether the declaration is in scope for the purposes of explicit template /// instantiation or specialization. The default is false. bool isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S = 0, - bool ExplicitInstantiationOrSpecialization = false); + bool ExplicitInstantiationOrSpecialization = false) const; /// Finds the scope corresponding to the given decl context, if it /// happens to be an enclosing scope. Otherwise return NULL. @@ -2844,7 +2844,7 @@ /// \brief Figure out if an expression could be turned into a call. bool isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy, - UnresolvedSetImpl &NonTemplateOverloads); + UnresolvedSetImpl &NonTemplateOverloads) const; /// \brief Conditionally issue a diagnostic based on the current /// evaluation context. @@ -3590,7 +3590,7 @@ /// \brief Determine whether the given function is an implicitly-deleted /// special member function. - bool isImplicitlyDeleted(FunctionDecl *FD); + bool isImplicitlyDeleted(FunctionDecl *FD) const; /// \brief Check whether 'this' shows up in the type of a static member /// function after the (naturally empty) cv-qualifier-seq would be. @@ -3722,7 +3722,7 @@ /// \brief Determine whether the given type is the type of *this that is used /// outside of the body of a member function for a type that is currently /// being defined. - bool isThisOutsideMemberFunctionBody(QualType BaseType); + bool isThisOutsideMemberFunctionBody(QualType BaseType) const; /// ActOnCXXBoolLiteral - Parse {true,false} literals. ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind); @@ -3926,7 +3926,7 @@ DeclContext *computeDeclContext(QualType T); DeclContext *computeDeclContext(const CXXScopeSpec &SS, bool EnteringContext = false); - bool isDependentScopeSpecifier(const CXXScopeSpec &SS); + bool isDependentScopeSpecifier(const CXXScopeSpec &SS) const; CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS); bool isUnknownSpecialization(const CXXScopeSpec &SS); @@ -3943,7 +3943,7 @@ bool ActOnCXXGlobalScopeSpecifier(Scope *S, SourceLocation CCLoc, CXXScopeSpec &SS); - bool isAcceptableNestedNameSpecifier(NamedDecl *SD); + bool isAcceptableNestedNameSpecifier(NamedDecl *SD) const; NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS); bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, @@ -4390,7 +4390,7 @@ void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method); void ActOnFinishDelayedMemberInitializers(Decl *Record); void MarkAsLateParsedTemplate(FunctionDecl *FD, bool Flag = true); - bool IsInsideALocalClassWithinATemplateFunction(); + bool IsInsideALocalClassWithinATemplateFunction() const; Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, @@ -4446,8 +4446,8 @@ void ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases, unsigned NumBases); - bool IsDerivedFrom(QualType Derived, QualType Base); - bool IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths); + bool IsDerivedFrom(QualType Derived, QualType Base) const; + bool IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) const; // FIXME: I don't like this name. void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath); @@ -6530,7 +6530,7 @@ }; // Determines which VarArgKind fits an expression. - VarArgKind isValidVarArgType(const QualType &Ty); + VarArgKind isValidVarArgType(const QualType &Ty) const; /// GatherArgumentsForCall - Collector argument expressions for various /// form of call prototypes. @@ -6671,7 +6671,8 @@ AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS); - bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType); + bool IsStringLiteralToNonConstPointerConversion(Expr *From, + QualType ToType) const; bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType); Index: lib/AST/ASTImporter.cpp =================================================================== --- lib/AST/ASTImporter.cpp (revision 167358) +++ lib/AST/ASTImporter.cpp (working copy) @@ -120,9 +120,10 @@ unsigned NumFromArgs, SmallVectorImpl &ToArgs); bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, - bool Complain = true); - bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); - bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); + bool Complain = true) const; + bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord) const; + bool IsStructuralMatch(ClassTemplateDecl *From, + ClassTemplateDecl *To) const; Decl *VisitDecl(Decl *D); Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); Decl *VisitNamespaceDecl(NamespaceDecl *D); @@ -2128,7 +2129,8 @@ } bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, - RecordDecl *ToRecord, bool Complain) { + RecordDecl *ToRecord, + bool Complain) const { StructuralEquivalenceContext Ctx(Importer.getFromContext(), Importer.getToContext(), Importer.getNonEquivalentDecls(), @@ -2136,7 +2138,8 @@ return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord); } -bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { +bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, + EnumDecl *ToEnum) const { StructuralEquivalenceContext Ctx(Importer.getFromContext(), Importer.getToContext(), Importer.getNonEquivalentDecls()); @@ -2144,7 +2147,7 @@ } bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, - ClassTemplateDecl *To) { + ClassTemplateDecl *To) const { StructuralEquivalenceContext Ctx(Importer.getFromContext(), Importer.getToContext(), Importer.getNonEquivalentDecls()); Index: lib/Analysis/AnalysisDeclContext.cpp =================================================================== --- lib/Analysis/AnalysisDeclContext.cpp (revision 167358) +++ lib/Analysis/AnalysisDeclContext.cpp (working copy) @@ -386,7 +386,7 @@ BumpVectorContext &bc) : BEVals(bevals), BC(bc) {} - bool IsTrackedDecl(const VarDecl *VD) { + bool IsTrackedDecl(const VarDecl *VD) const { const DeclContext *DC = VD->getDeclContext(); return IgnoredContexts.count(DC) == 0; } Index: lib/Analysis/LiveVariables.cpp =================================================================== --- lib/Analysis/LiveVariables.cpp (revision 167358) +++ lib/Analysis/LiveVariables.cpp (working copy) @@ -180,15 +180,15 @@ return D->hasGlobalStorage(); } -bool LiveVariables::isLive(const CFGBlock *B, const VarDecl *D) { +bool LiveVariables::isLive(const CFGBlock *B, const VarDecl *D) const { return isAlwaysAlive(D) || getImpl(impl).blocksEndToLiveness[B].isLive(D); } -bool LiveVariables::isLive(const Stmt *S, const VarDecl *D) { +bool LiveVariables::isLive(const Stmt *S, const VarDecl *D) const { return isAlwaysAlive(D) || getImpl(impl).stmtsToLiveness[S].isLive(D); } -bool LiveVariables::isLive(const Stmt *Loc, const Stmt *S) { +bool LiveVariables::isLive(const Stmt *Loc, const Stmt *S) const { return getImpl(impl).stmtsToLiveness[Loc].isLive(S); } Index: lib/Analysis/ThreadSafety.cpp =================================================================== --- lib/Analysis/ThreadSafety.cpp (revision 167358) +++ lib/Analysis/ThreadSafety.cpp (working copy) @@ -768,7 +768,7 @@ ID.AddInteger(LKind); } - bool isAtLeast(LockKind LK) { + bool isAtLeast(LockKind LK) const { return (LK == LK_Shared) || (LKind == LK_Exclusive); } }; @@ -956,7 +956,7 @@ unsigned Ref; // Reference to another VarDefinition Context Ctx; // The map with which Exp should be interpreted. - bool isReference() { return !Exp; } + bool isReference() const { return !Exp; } private: // Create ordinary variable definition Index: lib/Analysis/UninitializedValues.cpp =================================================================== --- lib/Analysis/UninitializedValues.cpp (revision 167358) +++ lib/Analysis/UninitializedValues.cpp (working copy) @@ -429,7 +429,7 @@ void VisitObjCForCollectionStmt(ObjCForCollectionStmt *FS); void VisitObjCMessageExpr(ObjCMessageExpr *ME); - bool isTrackedVar(const VarDecl *vd) { + bool isTrackedVar(const VarDecl *vd) const { return ::isTrackedVar(vd, cast(ac.getDecl())); } Index: lib/Basic/Builtins.cpp =================================================================== --- lib/Basic/Builtins.cpp (revision 167358) +++ lib/Basic/Builtins.cpp (working copy) @@ -83,7 +83,7 @@ bool Builtin::Context::isPrintfLike(unsigned ID, unsigned &FormatIdx, - bool &HasVAListArg) { + bool &HasVAListArg) const { const char *Printf = strpbrk(GetRecord(ID).Attributes, "pP"); if (!Printf) return false; @@ -102,7 +102,7 @@ // FIXME: Refactor with isPrintfLike. bool Builtin::Context::isScanfLike(unsigned ID, unsigned &FormatIdx, - bool &HasVAListArg) { + bool &HasVAListArg) const { const char *Scanf = strpbrk(GetRecord(ID).Attributes, "sS"); if (!Scanf) return false; Index: lib/Frontend/ASTUnit.cpp =================================================================== --- lib/Frontend/ASTUnit.cpp (revision 167358) +++ lib/Frontend/ASTUnit.cpp (working copy) @@ -2742,7 +2742,7 @@ return Loc; } -bool ASTUnit::isInPreambleFileID(SourceLocation Loc) { +bool ASTUnit::isInPreambleFileID(SourceLocation Loc) const { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); @@ -2753,7 +2753,7 @@ return SourceMgr->isInFileID(Loc, FID); } -bool ASTUnit::isInMainFileID(SourceLocation Loc) { +bool ASTUnit::isInMainFileID(SourceLocation Loc) const { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); @@ -2861,7 +2861,7 @@ return 0; } -bool ASTUnit::isModuleFile() { +bool ASTUnit::isModuleFile() const { return isMainFileAST() && !ASTFileLangOpts.CurrentModule.empty(); } Index: lib/Lex/Lexer.cpp =================================================================== --- lib/Lex/Lexer.cpp (revision 167358) +++ lib/Lex/Lexer.cpp (working copy) @@ -1537,7 +1537,7 @@ /// isHexaLiteral - Return true if Start points to a hex constant. /// in microsoft mode (where this is supposed to be several different tokens). -bool Lexer::isHexaLiteral(const char *Start, const LangOptions &LangOpts) { +bool Lexer::isHexaLiteral(const char *Start, const LangOptions &LangOpts) const { unsigned Size; char C1 = Lexer::getCharAndSizeNoWarn(Start, Size, LangOpts); if (C1 != '0') Index: lib/Lex/PPMacroExpansion.cpp =================================================================== --- lib/Lex/PPMacroExpansion.cpp (revision 167358) +++ lib/Lex/PPMacroExpansion.cpp (working copy) @@ -260,7 +260,7 @@ /// isNextPPTokenLParen - Determine whether the next preprocessor token to be /// lexed is a '('. If so, consume the token and return true, if not, this /// method should have no observable side-effect on the lexed tokens. -bool Preprocessor::isNextPPTokenLParen() { +bool Preprocessor::isNextPPTokenLParen() const { // Do some quick tests for rejection cases. unsigned Val; if (CurLexer) @@ -277,7 +277,7 @@ if (CurPPLexer) return false; for (unsigned i = IncludeMacroStack.size(); i != 0; --i) { - IncludeStackInfo &Entry = IncludeMacroStack[i-1]; + const IncludeStackInfo &Entry = IncludeMacroStack[i-1]; if (Entry.TheLexer) Val = Entry.TheLexer->isNextPPTokenLParen(); else if (Entry.ThePTHLexer) Index: lib/Sema/DeclSpec.cpp =================================================================== --- lib/Sema/DeclSpec.cpp (revision 167358) +++ lib/Sema/DeclSpec.cpp (working copy) @@ -957,7 +957,7 @@ // 'data definition has no type or storage class'? } -bool DeclSpec::isMissingDeclaratorOk() { +bool DeclSpec::isMissingDeclaratorOk() const { TST tst = getTypeSpecType(); return isDeclRep(tst) && getRepAsDecl() != 0 && StorageClassSpec != DeclSpec::SCS_typedef; Index: lib/Sema/Sema.cpp =================================================================== --- lib/Sema/Sema.cpp (revision 167358) +++ lib/Sema/Sema.cpp (working copy) @@ -1104,7 +1104,7 @@ /// \param OverloadSet - If the expression is an overloaded function /// name, this parameter is populated with the decls of the various overloads. bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy, - UnresolvedSetImpl &OverloadSet) { + UnresolvedSetImpl &OverloadSet) const { ZeroArgCallReturnTy = QualType(); OverloadSet.clear(); Index: lib/Sema/SemaCXXScopeSpec.cpp =================================================================== --- lib/Sema/SemaCXXScopeSpec.cpp (revision 167358) +++ lib/Sema/SemaCXXScopeSpec.cpp (working copy) @@ -160,7 +160,7 @@ llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); } -bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) { +bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) const { if (!SS.isSet() || SS.isInvalid()) return false; @@ -269,7 +269,7 @@ /// \brief Determines whether the given declaration is an valid acceptable /// result for name lookup of a nested-name-specifier. -bool Sema::isAcceptableNestedNameSpecifier(NamedDecl *SD) { +bool Sema::isAcceptableNestedNameSpecifier(NamedDecl *SD) const { if (!SD) return false; Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp (revision 167358) +++ lib/Sema/SemaDecl.cpp (working copy) @@ -385,7 +385,7 @@ /// A::TYPE a; // no typename required because A is a base class. /// }; /// @endcode -bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { +bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) const { if (CurContext->isRecord()) { const Type *Ty = SS->getScopeRep()->getAsType(); @@ -1096,7 +1096,7 @@ } bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S, - bool ExplicitInstantiationOrSpecialization) { + bool ExplicitInstantiationOrSpecialization) const { return IdResolver.isDeclInScope(D, Ctx, Context, S, ExplicitInstantiationOrSpecialization); } Index: lib/Sema/SemaDeclCXX.cpp =================================================================== --- lib/Sema/SemaDeclCXX.cpp (revision 167358) +++ lib/Sema/SemaDeclCXX.cpp (working copy) @@ -1231,7 +1231,7 @@ /// \brief Determine whether the type \p Derived is a C++ class that is /// derived from the type \p Base. -bool Sema::IsDerivedFrom(QualType Derived, QualType Base) { +bool Sema::IsDerivedFrom(QualType Derived, QualType Base) const { if (!getLangOpts().CPlusPlus) return false; @@ -1249,7 +1249,7 @@ /// \brief Determine whether the type \p Derived is a C++ class that is /// derived from the type \p Base. -bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) { +bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) const { if (!getLangOpts().CPlusPlus) return false; @@ -9013,7 +9013,7 @@ } } -bool Sema::isImplicitlyDeleted(FunctionDecl *FD) { +bool Sema::isImplicitlyDeleted(FunctionDecl *FD) const { return FD->isDeleted() && (FD->isDefaulted() || FD->isImplicit()) && isa(FD); Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp (revision 167358) +++ lib/Sema/SemaExpr.cpp (working copy) @@ -625,7 +625,7 @@ /// Determine the degree of POD-ness for an expression. /// Incomplete types are considered POD, since this check can be performed /// when we're in an unevaluated context. -Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) { +Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) const { if (Ty->isIncompleteType()) { if (Ty->isObjCObjectType()) return VAK_Invalid; Index: lib/Sema/SemaExprCXX.cpp =================================================================== --- lib/Sema/SemaExprCXX.cpp (revision 167358) +++ lib/Sema/SemaExprCXX.cpp (working copy) @@ -750,7 +750,7 @@ return Owned(new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false)); } -bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) { +bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) const { // If we're outside the body of a member function, then we'll have a specified // type for 'this'. if (CXXThisTypeOverride.isNull()) @@ -2268,7 +2268,8 @@ /// non-const wchar_t (for narrow and wide string literals, /// respectively). bool -Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { +Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, + QualType ToType) const { // Look inside the implicit cast, if it exists. if (ImplicitCastExpr *Cast = dyn_cast(From)) From = Cast->getSubExpr(); Index: lib/Sema/SemaStmt.cpp =================================================================== --- lib/Sema/SemaStmt.cpp (revision 167358) +++ lib/Sema/SemaStmt.cpp (working copy) @@ -1182,7 +1182,7 @@ Ranges(Ranges), Simple(true) {} - bool isSimple() { return Simple; } + bool isSimple() const { return Simple; } // Replaces the method in EvaluatedExprVisitor. void VisitMemberExpr(MemberExpr* E) { Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp (revision 167358) +++ lib/Sema/SemaTemplate.cpp (working copy) @@ -7351,7 +7351,7 @@ FD->setLateTemplateParsed(Flag); } -bool Sema::IsInsideALocalClassWithinATemplateFunction() { +bool Sema::IsInsideALocalClassWithinATemplateFunction() const { DeclContext *DC = CurContext; while (DC) { Index: utils/TableGen/ClangDiagnosticsEmitter.cpp =================================================================== --- utils/TableGen/ClangDiagnosticsEmitter.cpp (revision 167358) +++ utils/TableGen/ClangDiagnosticsEmitter.cpp (working copy) @@ -203,10 +203,10 @@ llvm::StringRef RootGroupName); /// Determine if the diagnostic is an extension. - bool isExtension(const Record *Diag); + bool isExtension(const Record *Diag) const; /// Determine if the diagnostic is off by default. - bool isOffByDefault(const Record *Diag); + bool isOffByDefault(const Record *Diag) const; /// Increment the count for a group, and transitively marked /// parent groups when appropriate. @@ -233,12 +233,12 @@ } /// Determine if the diagnostic is an extension. -bool InferPedantic::isExtension(const Record *Diag) { +bool InferPedantic::isExtension(const Record *Diag) const { const std::string &ClsName = Diag->getValueAsDef("Class")->getName(); return ClsName == "CLASS_EXTENSION"; } -bool InferPedantic::isOffByDefault(const Record *Diag) { +bool InferPedantic::isOffByDefault(const Record *Diag) const { const std::string &DefMap = Diag->getValueAsDef("DefaultMapping")->getName(); return DefMap == "MAP_IGNORE"; }