head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.14 netbsd-11-0-RC3:1.1.1.14 netbsd-11-0-RC2:1.1.1.14 netbsd-11-0-RC1:1.1.1.14 perseant-exfatfs-base-20250801:1.1.1.14 netbsd-11:1.1.1.14.0.10 netbsd-11-base:1.1.1.14 netbsd-10-1-RELEASE:1.1.1.14 perseant-exfatfs-base-20240630:1.1.1.14 perseant-exfatfs:1.1.1.14.0.8 perseant-exfatfs-base:1.1.1.14 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.13 netbsd-10-0-RELEASE:1.1.1.14 netbsd-10-0-RC6:1.1.1.14 netbsd-10-0-RC5:1.1.1.14 netbsd-10-0-RC4:1.1.1.14 netbsd-10-0-RC3:1.1.1.14 netbsd-10-0-RC2:1.1.1.14 netbsd-10-0-RC1:1.1.1.14 netbsd-10:1.1.1.14.0.6 netbsd-10-base:1.1.1.14 netbsd-9-3-RELEASE:1.1.1.13 cjep_sun2x:1.1.1.14.0.4 cjep_sun2x-base:1.1.1.14 cjep_staticlib_x-base1:1.1.1.14 netbsd-9-2-RELEASE:1.1.1.13 cjep_staticlib_x:1.1.1.14.0.2 cjep_staticlib_x-base:1.1.1.14 netbsd-9-1-RELEASE:1.1.1.13 phil-wifi-20200421:1.1.1.14 phil-wifi-20200411:1.1.1.14 phil-wifi-20200406:1.1.1.14 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.13 netbsd-9-0-RC2:1.1.1.13 netbsd-9-0-RC1:1.1.1.13 netbsd-9:1.1.1.13.0.2 netbsd-9-base:1.1.1.13 phil-wifi-20190609:1.1.1.13 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.12.2.1 pgoyette-compat-20190127:1.1.1.13 pgoyette-compat-20190118:1.1.1.13 pgoyette-compat-1226:1.1.1.13 pgoyette-compat-1126:1.1.1.13 pgoyette-compat-1020:1.1.1.13 pgoyette-compat-0930:1.1.1.13 pgoyette-compat-0906:1.1.1.13 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.13 clang-337282:1.1.1.13 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.12.0.4 phil-wifi-base:1.1.1.12 pgoyette-compat-0625:1.1.1.12 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.12 pgoyette-compat-0502:1.1.1.12 pgoyette-compat-0422:1.1.1.12 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.12 pgoyette-compat-0407:1.1.1.12 pgoyette-compat-0330:1.1.1.12 pgoyette-compat-0322:1.1.1.12 pgoyette-compat-0315:1.1.1.12 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.12.0.2 pgoyette-compat-base:1.1.1.12 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.12 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.50; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.50; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.45; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.23; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.19; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.54.16; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.30; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.29; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.57; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.33.52; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.35.00; author joerg; state Exp; branches; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2017.12.17.20.58.56; author joerg; state Exp; branches 1.1.1.12.2.1 1.1.1.12.4.1; next 1.1.1.13; commitid T7p9sjiUJyY1UhjA; 1.1.1.13 date 2018.07.17.18.31.18; author joerg; state Exp; branches; next 1.1.1.14; commitid wDzL46ALjrCZgwKA; 1.1.1.14 date 2019.11.13.22.19.26; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.09; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.54.16; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.29; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.30; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.30; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.40; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.12.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.12.4.1 date 2019.06.10.21.45.26; author christos; state Exp; branches; next 1.1.1.12.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.12.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// // // 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 actions class which performs semantic analysis and // builds an AST out of a parse stream. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "TargetAttributesSema.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTDiagnostic.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CXXFieldCollector.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/ExternalSemaSource.h" #include "clang/Sema/MultiplexExternalSemaSource.h" #include "clang/Sema/ObjCMethodList.h" #include "clang/Sema/PrettyDeclStackTrace.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaConsumer.h" #include "clang/Sema/TemplateDeduction.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/CrashRecoveryContext.h" using namespace clang; using namespace sema; PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, const Preprocessor &PP) { PrintingPolicy Policy = Context.getPrintingPolicy(); Policy.Bool = Context.getLangOpts().Bool; if (!Policy.Bool) { if (const MacroInfo * BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) { Policy.Bool = BoolMacro->isObjectLike() && BoolMacro->getNumTokens() == 1 && BoolMacro->getReplacementToken(0).is(tok::kw__Bool); } } return Policy; } void Sema::ActOnTranslationUnitScope(Scope *S) { TUScope = S; PushDeclContext(S, Context.getTranslationUnitDecl()); VAListTagName = PP.getIdentifierInfo("__va_list_tag"); } Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter) : TheTargetAttributesSema(0), ExternalSource(0), isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), CollectStats(false), CodeCompleter(CodeCompleter), CurContext(0), OriginalLexicalContext(0), PackContext(0), MSStructPragmaOn(false), VisContext(0), IsBuildingRecoveryCallExpr(false), ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0), IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0), NSNumberDecl(0), NSStringDecl(0), StringWithUTF8StringMethod(0), NSArrayDecl(0), ArrayWithObjectsMethod(0), NSDictionaryDecl(0), DictionaryWithObjectsMethod(0), GlobalNewDeleteDeclared(false), TUKind(TUKind), NumSFINAEErrors(0), InFunctionDeclarator(0), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(0), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), VarDataSharingAttributesStack(0), CurScope(0), Ident_super(0), Ident___float128(0) { TUScope = 0; LoadedExternalKnownNamespaces = false; for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) NSNumberLiteralMethods[I] = 0; if (getLangOpts().ObjC1) NSAPIObj.reset(new NSAPI(Context)); if (getLangOpts().CPlusPlus) FieldCollector.reset(new CXXFieldCollector()); // Tell diagnostics how to render things from the AST library. PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); ExprEvalContexts.push_back( ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, false, 0, false)); FunctionScopes.push_back(new FunctionScopeInfo(Diags)); // Initilization of data sharing attributes stack for OpenMP InitDataSharingAttributesStack(); } void Sema::Initialize() { // Tell the AST consumer about this Sema object. Consumer.Initialize(Context); // FIXME: Isn't this redundant with the initialization above? if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->InitializeSema(*this); // Tell the external Sema source about this Sema object. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->InitializeSema(*this); // Initialize predefined 128-bit integer types, if needed. if (PP.getTargetInfo().hasInt128Type()) { // If either of the 128-bit integer types are unavailable to name lookup, // define them now. DeclarationName Int128 = &Context.Idents.get("__int128_t"); if (IdResolver.begin(Int128) == IdResolver.end()) PushOnScopeChains(Context.getInt128Decl(), TUScope); DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); if (IdResolver.begin(UInt128) == IdResolver.end()) PushOnScopeChains(Context.getUInt128Decl(), TUScope); } // Initialize predefined Objective-C types: if (PP.getLangOpts().ObjC1) { // If 'SEL' does not yet refer to any declarations, make it refer to the // predefined 'SEL'. DeclarationName SEL = &Context.Idents.get("SEL"); if (IdResolver.begin(SEL) == IdResolver.end()) PushOnScopeChains(Context.getObjCSelDecl(), TUScope); // If 'id' does not yet refer to any declarations, make it refer to the // predefined 'id'. DeclarationName Id = &Context.Idents.get("id"); if (IdResolver.begin(Id) == IdResolver.end()) PushOnScopeChains(Context.getObjCIdDecl(), TUScope); // Create the built-in typedef for 'Class'. DeclarationName Class = &Context.Idents.get("Class"); if (IdResolver.begin(Class) == IdResolver.end()) PushOnScopeChains(Context.getObjCClassDecl(), TUScope); // Create the built-in forward declaratino for 'Protocol'. DeclarationName Protocol = &Context.Idents.get("Protocol"); if (IdResolver.begin(Protocol) == IdResolver.end()) PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); } DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); } Sema::~Sema() { for (LateParsedTemplateMapT::iterator I = LateParsedTemplateMap.begin(), E = LateParsedTemplateMap.end(); I != E; ++I) delete I->second; if (PackContext) FreePackedContext(); if (VisContext) FreeVisContext(); delete TheTargetAttributesSema; MSStructPragmaOn = false; // Kill all the active scopes. for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I) delete FunctionScopes[I]; if (FunctionScopes.size() == 1) delete FunctionScopes[0]; // Tell the SemaConsumer to forget about us; we're going out of scope. if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->ForgetSema(); // Detach from the external Sema source. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->ForgetSema(); // If Sema's ExternalSource is the multiplexer - we own it. if (isMultiplexExternalSource) delete ExternalSource; // Destroys data sharing attributes stack for OpenMP DestroyDataSharingAttributesStack(); } /// makeUnavailableInSystemHeader - There is an error in the current /// context. If we're still in a system header, and we can plausibly /// make the relevant declaration unavailable instead of erroring, do /// so and return true. bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, StringRef msg) { // If we're not in a function, it's an error. FunctionDecl *fn = dyn_cast(CurContext); if (!fn) return false; // If we're in template instantiation, it's an error. if (!ActiveTemplateInstantiations.empty()) return false; // If that function's not in a system header, it's an error. if (!Context.getSourceManager().isInSystemHeader(loc)) return false; // If the function is already unavailable, it's not an error. if (fn->hasAttr()) return true; fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg)); return true; } ASTMutationListener *Sema::getASTMutationListener() const { return getASTConsumer().GetASTMutationListener(); } ///\brief Registers an external source. If an external source already exists, /// creates a multiplex external source and appends to it. /// ///\param[in] E - A non-null external sema source. /// void Sema::addExternalSource(ExternalSemaSource *E) { assert(E && "Cannot use with NULL ptr"); if (!ExternalSource) { ExternalSource = E; return; } if (isMultiplexExternalSource) static_cast(ExternalSource)->addSource(*E); else { ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E); isMultiplexExternalSource = true; } } /// \brief Print out statistics about the semantic analysis. void Sema::PrintStats() const { llvm::errs() << "\n*** Semantic Analysis Stats:\n"; llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; BumpAlloc.PrintStats(); AnalysisWarnings.PrintStats(); } /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. /// If there is already an implicit cast, merge into the existing one. /// The result is of the given category. ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, CastKind Kind, ExprValueKind VK, const CXXCastPath *BasePath, CheckedConversionKind CCK) { #ifndef NDEBUG if (VK == VK_RValue && !E->isRValue()) { switch (Kind) { default: assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind"); case CK_LValueToRValue: case CK_ArrayToPointerDecay: case CK_FunctionToPointerDecay: case CK_ToVoid: break; } } assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); #endif QualType ExprTy = Context.getCanonicalType(E->getType()); QualType TypeTy = Context.getCanonicalType(Ty); if (ExprTy == TypeTy) return Owned(E); // If this is a derived-to-base cast to a through a virtual base, we // need a vtable. if (Kind == CK_DerivedToBase && BasePathInvolvesVirtualBase(*BasePath)) { QualType T = E->getType(); if (const PointerType *Pointer = T->getAs()) T = Pointer->getPointeeType(); if (const RecordType *RecordTy = T->getAs()) MarkVTableUsed(E->getLocStart(), cast(RecordTy->getDecl())); } if (ImplicitCastExpr *ImpCast = dyn_cast(E)) { if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { ImpCast->setType(Ty); ImpCast->setValueKind(VK); return Owned(E); } } return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK)); } /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding /// to the conversion from scalar type ScalarTy to the Boolean type. CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { switch (ScalarTy->getScalarTypeKind()) { case Type::STK_Bool: return CK_NoOp; case Type::STK_CPointer: return CK_PointerToBoolean; case Type::STK_BlockPointer: return CK_PointerToBoolean; case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; case Type::STK_Integral: return CK_IntegralToBoolean; case Type::STK_Floating: return CK_FloatingToBoolean; case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; } return CK_Invalid; } /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { if (D->getMostRecentDecl()->isUsed()) return true; if (D->isExternallyVisible()) return true; if (const FunctionDecl *FD = dyn_cast(D)) { // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const FunctionDecl *DeclToCheck; if (FD->hasBody(DeclToCheck)) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = FD->getMostRecentDecl(); if (DeclToCheck != FD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } if (const VarDecl *VD = dyn_cast(D)) { // If a variable usable in constant expressions is referenced, // don't warn if it isn't used: if the value of a variable is required // for the computation of a constant expression, it doesn't make sense to // warn even if the variable isn't odr-used. (isReferenced doesn't // precisely reflect that, but it's a decent approximation.) if (VD->isReferenced() && VD->isUsableInConstantExpressions(SemaRef->Context)) return true; // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const VarDecl *DeclToCheck = VD->getDefinition(); if (DeclToCheck) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = VD->getMostRecentDecl(); if (DeclToCheck != VD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } return false; } namespace { struct SortUndefinedButUsed { const SourceManager &SM; explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {} bool operator()(const std::pair &l, const std::pair &r) const { if (l.second.isValid() && !r.second.isValid()) return true; if (!l.second.isValid() && r.second.isValid()) return false; if (l.second != r.second) return SM.isBeforeInTranslationUnit(l.second, r.second); return SM.isBeforeInTranslationUnit(l.first->getLocation(), r.first->getLocation()); } }; } /// Obtains a sorted list of functions that are undefined but ODR-used. void Sema::getUndefinedButUsed( SmallVectorImpl > &Undefined) { for (llvm::DenseMap::iterator I = UndefinedButUsed.begin(), E = UndefinedButUsed.end(); I != E; ++I) { NamedDecl *ND = I->first; // Ignore attributes that have become invalid. if (ND->isInvalidDecl()) continue; // __attribute__((weakref)) is basically a definition. if (ND->hasAttr()) continue; if (FunctionDecl *FD = dyn_cast(ND)) { if (FD->isDefined()) continue; if (FD->isExternallyVisible() && !FD->getMostRecentDecl()->isInlined()) continue; } else { if (cast(ND)->hasDefinition() != VarDecl::DeclarationOnly) continue; if (ND->isExternallyVisible()) continue; } Undefined.push_back(std::make_pair(ND, I->second)); } // Sort (in order of use site) so that we're not dependent on the iteration // order through an llvm::DenseMap. std::sort(Undefined.begin(), Undefined.end(), SortUndefinedButUsed(Context.getSourceManager())); } /// checkUndefinedButUsed - Check for undefined objects with internal linkage /// or that are inline. static void checkUndefinedButUsed(Sema &S) { if (S.UndefinedButUsed.empty()) return; // Collect all the still-undefined entities with internal linkage. SmallVector, 16> Undefined; S.getUndefinedButUsed(Undefined); if (Undefined.empty()) return; for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { NamedDecl *ND = I->first; if (!ND->isExternallyVisible()) { S.Diag(ND->getLocation(), diag::warn_undefined_internal) << isa(ND) << ND; } else { assert(cast(ND)->getMostRecentDecl()->isInlined() && "used object requires definition but isn't inline or internal?"); S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND; } if (I->second.isValid()) S.Diag(I->second, diag::note_used_here); } } void Sema::LoadExternalWeakUndeclaredIdentifiers() { if (!ExternalSource) return; SmallVector, 4> WeakIDs; ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) { llvm::DenseMap::iterator Pos = WeakUndeclaredIdentifiers.find(WeakIDs[I].first); if (Pos != WeakUndeclaredIdentifiers.end()) continue; WeakUndeclaredIdentifiers.insert(WeakIDs[I]); } } typedef llvm::DenseMap RecordCompleteMap; /// \brief Returns true, if all methods and nested classes of the given /// CXXRecordDecl are defined in this translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = MNCComplete.find(RD); if (Cache != MNCComplete.end()) return Cache->second; if (!RD->isCompleteDefinition()) return false; bool Complete = true; for (DeclContext::decl_iterator I = RD->decls_begin(), E = RD->decls_end(); I != E && Complete; ++I) { if (const CXXMethodDecl *M = dyn_cast(*I)) Complete = M->isDefined() || (M->isPure() && !isa(M)); else if (const FunctionTemplateDecl *F = dyn_cast(*I)) Complete = F->getTemplatedDecl()->isDefined(); else if (const CXXRecordDecl *R = dyn_cast(*I)) { if (R->isInjectedClassName()) continue; if (R->hasDefinition()) Complete = MethodsAndNestedClassesComplete(R->getDefinition(), MNCComplete); else Complete = false; } } MNCComplete[RD] = Complete; return Complete; } /// \brief Returns true, if the given CXXRecordDecl is fully defined in this /// translation unit, i.e. all methods are defined or pure virtual and all /// friends, friend functions and nested classes are fully defined in this /// translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool IsRecordFullyDefined(const CXXRecordDecl *RD, RecordCompleteMap &RecordsComplete, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); if (Cache != RecordsComplete.end()) return Cache->second; bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), E = RD->friend_end(); I != E && Complete; ++I) { // Check if friend classes and methods are complete. if (TypeSourceInfo *TSI = (*I)->getFriendType()) { // Friend classes are available as the TypeSourceInfo of the FriendDecl. if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); else Complete = false; } else { // Friend functions are available through the NamedDecl of FriendDecl. if (const FunctionDecl *FD = dyn_cast((*I)->getFriendDecl())) Complete = FD->isDefined(); else // This is a template friend, give up. Complete = false; } } RecordsComplete[RD] = Complete; return Complete; } /// ActOnEndOfTranslationUnit - This is called at the very end of the /// translation unit when EOF is reached and all but the top-level scope is /// popped. void Sema::ActOnEndOfTranslationUnit() { assert(DelayedDiagnostics.getCurrentPool() == NULL && "reached end of translation unit with a pool attached?"); // If code completion is enabled, don't perform any end-of-translation-unit // work. if (PP.isCodeCompletionEnabled()) return; // Complete translation units and modules define vtables and perform implicit // instantiations. PCH files do not. if (TUKind != TU_Prefix) { DiagnoseUseOfUnimplementedSelectors(); // If any dynamic classes have their key function defined within // this translation unit, then those vtables are considered "used" and must // be emitted. for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource), E = DynamicClasses.end(); I != E; ++I) { assert(!(*I)->isDependentType() && "Should not see dependent types here!"); if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { const FunctionDecl *Definition = 0; if (KeyFunction->hasBody(Definition)) MarkVTableUsed(Definition->getLocation(), *I, true); } } // If DefinedUsedVTables ends up marking any virtual member functions it // might lead to more pending template instantiations, which we then need // to instantiate. DefineUsedVTables(); // C++: Perform implicit template instantiations. // // FIXME: When we perform these implicit instantiations, we do not // carefully keep track of the point of instantiation (C++ [temp.point]). // This means that name lookup that occurs within the template // instantiation will always happen at the end of the translation unit, // so it will find some names that are not required to be found. This is // valid, but we could do better by diagnosing if an instantiation uses a // name that was not visible at its first point of instantiation. PerformPendingInstantiations(); CheckDelayedMemberExceptionSpecs(); } // All delayed member exception specs should be checked or we end up accepting // incompatible declarations. assert(DelayedDefaultedMemberExceptionSpecs.empty()); assert(DelayedDestructorExceptionSpecChecks.empty()); // Remove file scoped decls that turned out to be used. UnusedFileScopedDecls.erase( std::remove_if(UnusedFileScopedDecls.begin(0, true), UnusedFileScopedDecls.end(), std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)), UnusedFileScopedDecls.end()); if (TUKind == TU_Prefix) { // Translation unit prefixes don't need any of the checking below. TUScope = 0; return; } // Check for #pragma weak identifiers that were never declared // FIXME: This will cause diagnostics to be emitted in a non-determinstic // order! Iterating over a densemap like this is bad. LoadExternalWeakUndeclaredIdentifiers(); for (llvm::DenseMap::iterator I = WeakUndeclaredIdentifiers.begin(), E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { if (I->second.getUsed()) continue; Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) << I->first; } if (LangOpts.CPlusPlus11 && Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle, SourceLocation()) != DiagnosticsEngine::Ignored) CheckDelegatingCtorCycles(); if (TUKind == TU_Module) { // If we are building a module, resolve all of the exported declarations // now. if (Module *CurrentModule = PP.getCurrentModule()) { ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); SmallVector Stack; Stack.push_back(CurrentModule); while (!Stack.empty()) { Module *Mod = Stack.pop_back_val(); // Resolve the exported declarations and conflicts. // FIXME: Actually complain, once we figure out how to teach the // diagnostic client to deal with complaints in the module map at this // point. ModMap.resolveExports(Mod, /*Complain=*/false); ModMap.resolveUses(Mod, /*Complain=*/false); ModMap.resolveConflicts(Mod, /*Complain=*/false); // Queue the submodules, so their exports will also be resolved. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) { Stack.push_back(*Sub); } } } // Modules don't need any of the checking below. TUScope = 0; return; } // C99 6.9.2p2: // A declaration of an identifier for an object that has file // scope without an initializer, and without a storage-class // specifier or with the storage-class specifier static, // constitutes a tentative definition. If a translation unit // contains one or more tentative definitions for an identifier, // and the translation unit contains no external definition for // that identifier, then the behavior is exactly as if the // translation unit contains a file scope declaration of that // identifier, with the composite type as of the end of the // translation unit, with an initializer equal to 0. llvm::SmallSet Seen; for (TentativeDefinitionsType::iterator T = TentativeDefinitions.begin(ExternalSource), TEnd = TentativeDefinitions.end(); T != TEnd; ++T) { VarDecl *VD = (*T)->getActingDefinition(); // If the tentative definition was completed, getActingDefinition() returns // null. If we've already seen this variable before, insert()'s second // return value is false. if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) continue; if (const IncompleteArrayType *ArrayT = Context.getAsIncompleteArrayType(VD->getType())) { // Set the length of the array to 1 (C99 6.9.2p5). Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One, ArrayType::Normal, 0); VD->setType(T); } else if (RequireCompleteType(VD->getLocation(), VD->getType(), diag::err_tentative_def_incomplete_type)) VD->setInvalidDecl(); CheckCompleteVariableDeclaration(VD); // Notify the consumer that we've completed a tentative definition. if (!VD->isInvalidDecl()) Consumer.CompleteTentativeDefinition(VD); } // If there were errors, disable 'unused' warnings since they will mostly be // noise. if (!Diags.hasErrorOccurred()) { // Output warning for unused file scoped decls. for (UnusedFileScopedDeclsType::iterator I = UnusedFileScopedDecls.begin(ExternalSource), E = UnusedFileScopedDecls.end(); I != E; ++I) { if (ShouldRemoveFromUnused(this, *I)) continue; if (const FunctionDecl *FD = dyn_cast(*I)) { const FunctionDecl *DiagD; if (!FD->hasBody(DiagD)) DiagD = FD; if (DiagD->isDeleted()) continue; // Deleted functions are supposed to be unused. if (DiagD->isReferenced()) { if (isa(DiagD)) Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) << DiagD->getDeclName(); else { if (FD->getStorageClass() == SC_Static && !FD->isInlineSpecified() && !SourceMgr.isInMainFile( SourceMgr.getExpansionLoc(FD->getLocation()))) Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) << DiagD->getDeclName(); else Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*function*/0 << DiagD->getDeclName(); } } else { Diag(DiagD->getLocation(), isa(DiagD) ? diag::warn_unused_member_function : diag::warn_unused_function) << DiagD->getDeclName(); } } else { const VarDecl *DiagD = cast(*I)->getDefinition(); if (!DiagD) DiagD = cast(*I); if (DiagD->isReferenced()) { Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*variable*/1 << DiagD->getDeclName(); } else if (DiagD->getType().isConstQualified()) { Diag(DiagD->getLocation(), diag::warn_unused_const_variable) << DiagD->getDeclName(); } else { Diag(DiagD->getLocation(), diag::warn_unused_variable) << DiagD->getDeclName(); } } } if (ExternalSource) ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); checkUndefinedButUsed(*this); } if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, SourceLocation()) != DiagnosticsEngine::Ignored) { RecordCompleteMap RecordsComplete; RecordCompleteMap MNCComplete; for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), E = UnusedPrivateFields.end(); I != E; ++I) { const NamedDecl *D = *I; const CXXRecordDecl *RD = dyn_cast(D->getDeclContext()); if (RD && !RD->isUnion() && IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { Diag(D->getLocation(), diag::warn_unused_private_field) << D->getDeclName(); } } } // Check we've noticed that we're no longer parsing the initializer for every // variable. If we miss cases, then at best we have a performance issue and // at worst a rejects-valid bug. assert(ParsingInitForAutoVars.empty() && "Didn't unmark var as having its initializer parsed"); TUScope = 0; } //===----------------------------------------------------------------------===// // Helper functions. //===----------------------------------------------------------------------===// DeclContext *Sema::getFunctionLevelDeclContext() { DeclContext *DC = CurContext; while (true) { if (isa(DC) || isa(DC) || isa(DC)) { DC = DC->getParent(); } else if (isa(DC) && cast(DC)->getOverloadedOperator() == OO_Call && cast(DC->getParent())->isLambda()) { DC = DC->getParent()->getParent(); } else break; } return DC; } /// getCurFunctionDecl - If inside of a function body, this returns a pointer /// to the function decl for the function being parsed. If we're currently /// in a 'block', this returns the containing context. FunctionDecl *Sema::getCurFunctionDecl() { DeclContext *DC = getFunctionLevelDeclContext(); return dyn_cast(DC); } ObjCMethodDecl *Sema::getCurMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); while (isa(DC)) DC = DC->getParent(); return dyn_cast(DC); } NamedDecl *Sema::getCurFunctionOrMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); if (isa(DC) || isa(DC)) return cast(DC); return 0; } void Sema::EmitCurrentDiagnostic(unsigned DiagID) { // FIXME: It doesn't make sense to me that DiagID is an incoming argument here // and yet we also use the current diag ID on the DiagnosticsEngine. This has // been made more painfully obvious by the refactor that introduced this // function, but it is possible that the incoming argument can be // eliminnated. If it truly cannot be (for example, there is some reentrancy // issue I am not seeing yet), then there should at least be a clarifying // comment somewhere. if (Optional Info = isSFINAEContext()) { switch (DiagnosticIDs::getDiagnosticSFINAEResponse( Diags.getCurrentDiagID())) { case DiagnosticIDs::SFINAE_Report: // We'll report the diagnostic below. break; case DiagnosticIDs::SFINAE_SubstitutionFailure: // Count this failure so that we know that template argument deduction // has failed. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; case DiagnosticIDs::SFINAE_AccessControl: { // Per C++ Core Issue 1170, access control is part of SFINAE. // Additionally, the AccessCheckingSFINAE flag can be used to temporarily // make access control a part of SFINAE for the purposes of checking // type traits. if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) break; SourceLocation Loc = Diags.getCurrentDiagLoc(); // Suppress this diagnostic. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); // Now the diagnostic state is clear, produce a C++98 compatibility // warning. Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); // The last diagnostic which Sema produced was ignored. Suppress any // notes attached to it. Diags.setLastDiagnosticIgnored(); return; } case DiagnosticIDs::SFINAE_Suppress: // Make a copy of this suppressed diagnostic and store it with the // template-deduction information; if (*Info) { Diagnostic DiagInfo(&Diags); (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } // Suppress this diagnostic. Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; } } // Set up the context's printing policy based on our current state. Context.setPrintingPolicy(getPrintingPolicy()); // Emit the diagnostic. if (!Diags.EmitCurrentDiagnostic()) return; // If this is not a note, and we're in a template instantiation // that is different from the last template instantiation where // we emitted an error, print a template instantiation // backtrace. if (!DiagnosticIDs::isBuiltinNote(DiagID) && !ActiveTemplateInstantiations.empty() && ActiveTemplateInstantiations.back() != LastTemplateInstantiationErrorContext) { PrintInstantiationStack(); LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); } } Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); PD.Emit(Builder); return Builder; } /// \brief Looks through the macro-expansion chain for the given /// location, looking for a macro expansion with the given name. /// If one is found, returns true and sets the location to that /// expansion loc. bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { SourceLocation loc = locref; if (!loc.isMacroID()) return false; // There's no good way right now to look at the intermediate // expansions, so just jump to the expansion location. loc = getSourceManager().getExpansionLoc(loc); // If that's written with the name, stop here. SmallVector buffer; if (getPreprocessor().getSpelling(loc, buffer) == name) { locref = loc; return true; } return false; } /// \brief Determines the active Scope associated with the given declaration /// context. /// /// This routine maps a declaration context to the active Scope object that /// represents that declaration context in the parser. It is typically used /// from "scope-less" code (e.g., template instantiation, lazy creation of /// declarations) that injects a name for name-lookup purposes and, therefore, /// must update the Scope. /// /// \returns The scope corresponding to the given declaraion context, or NULL /// if no such scope is open. Scope *Sema::getScopeForContext(DeclContext *Ctx) { if (!Ctx) return 0; Ctx = Ctx->getPrimaryContext(); for (Scope *S = getCurScope(); S; S = S->getParent()) { // Ignore scopes that cannot have declarations. This is important for // out-of-line definitions of static class members. if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) if (DeclContext *Entity = S->getEntity()) if (Ctx == Entity->getPrimaryContext()) return S; } return 0; } /// \brief Enter a new function scope void Sema::PushFunctionScope() { if (FunctionScopes.size() == 1) { // Use the "top" function scope rather than having to allocate // memory for a new scope. FunctionScopes.back()->Clear(); FunctionScopes.push_back(FunctionScopes.back()); return; } FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); } void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), BlockScope, Block)); } LambdaScopeInfo *Sema::PushLambdaScope() { LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); FunctionScopes.push_back(LSI); return LSI; } void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { if (LambdaScopeInfo *const LSI = getCurLambda()) { LSI->AutoTemplateParameterDepth = Depth; return; } llvm_unreachable( "Remove assertion if intentionally called in a non-lambda context."); } void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, const Decl *D, const BlockExpr *blkExpr) { FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); assert(!FunctionScopes.empty() && "mismatched push/pop!"); // Issue any analysis-based warnings. if (WP && D) AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); else { for (SmallVectorImpl::iterator i = Scope->PossiblyUnreachableDiags.begin(), e = Scope->PossiblyUnreachableDiags.end(); i != e; ++i) { const sema::PossiblyUnreachableDiag &D = *i; Diag(D.Loc, D.PD); } } if (FunctionScopes.back() != Scope) { delete Scope; } } void Sema::PushCompoundScope() { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); } void Sema::PopCompoundScope() { FunctionScopeInfo *CurFunction = getCurFunction(); assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); CurFunction->CompoundScopes.pop_back(); } /// \brief Determine whether any errors occurred within this function/method/ /// block. bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); } BlockScopeInfo *Sema::getCurBlock() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } LambdaScopeInfo *Sema::getCurLambda() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } // We have a generic lambda if we parsed auto parameters, or we have // an associated template parameter list. LambdaScopeInfo *Sema::getCurGenericLambda() { if (LambdaScopeInfo *LSI = getCurLambda()) { return (LSI->AutoTemplateParams.size() || LSI->GLTemplateParameterList) ? LSI : 0; } return 0; } void Sema::ActOnComment(SourceRange Comment) { if (!LangOpts.RetainCommentsFromSystemHeaders && SourceMgr.isInSystemHeader(Comment.getBegin())) return; RawComment RC(SourceMgr, Comment, false, LangOpts.CommentOpts.ParseAllComments); if (RC.isAlmostTrailingComment()) { SourceRange MagicMarkerRange(Comment.getBegin(), Comment.getBegin().getLocWithOffset(3)); StringRef MagicMarkerText; switch (RC.getKind()) { case RawComment::RCK_OrdinaryBCPL: MagicMarkerText = "///<"; break; case RawComment::RCK_OrdinaryC: MagicMarkerText = "/**<"; break; default: llvm_unreachable("if this is an almost Doxygen comment, " "it should be ordinary"); } Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); } Context.addComment(RC); } // Pin this vtable to this file. ExternalSemaSource::~ExternalSemaSource() {} void ExternalSemaSource::ReadMethodPool(Selector Sel) { } void ExternalSemaSource::ReadKnownNamespaces( SmallVectorImpl &Namespaces) { } void ExternalSemaSource::ReadUndefinedButUsed( llvm::DenseMap &Undefined) { } void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { SourceLocation Loc = this->Loc; if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); if (Loc.isValid()) { Loc.print(OS, S.getSourceManager()); OS << ": "; } OS << Message; if (TheDecl && isa(TheDecl)) { std::string Name = cast(TheDecl)->getNameAsString(); if (!Name.empty()) OS << " '" << Name << '\''; } OS << '\n'; } /// \brief Figure out if an expression could be turned into a call. /// /// Use this when trying to recover from an error where the programmer may have /// written just the name of a function instead of actually calling it. /// /// \param E - The expression to examine. /// \param ZeroArgCallReturnTy - If the expression can be turned into a call /// with no arguments, this parameter is set to the type returned by such a /// call; otherwise, it is set to an empty QualType. /// \param OverloadSet - If the expression is an overloaded function /// name, this parameter is populated with the decls of the various overloads. bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &OverloadSet) { ZeroArgCallReturnTy = QualType(); OverloadSet.clear(); const OverloadExpr *Overloads = NULL; bool IsMemExpr = false; if (E.getType() == Context.OverloadTy) { OverloadExpr::FindResult FR = OverloadExpr::find(const_cast(&E)); // Ignore overloads that are pointer-to-member constants. if (FR.HasFormOfMemberPointer) return false; Overloads = FR.Expression; } else if (E.getType() == Context.BoundMemberTy) { Overloads = dyn_cast(E.IgnoreParens()); IsMemExpr = true; } bool Ambiguous = false; if (Overloads) { for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { OverloadSet.addDecl(*it); // Check whether the function is a non-template, non-member which takes no // arguments. if (IsMemExpr) continue; if (const FunctionDecl *OverloadDecl = dyn_cast((*it)->getUnderlyingDecl())) { if (OverloadDecl->getMinRequiredArguments() == 0) { if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) { ZeroArgCallReturnTy = QualType(); Ambiguous = true; } else ZeroArgCallReturnTy = OverloadDecl->getResultType(); } } } // If it's not a member, use better machinery to try to resolve the call if (!IsMemExpr) return !ZeroArgCallReturnTy.isNull(); } // Attempt to call the member with no arguments - this will correctly handle // member templates with defaults/deduction of template arguments, overloads // with default arguments, etc. if (IsMemExpr && !E.isTypeDependent()) { bool Suppress = getDiagnostics().getSuppressAllDiagnostics(); getDiagnostics().setSuppressAllDiagnostics(true); ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None, SourceLocation()); getDiagnostics().setSuppressAllDiagnostics(Suppress); if (R.isUsable()) { ZeroArgCallReturnTy = R.get()->getType(); return true; } return false; } if (const DeclRefExpr *DeclRef = dyn_cast(E.IgnoreParens())) { if (const FunctionDecl *Fun = dyn_cast(DeclRef->getDecl())) { if (Fun->getMinRequiredArguments() == 0) ZeroArgCallReturnTy = Fun->getResultType(); return true; } } // We don't have an expression that's convenient to get a FunctionDecl from, // but we can at least check if the type is "function of 0 arguments". QualType ExprTy = E.getType(); const FunctionType *FunTy = NULL; QualType PointeeTy = ExprTy->getPointeeType(); if (!PointeeTy.isNull()) FunTy = PointeeTy->getAs(); if (!FunTy) FunTy = ExprTy->getAs(); if (const FunctionProtoType *FPT = dyn_cast_or_null(FunTy)) { if (FPT->getNumArgs() == 0) ZeroArgCallReturnTy = FunTy->getResultType(); return true; } return false; } /// \brief Give notes for a set of overloads. /// /// A companion to tryExprAsCall. In cases when the name that the programmer /// wrote was an overloaded function, we may be able to make some guesses about /// plausible overloads based on their return types; such guesses can be handed /// off to this method to be emitted as notes. /// /// \param Overloads - The overloads to note. /// \param FinalNoteLoc - If we've suppressed printing some overloads due to /// -fshow-overloads=best, this is the location to attach to the note about too /// many candidates. Typically this will be the location of the original /// ill-formed expression. static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc) { int ShownOverloads = 0; int SuppressedOverloads = 0; for (UnresolvedSetImpl::iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { // FIXME: Magic number for max shown overloads stolen from // OverloadCandidateSet::NoteCandidates. if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { ++SuppressedOverloads; continue; } NamedDecl *Fn = (*It)->getUnderlyingDecl(); S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); ++ShownOverloads; } if (SuppressedOverloads) S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) << SuppressedOverloads; } static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool (*IsPlausibleResult)(QualType)) { if (!IsPlausibleResult) return noteOverloads(S, Overloads, Loc); UnresolvedSet<2> PlausibleOverloads; for (OverloadExpr::decls_iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { const FunctionDecl *OverloadDecl = cast(*It); QualType OverloadResultTy = OverloadDecl->getResultType(); if (IsPlausibleResult(OverloadResultTy)) PlausibleOverloads.addDecl(It.getDecl()); } noteOverloads(S, PlausibleOverloads, Loc); } /// Determine whether the given expression can be called by just /// putting parentheses after it. Notably, expressions with unary /// operators can't be because the unary operator will start parsing /// outside the call. static bool IsCallableWithAppend(Expr *E) { E = E->IgnoreImplicit(); return (!isa(E) && !isa(E) && !isa(E) && !isa(E)); } bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain, bool (*IsPlausibleResult)(QualType)) { SourceLocation Loc = E.get()->getExprLoc(); SourceRange Range = E.get()->getSourceRange(); QualType ZeroArgCallTy; UnresolvedSet<4> Overloads; if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && !ZeroArgCallTy.isNull() && (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { // At this point, we know E is potentially callable with 0 // arguments and that it returns something of a reasonable type, // so we can emit a fixit and carry on pretending that E was // actually a CallExpr. SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd()); Diag(Loc, PD) << /*zero-arg*/ 1 << Range << (IsCallableWithAppend(E.get()) ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") : FixItHint()); notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); // FIXME: Try this before emitting the fixit, and suppress diagnostics // while doing so. E = ActOnCallExpr(0, E.take(), Range.getEnd(), None, Range.getEnd().getLocWithOffset(1)); return true; } if (!ForceComplain) return false; Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); E = ExprError(); return true; } IdentifierInfo *Sema::getSuperIdentifier() const { if (!Ident_super) Ident_super = &Context.Idents.get("super"); return Ident_super; } IdentifierInfo *Sema::getFloat128Identifier() const { if (!Ident___float128) Ident___float128 = &Context.Idents.get("__float128"); return Ident___float128; } void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K) { CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD, CD->getContextParam(), K); CSI->ReturnType = Context.VoidTy; FunctionScopes.push_back(CSI); } CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a122 6 void Sema::addImplicitTypedef(StringRef Name, QualType T) { DeclarationName DN = &Context.Idents.get(Name); if (IdResolver.begin(DN) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope); } a174 12 // Initialize predefined OpenCL types. if (PP.getLangOpts().OpenCL) { addImplicitTypedef("image1d_t", Context.OCLImage1dTy); addImplicitTypedef("image1d_array_t", Context.OCLImage1dArrayTy); addImplicitTypedef("image1d_buffer_t", Context.OCLImage1dBufferTy); addImplicitTypedef("image2d_t", Context.OCLImage2dTy); addImplicitTypedef("image2d_array_t", Context.OCLImage2dArrayTy); addImplicitTypedef("image3d_t", Context.OCLImage3dTy); addImplicitTypedef("sampler_t", Context.OCLSamplerTy); addImplicitTypedef("event_t", Context.OCLEventTy); } @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d16 1 d73 1 a73 1 : ExternalSource(0), a180 9 // Initialize Microsoft "predefined C++ types". if (PP.getLangOpts().MSVCCompat && PP.getLangOpts().CPlusPlus) { if (IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class), TUScope); addImplicitTypedef("size_t", Context.getSizeType()); } d205 1 @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d78 1 a78 2 PackContext(0), MSStructPragmaOn(false), MSPointerToMemberRepresentationMethod(PPTMK_BestCase), VisContext(0), d213 1 d258 1 a258 1 fn->addAttr(UnavailableAttr::CreateImplicit(Context, msg, loc)); d1243 1 a1243 1 ZeroArgCallReturnTy = OverloadDecl->getReturnType(); d1272 1 a1272 1 ZeroArgCallReturnTy = Fun->getReturnType(); d1289 2 a1290 2 if (FPT->getNumParams() == 0) ZeroArgCallReturnTy = FunTy->getReturnType(); d1341 1 a1341 1 QualType OverloadResultTy = OverloadDecl->getReturnType(); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @d79 1 a79 4 MSPointerToMemberRepresentationMethod( LangOpts.getMSPointerToMemberRepresentationMethod()), VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), VisContext(0), d89 1 a89 1 NumSFINAEErrors(0), d208 4 a211 1 llvm::DeleteContainerSeconds(LateParsedTemplateMap); @ 1.1.1.5.2.1 log @Rebase. @ text @a23 1 #include "clang/Basic/DiagnosticOptions.h" a45 6 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) { return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts); } ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); } d72 1 a72 1 : ExternalSource(nullptr), d77 2 a78 2 CurContext(nullptr), OriginalLexicalContext(nullptr), PackContext(nullptr), MSStructPragmaOn(false), d82 1 a82 2 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), VisContext(nullptr), d84 6 a89 7 ExprNeedsCleanups(false), LateTemplateParser(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr), d95 1 a95 1 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), d97 2 a98 2 VarDataSharingAttributesStack(nullptr), CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) d100 1 a100 1 TUScope = nullptr; d104 1 a104 1 NSNumberLiteralMethods[I] = nullptr; d118 1 a118 1 false, nullptr, false)); d146 1 a146 1 if (Context.getTargetInfo().hasInt128Type()) { d322 1 a322 1 return E; d340 1 a340 1 return E; d344 1 a344 1 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK); d412 19 a462 1 SourceManager &SM = Context.getSourceManager(); d464 1 a464 11 [&SM](const std::pair &l, const std::pair &r) { if (l.second.isValid() && !r.second.isValid()) return true; if (!l.second.isValid() && r.second.isValid()) return false; if (l.second != r.second) return SM.isBeforeInTranslationUnit(l.second, r.second); return SM.isBeforeInTranslationUnit(l.first->getLocation(), r.first->getLocation()); }); a480 7 if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } d589 1 a589 1 assert(DelayedDiagnostics.getCurrentPool() == nullptr d610 2 a611 3 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { const FunctionDecl *Definition = nullptr; a630 7 if (ExternalSource) { // Load pending instantiations from the external source. SmallVector Pending; ExternalSource->ReadPendingInstantiations(Pending); PendingInstantiations.insert(PendingInstantiations.begin(), Pending.begin(), Pending.end()); } a631 1 d642 1 a642 1 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true), d649 1 a649 1 TUScope = nullptr; d701 1 a701 1 TUScope = nullptr; d727 1 a727 1 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD)) d832 1 a832 1 TUScope = nullptr; d876 1 a876 1 return nullptr; d1024 1 a1024 1 return nullptr; d1036 1 a1036 1 return nullptr; d1080 9 a1088 3 else for (const auto &PUD : Scope->PossiblyUnreachableDiags) Diag(PUD.Loc, PUD.PD); d1090 1 a1090 1 if (FunctionScopes.back() != Scope) d1092 1 d1114 1 a1114 9 return nullptr; auto CurBSI = dyn_cast(FunctionScopes.back()); if (CurBSI && CurBSI->TheDecl && !CurBSI->TheDecl->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } d1116 1 a1116 1 return CurBSI; d1121 1 a1121 9 return nullptr; auto CurLSI = dyn_cast(FunctionScopes.back()); if (CurLSI && CurLSI->Lambda && !CurLSI->Lambda->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } d1123 1 a1123 1 return CurLSI; d1130 1 a1130 1 LSI->GLTemplateParameterList) ? LSI : nullptr; d1132 1 a1132 1 return nullptr; d1210 1 a1210 1 const OverloadExpr *Overloads = nullptr; d1259 2 a1260 2 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(), None, SourceLocation()); d1280 1 a1280 1 const FunctionType *FunTy = nullptr; d1385 1 a1385 1 E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None, d1420 1 a1420 1 return nullptr; @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @a23 1 #include "clang/Basic/DiagnosticOptions.h" a45 6 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) { return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts); } ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); } d72 1 a72 1 : ExternalSource(nullptr), d77 2 a78 2 CurContext(nullptr), OriginalLexicalContext(nullptr), PackContext(nullptr), MSStructPragmaOn(false), d82 1 a82 2 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), VisContext(nullptr), d84 6 a89 7 ExprNeedsCleanups(false), LateTemplateParser(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr), d95 1 a95 1 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), d97 2 a98 2 VarDataSharingAttributesStack(nullptr), CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) d100 1 a100 1 TUScope = nullptr; d104 1 a104 1 NSNumberLiteralMethods[I] = nullptr; d118 1 a118 1 false, nullptr, false)); d146 1 a146 1 if (Context.getTargetInfo().hasInt128Type()) { d322 1 a322 1 return E; d340 1 a340 1 return E; d344 1 a344 1 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK); d412 19 a462 1 SourceManager &SM = Context.getSourceManager(); d464 1 a464 11 [&SM](const std::pair &l, const std::pair &r) { if (l.second.isValid() && !r.second.isValid()) return true; if (!l.second.isValid() && r.second.isValid()) return false; if (l.second != r.second) return SM.isBeforeInTranslationUnit(l.second, r.second); return SM.isBeforeInTranslationUnit(l.first->getLocation(), r.first->getLocation()); }); a480 7 if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } d589 1 a589 1 assert(DelayedDiagnostics.getCurrentPool() == nullptr d610 2 a611 3 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { const FunctionDecl *Definition = nullptr; a630 7 if (ExternalSource) { // Load pending instantiations from the external source. SmallVector Pending; ExternalSource->ReadPendingInstantiations(Pending); PendingInstantiations.insert(PendingInstantiations.begin(), Pending.begin(), Pending.end()); } a631 1 d642 1 a642 1 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true), d649 1 a649 1 TUScope = nullptr; d701 1 a701 1 TUScope = nullptr; d727 1 a727 1 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD)) d832 1 a832 1 TUScope = nullptr; d876 1 a876 1 return nullptr; d1024 1 a1024 1 return nullptr; d1036 1 a1036 1 return nullptr; d1080 9 a1088 3 else for (const auto &PUD : Scope->PossiblyUnreachableDiags) Diag(PUD.Loc, PUD.PD); d1090 1 a1090 1 if (FunctionScopes.back() != Scope) d1092 1 d1114 1 a1114 9 return nullptr; auto CurBSI = dyn_cast(FunctionScopes.back()); if (CurBSI && CurBSI->TheDecl && !CurBSI->TheDecl->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } d1116 1 a1116 1 return CurBSI; d1121 1 a1121 9 return nullptr; auto CurLSI = dyn_cast(FunctionScopes.back()); if (CurLSI && CurLSI->Lambda && !CurLSI->Lambda->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } d1123 1 a1123 1 return CurLSI; d1130 1 a1130 1 LSI->GLTemplateParameterList) ? LSI : nullptr; d1132 1 a1132 1 return nullptr; d1210 1 a1210 1 const OverloadExpr *Overloads = nullptr; d1259 2 a1260 2 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(), None, SourceLocation()); d1280 1 a1280 1 const FunctionType *FunTy = nullptr; d1385 1 a1385 1 E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None, d1420 1 a1420 1 return nullptr; @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @d90 1 a90 1 CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), a97 1 InitArrayWithObjectsMethod(nullptr), a98 3 InitDictionaryWithObjectsMethod(nullptr), ArrayAllocObjectsMethod(nullptr), DictAllocObjectsMethod(nullptr), d316 1 a316 2 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast " "kind"); d684 3 a686 1 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation())) d792 2 a793 3 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) << DiagD->getDeclName(); d826 3 a828 1 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) { d1438 2 a1439 2 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo( getDiagnostics(), S, CD, RD, CD->getContextParam(), K); @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d72 2 a92 1 LateTemplateParserCleanup(nullptr), d98 1 d100 3 a102 1 MSAsmLabelNameCounter(0), a157 4 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we // will not be able to merge any duplicate __va_list_tag decls correctly. VAListTagName = PP.getIdentifierInfo("__va_list_tag"); a247 2 assert(DelayedTypos.empty() && "Uncorrected typos!"); d545 1 a545 6 // If the template function is marked as late template parsed at this point, // it has not been instantiated and therefore we have not performed semantic // analysis on it yet, so we cannot know if the type can be considered // complete. Complete = !F->getTemplatedDecl()->isLateTemplateParsed() && F->getTemplatedDecl()->isDefined(); a597 13 void Sema::emitAndClearUnusedLocalTypedefWarnings() { if (ExternalSource) ExternalSource->ReadUnusedLocalTypedefNameCandidates( UnusedLocalTypedefNameCandidates); for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) { if (TD->isReferenced()) continue; Diag(TD->getLocation(), diag::warn_unused_local_typedef) << isa(TD) << TD->getDeclName(); } UnusedLocalTypedefNameCandidates.clear(); } a653 3 if (LateTemplateParserCleanup) LateTemplateParserCleanup(OpaqueParser); d660 1 a660 1 assert(DelayedExceptionSpecChecks.empty()); a719 4 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for // modules when they are built, not every time they are used. emitAndClearUnusedLocalTypedefWarnings(); d747 1 a747 1 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second) a827 2 emitAndClearUnusedLocalTypedefWarnings(); @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d72 2 a92 1 LateTemplateParserCleanup(nullptr), d98 1 d100 3 a102 1 MSAsmLabelNameCounter(0), a157 4 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we // will not be able to merge any duplicate __va_list_tag decls correctly. VAListTagName = PP.getIdentifierInfo("__va_list_tag"); a247 2 assert(DelayedTypos.empty() && "Uncorrected typos!"); d545 1 a545 6 // If the template function is marked as late template parsed at this point, // it has not been instantiated and therefore we have not performed semantic // analysis on it yet, so we cannot know if the type can be considered // complete. Complete = !F->getTemplatedDecl()->isLateTemplateParsed() && F->getTemplatedDecl()->isDefined(); a597 13 void Sema::emitAndClearUnusedLocalTypedefWarnings() { if (ExternalSource) ExternalSource->ReadUnusedLocalTypedefNameCandidates( UnusedLocalTypedefNameCandidates); for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) { if (TD->isReferenced()) continue; Diag(TD->getLocation(), diag::warn_unused_local_typedef) << isa(TD) << TD->getDeclName(); } UnusedLocalTypedefNameCandidates.clear(); } a653 3 if (LateTemplateParserCleanup) LateTemplateParserCleanup(OpaqueParser); d660 1 a660 1 assert(DelayedExceptionSpecChecks.empty()); a719 4 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for // modules when they are built, not every time they are used. emitAndClearUnusedLocalTypedefWarnings(); d747 1 a747 1 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second) a827 2 emitAndClearUnusedLocalTypedefWarnings(); @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @d43 1 d94 1 a94 1 NSNumberDecl(nullptr), NSValueDecl(nullptr), a95 1 ValueWithBytesObjCTypeMethod(nullptr), a101 1 CachedFakeTopLevelModule(nullptr), d105 1 a105 1 TyposCorrected(0), AnalysisWarnings(*this), ThreadSafetyDeclCache(nullptr), d122 2 a123 1 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); d125 3 a127 1 ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, false, nullptr, false); d142 4 a157 3 if (!TUScope) return; d173 1 a173 1 if (getLangOpts().ObjC1) { d198 2 a199 3 if (getLangOpts().MSVCCompat) { if (getLangOpts().CPlusPlus && IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) d207 1 a207 1 if (getLangOpts().OpenCL) { a215 41 if (getLangOpts().OpenCLVersion >= 200) { addImplicitTypedef("image2d_depth_t", Context.OCLImage2dDepthTy); addImplicitTypedef("image2d_array_depth_t", Context.OCLImage2dArrayDepthTy); addImplicitTypedef("image2d_msaa_t", Context.OCLImage2dMSAATy); addImplicitTypedef("image2d_array_msaa_t", Context.OCLImage2dArrayMSAATy); addImplicitTypedef("image2d_msaa_depth_t", Context.OCLImage2dMSAADepthTy); addImplicitTypedef("image2d_array_msaa_depth_t", Context.OCLImage2dArrayMSAADepthTy); addImplicitTypedef("clk_event_t", Context.OCLClkEventTy); addImplicitTypedef("queue_t", Context.OCLQueueTy); addImplicitTypedef("ndrange_t", Context.OCLNDRangeTy); addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy); addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy)); addImplicitTypedef("atomic_uint", Context.getAtomicType(Context.UnsignedIntTy)); addImplicitTypedef("atomic_long", Context.getAtomicType(Context.LongTy)); addImplicitTypedef("atomic_ulong", Context.getAtomicType(Context.UnsignedLongTy)); addImplicitTypedef("atomic_float", Context.getAtomicType(Context.FloatTy)); addImplicitTypedef("atomic_double", Context.getAtomicType(Context.DoubleTy)); // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide. addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy)); addImplicitTypedef("atomic_intptr_t", Context.getAtomicType(Context.getIntPtrType())); addImplicitTypedef("atomic_uintptr_t", Context.getAtomicType(Context.getUIntPtrType())); addImplicitTypedef("atomic_size_t", Context.getAtomicType(Context.getSizeType())); addImplicitTypedef("atomic_ptrdiff_t", Context.getAtomicType(Context.getPointerDiffType())); } } if (Context.getTargetInfo().hasBuiltinMSVaList()) { DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list"); if (IdResolver.begin(MSVaList) == IdResolver.end()) PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope); a245 2 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache); d257 1 a257 1 UnavailableAttr::ImplicitReason reason) { d273 1 a273 1 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc)); a310 14 void Sema::diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc) { Optional ExprNullability = SrcType->getNullability(Context); if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable) return; Optional TypeNullability = DstType->getNullability(Context); if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull) return; Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType; } a333 2 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getLocStart()); d340 12 d515 8 a522 2 for (auto &WeakID : WeakIDs) WeakUndeclaredIdentifiers.insert(WeakID); d547 4 a550 4 // If the template function is marked as late template parsed at this // point, it has not been instantiated and therefore we have not // performed semantic analysis on it yet, so we cannot know if the type // can be considered complete. d635 16 a681 2 // FIXME: This is wrong for TUKind == TU_Prefix. In that case, we need to // write out the lists to the AST file (if any). a684 3 // All dllexport classes should have been processed already. assert(DelayedDllExportClasses.empty()); d699 2 d702 4 a705 3 for (auto WeakID : WeakUndeclaredIdentifiers) { if (WeakID.second.getUsed()) continue; d707 2 a708 9 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(), LookupOrdinaryName); if (PrevDecl != nullptr && !(isa(PrevDecl) || isa(PrevDecl))) Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type) << "'weak'" << ExpectedVariableOrFunction; else Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared) << WeakID.first; d735 5 a739 1 Stack.append(Mod->submodule_begin(), Mod->submodule_end()); a873 11 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) { if (ExternalSource) ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs); for (const auto &DeletedFieldInfo : DeleteExprs) { for (const auto &DeleteExprLoc : DeletedFieldInfo.second) { AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first, DeleteExprLoc.second); } } } a1232 3 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector, 4>> &) {} d1432 1 a1432 1 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd()); a1480 5 const llvm::MapVector & Sema::getMismatchingDeleteExpressions() const { return DeleteExprs; } @ 1.1.1.9.2.1 log @Sync with HEAD @ text @d15 1 d25 1 a32 1 #include "clang/Sema/Initialization.h" a38 1 #include "clang/Sema/SemaInternal.h" d40 1 a54 2 // Our printing policy is copied over the ASTContext printing policy whenever // a diagnostic is emitted, so recompute it. d57 2 a58 1 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) { d60 2 a61 2 BoolMacro->getNumTokens() == 1 && BoolMacro->getReplacementToken(0).is(tok::kw__Bool); d82 1 a82 1 MSStructPragmaOn(false), d85 3 a87 4 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0), DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), d89 3 a91 3 Cleanup{}, LateTemplateParser(nullptr), LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr), d98 1 d125 1 a125 2 ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, CleanupInfo{}, nullptr, false); a193 5 // Create the internal type for the *StringMakeConstantString builtins. DeclarationName ConstantString = &Context.Idents.get("__NSConstantString"); if (IdResolver.begin(ConstantString) == IdResolver.end()) PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope); d204 1 a204 2 // Initialize predefined OpenCL types and supported extensions and (optional) // core features. d206 6 a211 2 getOpenCLOptions().addSupport(Context.getTargetInfo().getSupportedOpenCLOpts()); getOpenCLOptions().enableSupportedCore(getLangOpts().OpenCLVersion); d215 8 d230 3 a232 4 auto AtomicLongT = Context.getAtomicType(Context.LongTy); addImplicitTypedef("atomic_long", AtomicLongT); auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy); addImplicitTypedef("atomic_ulong", AtomicULongT); d235 2 a236 2 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy); addImplicitTypedef("atomic_double", AtomicDoubleT); d240 8 a247 35 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType()); addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT); auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType()); addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT); auto AtomicSizeT = Context.getAtomicType(Context.getSizeType()); addImplicitTypedef("atomic_size_t", AtomicSizeT); auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType()); addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT); // OpenCL v2.0 s6.13.11.6: // - The atomic_long and atomic_ulong types are supported if the // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics // extensions are supported. // - The atomic_double type is only supported if double precision // is supported and the cl_khr_int64_base_atomics and // cl_khr_int64_extended_atomics extensions are supported. // - If the device address space is 64-bits, the data types // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and // cl_khr_int64_extended_atomics extensions are supported. std::vector Atomic64BitTypes; Atomic64BitTypes.push_back(AtomicLongT); Atomic64BitTypes.push_back(AtomicULongT); Atomic64BitTypes.push_back(AtomicDoubleT); if (Context.getTypeSize(AtomicSizeT) == 64) { Atomic64BitTypes.push_back(AtomicSizeT); Atomic64BitTypes.push_back(AtomicIntPtrT); Atomic64BitTypes.push_back(AtomicUIntPtrT); Atomic64BitTypes.push_back(AtomicPtrDiffT); } for (auto &I : Atomic64BitTypes) setOpenCLExtensionForType(I, "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics"); setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64"); d249 1 a249 7 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64"); #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \ setOpenCLExtensionForType(Context.Id, Ext); #include "clang/Basic/OpenCLImageTypes.def" }; d263 2 a396 12 // C++1z [conv.array]: The temporary materialization conversion is applied. // We also use this to fuel C++ DR1213, which applies to C++11 onwards. if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus && E->getValueKind() == VK_RValue) { // The temporary is an lvalue in C++98 and an xvalue otherwise. ExprResult Materialized = CreateMaterializeTemporaryExpr( E->getType(), E, !getLangOpts().CPlusPlus11); if (Materialized.isInvalid()) return ExprError(); E = Materialized.get(); } d473 1 a473 2 /// Obtains a sorted list of functions and variables that are undefined but /// ODR-used. d476 4 a479 2 for (const auto &UndefinedUse : UndefinedButUsed) { NamedDecl *ND = UndefinedUse.first; d494 1 a494 2 auto *VD = cast(ND); if (VD->hasDefinition() != VarDecl::DeclarationOnly) d496 1 a496 1 if (VD->isExternallyVisible() && !VD->getMostRecentDecl()->isInline()) d500 1 a500 1 Undefined.push_back(std::make_pair(ND, UndefinedUse.second)); d502 16 d544 2 a545 3 } else if (auto *FD = dyn_cast(ND)) { (void)FD; assert(FD->getMostRecentDecl()->isInlined() && a546 1 // FIXME: This is ill-formed; we should reject. a547 4 } else { assert(cast(ND)->getMostRecentDecl()->isInline() && "used var requires definition but isn't inline or internal?"); S.Diag(ND->getLocation(), diag::err_undefined_inline_var) << ND; a551 2 S.UndefinedButUsed.clear(); d722 1 a722 2 if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; a746 6 if (!Diags.hasErrorOccurred()) { if (ExternalSource) ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); checkUndefinedButUsed(*this); } a816 1 // No initialization is performed for a tentative definition. d871 2 a872 5 const SourceManager &SM = SourceMgr; if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) || !PP.getLangOpts().IsHeaderFile) Diag(DiagD->getLocation(), diag::warn_unused_const_variable) << DiagD->getDeclName(); d880 4 d919 1 a919 2 if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; d1207 1 a1207 1 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreCapturedRegions) { d1211 1 a1211 9 auto I = FunctionScopes.rbegin(); if (IgnoreCapturedRegions) { auto E = FunctionScopes.rend(); while (I != E && isa(*I)) ++I; if (I == E) return nullptr; } auto *CurLSI = dyn_cast(*I); a1262 1 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { } d1269 2 a1270 1 llvm::MapVector &Undefined) {} d1284 4 a1287 4 if (auto *ND = dyn_cast_or_null(TheDecl)) { OS << " '"; ND->getNameForDiagnostic(OS, ND->getASTContext().getPrintingPolicy(), true); OS << "'"; d1512 1 a1512 2 getDiagnostics(), S, CD, RD, CD->getContextParam(), K, (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0); a1527 82 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) { if (ExtStr.empty()) return; llvm::SmallVector Exts; ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); auto CanT = T.getCanonicalType().getTypePtr(); for (auto &I : Exts) OpenCLTypeExtMap[CanT].insert(I.str()); } void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) { llvm::SmallVector Exts; ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); if (Exts.empty()) return; for (auto &I : Exts) OpenCLDeclExtMap[FD].insert(I.str()); } void Sema::setCurrentOpenCLExtensionForType(QualType T) { if (CurrOpenCLExtension.empty()) return; setOpenCLExtensionForType(T, CurrOpenCLExtension); } void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) { if (CurrOpenCLExtension.empty()) return; setOpenCLExtensionForDecl(D, CurrOpenCLExtension); } bool Sema::isOpenCLDisabledDecl(Decl *FD) { auto Loc = OpenCLDeclExtMap.find(FD); if (Loc == OpenCLDeclExtMap.end()) return false; for (auto &I : Loc->second) { if (!getOpenCLOptions().isEnabled(I)) return true; } return false; } template bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo, MapT &Map, unsigned Selector, SourceRange SrcRange) { auto Loc = Map.find(D); if (Loc == Map.end()) return false; bool Disabled = false; for (auto &I : Loc->second) { if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) { Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo << I << SrcRange; Disabled = true; } } return Disabled; } bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) { // Check extensions for declared types. Decl *Decl = nullptr; if (auto TypedefT = dyn_cast(QT.getTypePtr())) Decl = TypedefT->getDecl(); if (auto TagT = dyn_cast(QT.getCanonicalType().getTypePtr())) Decl = TagT->getDecl(); auto Loc = DS.getTypeSpecTypeLoc(); if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap)) return true; // Check extensions for builtin types. return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc, QT, OpenCLTypeExtMap); } bool Sema::checkOpenCLDisabledDecl(const Decl &D, const Expr &E) { return checkOpenCLDisabledTypeOrDecl(&D, E.getLocStart(), "", OpenCLDeclExtMap, 1, D.getSourceRange()); } @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @d15 1 d25 1 a32 1 #include "clang/Sema/Initialization.h" a38 1 #include "clang/Sema/SemaInternal.h" d40 1 a54 2 // Our printing policy is copied over the ASTContext printing policy whenever // a diagnostic is emitted, so recompute it. d57 2 a58 1 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) { d60 2 a61 2 BoolMacro->getNumTokens() == 1 && BoolMacro->getReplacementToken(0).is(tok::kw__Bool); d82 1 a82 1 MSStructPragmaOn(false), d85 3 a87 4 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0), DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), d89 3 a91 3 Cleanup{}, LateTemplateParser(nullptr), LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr), d98 1 d125 1 a125 2 ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, CleanupInfo{}, nullptr, false); a193 5 // Create the internal type for the *StringMakeConstantString builtins. DeclarationName ConstantString = &Context.Idents.get("__NSConstantString"); if (IdResolver.begin(ConstantString) == IdResolver.end()) PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope); d204 1 a204 2 // Initialize predefined OpenCL types and supported extensions and (optional) // core features. d206 6 a211 2 getOpenCLOptions().addSupport(Context.getTargetInfo().getSupportedOpenCLOpts()); getOpenCLOptions().enableSupportedCore(getLangOpts().OpenCLVersion); d215 8 d230 3 a232 4 auto AtomicLongT = Context.getAtomicType(Context.LongTy); addImplicitTypedef("atomic_long", AtomicLongT); auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy); addImplicitTypedef("atomic_ulong", AtomicULongT); d235 2 a236 2 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy); addImplicitTypedef("atomic_double", AtomicDoubleT); d240 8 a247 35 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType()); addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT); auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType()); addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT); auto AtomicSizeT = Context.getAtomicType(Context.getSizeType()); addImplicitTypedef("atomic_size_t", AtomicSizeT); auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType()); addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT); // OpenCL v2.0 s6.13.11.6: // - The atomic_long and atomic_ulong types are supported if the // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics // extensions are supported. // - The atomic_double type is only supported if double precision // is supported and the cl_khr_int64_base_atomics and // cl_khr_int64_extended_atomics extensions are supported. // - If the device address space is 64-bits, the data types // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and // cl_khr_int64_extended_atomics extensions are supported. std::vector Atomic64BitTypes; Atomic64BitTypes.push_back(AtomicLongT); Atomic64BitTypes.push_back(AtomicULongT); Atomic64BitTypes.push_back(AtomicDoubleT); if (Context.getTypeSize(AtomicSizeT) == 64) { Atomic64BitTypes.push_back(AtomicSizeT); Atomic64BitTypes.push_back(AtomicIntPtrT); Atomic64BitTypes.push_back(AtomicUIntPtrT); Atomic64BitTypes.push_back(AtomicPtrDiffT); } for (auto &I : Atomic64BitTypes) setOpenCLExtensionForType(I, "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics"); setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64"); d249 1 a249 7 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64"); #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \ setOpenCLExtensionForType(Context.Id, Ext); #include "clang/Basic/OpenCLImageTypes.def" }; d263 2 a396 12 // C++1z [conv.array]: The temporary materialization conversion is applied. // We also use this to fuel C++ DR1213, which applies to C++11 onwards. if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus && E->getValueKind() == VK_RValue) { // The temporary is an lvalue in C++98 and an xvalue otherwise. ExprResult Materialized = CreateMaterializeTemporaryExpr( E->getType(), E, !getLangOpts().CPlusPlus11); if (Materialized.isInvalid()) return ExprError(); E = Materialized.get(); } d473 1 a473 2 /// Obtains a sorted list of functions and variables that are undefined but /// ODR-used. d476 4 a479 2 for (const auto &UndefinedUse : UndefinedButUsed) { NamedDecl *ND = UndefinedUse.first; d494 1 a494 2 auto *VD = cast(ND); if (VD->hasDefinition() != VarDecl::DeclarationOnly) d496 1 a496 1 if (VD->isExternallyVisible() && !VD->getMostRecentDecl()->isInline()) d500 1 a500 1 Undefined.push_back(std::make_pair(ND, UndefinedUse.second)); d502 16 d544 2 a545 3 } else if (auto *FD = dyn_cast(ND)) { (void)FD; assert(FD->getMostRecentDecl()->isInlined() && a546 1 // FIXME: This is ill-formed; we should reject. a547 4 } else { assert(cast(ND)->getMostRecentDecl()->isInline() && "used var requires definition but isn't inline or internal?"); S.Diag(ND->getLocation(), diag::err_undefined_inline_var) << ND; a551 2 S.UndefinedButUsed.clear(); d722 1 a722 2 if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; a746 6 if (!Diags.hasErrorOccurred()) { if (ExternalSource) ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); checkUndefinedButUsed(*this); } a816 1 // No initialization is performed for a tentative definition. d871 2 a872 5 const SourceManager &SM = SourceMgr; if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) || !PP.getLangOpts().IsHeaderFile) Diag(DiagD->getLocation(), diag::warn_unused_const_variable) << DiagD->getDeclName(); d880 4 d919 1 a919 2 if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; d1207 1 a1207 1 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreCapturedRegions) { d1211 1 a1211 9 auto I = FunctionScopes.rbegin(); if (IgnoreCapturedRegions) { auto E = FunctionScopes.rend(); while (I != E && isa(*I)) ++I; if (I == E) return nullptr; } auto *CurLSI = dyn_cast(*I); a1262 1 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { } d1269 2 a1270 1 llvm::MapVector &Undefined) {} d1284 4 a1287 4 if (auto *ND = dyn_cast_or_null(TheDecl)) { OS << " '"; ND->getNameForDiagnostic(OS, ND->getASTContext().getPrintingPolicy(), true); OS << "'"; d1512 1 a1512 2 getDiagnostics(), S, CD, RD, CD->getContextParam(), K, (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0); a1527 82 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) { if (ExtStr.empty()) return; llvm::SmallVector Exts; ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); auto CanT = T.getCanonicalType().getTypePtr(); for (auto &I : Exts) OpenCLTypeExtMap[CanT].insert(I.str()); } void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) { llvm::SmallVector Exts; ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); if (Exts.empty()) return; for (auto &I : Exts) OpenCLDeclExtMap[FD].insert(I.str()); } void Sema::setCurrentOpenCLExtensionForType(QualType T) { if (CurrOpenCLExtension.empty()) return; setOpenCLExtensionForType(T, CurrOpenCLExtension); } void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) { if (CurrOpenCLExtension.empty()) return; setOpenCLExtensionForDecl(D, CurrOpenCLExtension); } bool Sema::isOpenCLDisabledDecl(Decl *FD) { auto Loc = OpenCLDeclExtMap.find(FD); if (Loc == OpenCLDeclExtMap.end()) return false; for (auto &I : Loc->second) { if (!getOpenCLOptions().isEnabled(I)) return true; } return false; } template bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo, MapT &Map, unsigned Selector, SourceRange SrcRange) { auto Loc = Map.find(D); if (Loc == Map.end()) return false; bool Disabled = false; for (auto &I : Loc->second) { if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) { Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo << I << SrcRange; Disabled = true; } } return Disabled; } bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) { // Check extensions for declared types. Decl *Decl = nullptr; if (auto TypedefT = dyn_cast(QT.getTypePtr())) Decl = TypedefT->getDecl(); if (auto TagT = dyn_cast(QT.getCanonicalType().getTypePtr())) Decl = TagT->getDecl(); auto Loc = DS.getTypeSpecTypeLoc(); if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap)) return true; // Check extensions for builtin types. return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc, QT, OpenCLTypeExtMap); } bool Sema::checkOpenCLDisabledDecl(const Decl &D, const Expr &E) { return checkOpenCLDisabledTypeOrDecl(&D, E.getLocStart(), "", OpenCLDeclExtMap, 1, D.getSourceRange()); } @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @d74 36 a109 28 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter) : ExternalSource(nullptr), isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), CollectStats(false), CodeCompleter(CodeCompleter), CurContext(nullptr), OriginalLexicalContext(nullptr), MSStructPragmaOn(false), MSPointerToMemberRepresentationMethod( LangOpts.getMSPointerToMemberRepresentationMethod()), VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0), DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), PragmaAttributeCurrentTargetDecl(nullptr), IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr), LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false), TUKind(TUKind), NumSFINAEErrors(0), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr), CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) { d125 2 a126 3 ExprEvalContexts.emplace_back( ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{}, nullptr, false); d220 1 d331 1 a331 1 if (inTemplateInstantiation()) a392 13 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) { if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer) return; if (E->getType()->isNullPtrType()) return; // nullptr only exists from C++11 on, so don't warn on its absence earlier. if (!getLangOpts().CPlusPlus11) return; Diag(E->getLocStart(), diag::warn_zero_as_null_pointer_constant) << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr"); } a416 1 diagnoseZeroToNullptrConversion(Kind, E); a472 7 // If this is a function template and none of its specializations is used, // we should warn. if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate()) for (const auto *Spec : Template->specializations()) if (ShouldRemoveFromUnused(SemaRef, Spec)) return true; a495 7 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate()) // If this is a variable template and none of its specializations is used, // we should warn. for (const auto *Spec : Template->specializations()) if (ShouldRemoveFromUnused(SemaRef, Spec)) return true; a687 12 /// This is called before the very first declaration in the translation unit /// is parsed. Note that the ASTContext may have already injected some /// declarations. void Sema::ActOnStartOfTranslationUnit() { if (getLangOpts().ModulesTS) { // We start in the global module; all those declarations are implicitly // module-private (though they do not have module linkage). Context.getTranslationUnitDecl()->setModuleOwnershipKind( Decl::ModuleOwnershipKind::ModulePrivate); } } a722 3 for (auto PII : Pending) if (auto Func = dyn_cast(PII.first)) Func->setInstantiationIsPending(true); a733 2 DiagnoseUnterminatedPragmaAttribute(); d748 1 a748 3 [this](const DeclaratorDecl *DD) { return ShouldRemoveFromUnused(this, DD); }), d814 1 a814 2 if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; d897 4 a900 8 if (FD->getDescribedFunctionTemplate()) Diag(DiagD->getLocation(), diag::warn_unused_template) << /*function*/0 << DiagD->getDeclName(); else Diag(DiagD->getLocation(), isa(DiagD) ? diag::warn_unused_member_function : diag::warn_unused_function) << DiagD->getDeclName(); d916 1 a916 5 if (DiagD->getDescribedVarTemplate()) Diag(DiagD->getLocation(), diag::warn_unused_template) << /*variable*/1 << DiagD->getDeclName(); else Diag(DiagD->getLocation(), diag::warn_unused_variable) d1010 1 a1010 1 // eliminated. If it truly cannot be (for example, there is some reentrancy d1098 7 a1104 2 if (!DiagnosticIDs::isBuiltinNote(DiagID)) PrintContextStack(); a1171 2 if (LangOpts.OpenMP) pushOpenMPFunctionRegion(); a1175 2 if (LangOpts.OpenMP) pushOpenMPFunctionRegion(); a1202 3 if (LangOpts.OpenMP) popOpenMPFunctionRegion(Scope); d1239 1 a1239 1 assert(!CodeSynthesisContexts.empty()); d1246 1 a1246 1 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) { d1251 1 a1251 1 if (IgnoreNonLambdaCapturingScope) { d1253 1 a1253 1 while (I != E && isa(*I) && !isa(*I)) d1262 1 a1262 1 assert(!CodeSynthesisContexts.empty()); d1654 2 a1655 3 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) { IdentifierInfo *FnName = D.getIdentifier(); return checkOpenCLDisabledTypeOrDecl(&D, E.getLocStart(), FnName, @ 1.1.1.12 log @Import clang r319952 from branches/release_50 @ text @a544 3 if (isa(ND)) continue; @ 1.1.1.12.4.1 log @Sync with HEAD @ text @a21 1 #include "clang/AST/PrettyDeclStackTrace.h" d34 1 a39 1 #include "clang/Sema/TemplateInstCallback.h" d54 2 a55 2 // In diagnostics, we print _Bool as bool if the latter is defined as the // former. a72 43 namespace clang { namespace sema { class SemaPPCallbacks : public PPCallbacks { Sema *S = nullptr; llvm::SmallVector IncludeStack; public: void set(Sema &S) { this->S = &S; } void reset() { S = nullptr; } virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override { if (!S) return; switch (Reason) { case EnterFile: { SourceManager &SM = S->getSourceManager(); SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc)); if (IncludeLoc.isValid()) { IncludeStack.push_back(IncludeLoc); S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc); } break; } case ExitFile: if (!IncludeStack.empty()) S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::ChangedStateAtExit, IncludeStack.pop_back_val()); break; default: break; } } }; } // end namespace sema } // end namespace clang d90 3 a92 3 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), d96 4 a99 7 TUKind(TUKind), NumSFINAEErrors(0), FullyCheckedComparisonCategories( static_cast(ComparisonCategoryType::Last) + 1), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), d119 1 a119 1 nullptr, ExpressionEvaluationContextRecord::EK_Other); d121 1 a121 1 PreallocatedFunctionScope.reset(new FunctionScopeInfo(Diags)); a124 6 std::unique_ptr Callbacks = llvm::make_unique(); SemaPPCallbackHandler = Callbacks.get(); PP.addPPCallbacks(std::move(Callbacks)); SemaPPCallbackHandler->set(*this); a284 1 d286 4 a289 3 for (sema::FunctionScopeInfo *FSI : FunctionScopes) if (FSI != PreallocatedFunctionScope.get()) delete FSI; a308 4 // Detach from the PP callback handler which outlives Sema since it's owned // by the preprocessor. SemaPPCallbackHandler->reset(); d341 1 a341 1 ///Registers an external source. If an external source already exists, d362 1 a362 1 /// Print out statistics about the semantic analysis. d386 3 a388 2 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant, E->getLocStart())) a393 13 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer) return; if (E->IgnoreParenImpCasts()->getType()->isNullPtrType()) return; // If it is a macro from system header, and if the macro name is not "NULL", // do not warn. SourceLocation MaybeMacroLoc = E->getLocStart(); if (Diags.getSuppressSystemWarnings() && SourceMgr.isInSystemMacro(MaybeMacroLoc) && !findMacroSpelling(MaybeMacroLoc, "NULL")) return; d467 1 a467 1 llvm_unreachable("unknown scalar type kind"); d470 1 a470 1 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector. a531 17 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) { if (auto *FD = dyn_cast(ND)) return FD->isExternC(); return cast(ND)->isExternC(); } /// Determine whether ND is an external-linkage function or variable whose /// type has no linkage. bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) { // Note: it's not quite enough to check whether VD has UniqueExternalLinkage, // because we also want to catch the case where its type has VisibleNoLinkage, // which does not affect the linkage of VD. return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() && !isExternalFormalLinkage(VD->getType()->getLinkage()) && !isFunctionOrVarDeclExternC(VD); } a547 7 if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } a551 1 !isExternalWithNoLinkageType(FD) && a553 2 if (FD->getBuiltinID()) continue; d558 1 a558 8 if (VD->isExternallyVisible() && !isExternalWithNoLinkageType(VD) && !VD->getMostRecentDecl()->isInline()) continue; // Skip VarDecls that lack formal definitions but which we know are in // fact defined somewhere. if (VD->isKnownToBeDefined()) d576 15 a590 25 for (auto Undef : Undefined) { ValueDecl *VD = cast(Undef.first); SourceLocation UseLoc = Undef.second; if (S.isExternalWithNoLinkageType(VD)) { // C++ [basic.link]p8: // A type without linkage shall not be used as the type of a variable // or function with external linkage unless // -- the entity has C language linkage // -- the entity is not odr-used or is defined in the same TU // // As an extension, accept this in cases where the type is externally // visible, since the function or variable actually can be defined in // another translation unit in that case. S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage()) ? diag::ext_undefined_internal_type : diag::err_undefined_internal_type) << isa(VD) << VD; } else if (!VD->isExternallyVisible()) { // FIXME: We can promote this to an error. The function or variable can't // be defined anywhere else, so the program must necessarily violate the // one definition rule. S.Diag(VD->getLocation(), diag::warn_undefined_internal) << isa(VD) << VD; } else if (auto *FD = dyn_cast(VD)) { d595 1 a595 1 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD; d597 1 a597 1 assert(cast(VD)->getMostRecentDecl()->isInline() && d599 1 a599 1 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD; d601 2 a602 2 if (UseLoc.isValid()) S.Diag(UseLoc, diag::note_used_here); d621 1 a621 1 /// Returns true, if all methods and nested classes of the given d638 1 a638 2 Complete = M->isDefined() || M->isDefaulted() || (M->isPure() && !isa(M)); d660 1 a660 1 /// Returns true, if the given CXXRecordDecl is fully defined in this a715 3 SourceLocation StartOfTU = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()); d718 2 a719 13 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU); assert(GlobalModule && "module creation should not fail"); // Enter the scope of the global module. ModuleScopes.push_back({}); ModuleScopes.back().Module = GlobalModule; VisibleModules.setVisible(GlobalModule, StartOfTU); // All declarations created from now on are owned by the global module. auto *TU = Context.getTranslationUnitDecl(); TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible); TU->setLocalOwningModule(GlobalModule); a734 14 // Transfer late parsed template instantiations over to the pending template // instantiation list. During normal compliation, the late template parser // will be installed and instantiating these templates will succeed. // // If we are building a TU prefix for serialization, it is also safe to // transfer these over, even though they are not parsed. The end of the TU // should be outside of any eager template instantiation scope, so when this // AST is deserialized, these templates will not be parsed until the end of // the combined TU. PendingInstantiations.insert(PendingInstantiations.end(), LateParsedInstantiations.begin(), LateParsedInstantiations.end()); LateParsedInstantiations.clear(); a763 1 a765 4 assert(LateParsedInstantiations.empty() && "end of TU template instantiation should not create more " "late-parsed templates"); a771 1 DiagnoseUnterminatedPragmaPack(); a827 11 // If we are building a module interface unit, we need to have seen the // module declaration by now. if (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface && ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit) { // FIXME: Make a better guess as to where to put the module declaration. Diag(getSourceManager().getLocForStartOfFile( getSourceManager().getMainFileID()), diag::err_module_declaration_missing); } d854 5 d876 2 a877 1 T != TEnd; ++T) { d904 1 d908 2 a909 4 // noise. Don't warn for a use from a module: either we should warn on all // file-scope declarations in modules or not at all, but whether the // declaration is used is immaterial. if (!Diags.hasErrorOccurred() && TUKind != TU_Module) { a976 2 // FIXME: Load additional unused private field candidates from the external // source. d1138 1 a1138 2 // Copy the diagnostic printing policy over the ASTContext printing policy. // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292 d1161 1 a1161 1 /// Looks through the macro-expansion chain for the given d1182 1 a1182 1 /// Determines the active Scope associated with the given declaration d1211 1 a1211 1 /// Enter a new function scope d1213 8 a1220 6 if (FunctionScopes.empty()) { // Use PreallocatedFunctionScope to avoid allocating memory when possible. PreallocatedFunctionScope->Clear(); FunctionScopes.push_back(PreallocatedFunctionScope.get()); } else { FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); d1222 2 d1243 2 a1244 2 } llvm_unreachable( d1250 1 a1251 1 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); d1263 1 a1263 2 // Delete the scope unless its our preallocated scope. if (Scope != PreallocatedFunctionScope.get()) d1267 2 a1268 2 void Sema::PushCompoundScope(bool IsStmtExpr) { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr)); d1278 1 a1278 1 /// Determine whether any errors occurred within this function/method/ a1283 15 void Sema::setFunctionHasBranchIntoScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchIntoScope(); } void Sema::setFunctionHasBranchProtectedScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchProtectedScope(); } void Sema::setFunctionHasIndirectGoto() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasIndirectGoto(); } a1298 12 FunctionScopeInfo *Sema::getEnclosingFunction() const { if (FunctionScopes.empty()) return nullptr; for (int e = FunctionScopes.size() - 1; e >= 0; --e) { if (isa(FunctionScopes[e])) continue; return FunctionScopes[e]; } return nullptr; } d1336 2 a1337 1 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false); d1375 19 a1393 1 /// Figure out if an expression could be turned into a call. d1495 1 a1495 1 /// Give notes for a set of overloads. a1520 6 // Don't print overloads for non-default multiversioned functions. if (const auto *FD = Fn->getAsFunction()) { if (FD->isMultiVersion() && !FD->getAttr()->isDefaultVersion()) continue; } @ 1.1.1.12.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.12.2.1 log @Sync with HEAD @ text @a21 1 #include "clang/AST/PrettyDeclStackTrace.h" d34 1 a39 1 #include "clang/Sema/TemplateInstCallback.h" d54 2 a55 2 // In diagnostics, we print _Bool as bool if the latter is defined as the // former. a72 43 namespace clang { namespace sema { class SemaPPCallbacks : public PPCallbacks { Sema *S = nullptr; llvm::SmallVector IncludeStack; public: void set(Sema &S) { this->S = &S; } void reset() { S = nullptr; } virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override { if (!S) return; switch (Reason) { case EnterFile: { SourceManager &SM = S->getSourceManager(); SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc)); if (IncludeLoc.isValid()) { IncludeStack.push_back(IncludeLoc); S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc); } break; } case ExitFile: if (!IncludeStack.empty()) S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::ChangedStateAtExit, IncludeStack.pop_back_val()); break; default: break; } } }; } // end namespace sema } // end namespace clang d90 3 a92 3 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), d96 4 a99 7 TUKind(TUKind), NumSFINAEErrors(0), FullyCheckedComparisonCategories( static_cast(ComparisonCategoryType::Last) + 1), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), d119 1 a119 1 nullptr, ExpressionEvaluationContextRecord::EK_Other); d121 1 a121 1 PreallocatedFunctionScope.reset(new FunctionScopeInfo(Diags)); a124 6 std::unique_ptr Callbacks = llvm::make_unique(); SemaPPCallbackHandler = Callbacks.get(); PP.addPPCallbacks(std::move(Callbacks)); SemaPPCallbackHandler->set(*this); a284 1 d286 4 a289 3 for (sema::FunctionScopeInfo *FSI : FunctionScopes) if (FSI != PreallocatedFunctionScope.get()) delete FSI; a308 4 // Detach from the PP callback handler which outlives Sema since it's owned // by the preprocessor. SemaPPCallbackHandler->reset(); d341 1 a341 1 ///Registers an external source. If an external source already exists, d362 1 a362 1 /// Print out statistics about the semantic analysis. d386 3 a388 2 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant, E->getLocStart())) a393 13 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer) return; if (E->IgnoreParenImpCasts()->getType()->isNullPtrType()) return; // If it is a macro from system header, and if the macro name is not "NULL", // do not warn. SourceLocation MaybeMacroLoc = E->getLocStart(); if (Diags.getSuppressSystemWarnings() && SourceMgr.isInSystemMacro(MaybeMacroLoc) && !findMacroSpelling(MaybeMacroLoc, "NULL")) return; d467 1 a467 1 llvm_unreachable("unknown scalar type kind"); d470 1 a470 1 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector. a531 17 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) { if (auto *FD = dyn_cast(ND)) return FD->isExternC(); return cast(ND)->isExternC(); } /// Determine whether ND is an external-linkage function or variable whose /// type has no linkage. bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) { // Note: it's not quite enough to check whether VD has UniqueExternalLinkage, // because we also want to catch the case where its type has VisibleNoLinkage, // which does not affect the linkage of VD. return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() && !isExternalFormalLinkage(VD->getType()->getLinkage()) && !isFunctionOrVarDeclExternC(VD); } a547 7 if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } a551 1 !isExternalWithNoLinkageType(FD) && a553 2 if (FD->getBuiltinID()) continue; d558 1 a558 8 if (VD->isExternallyVisible() && !isExternalWithNoLinkageType(VD) && !VD->getMostRecentDecl()->isInline()) continue; // Skip VarDecls that lack formal definitions but which we know are in // fact defined somewhere. if (VD->isKnownToBeDefined()) d576 15 a590 25 for (auto Undef : Undefined) { ValueDecl *VD = cast(Undef.first); SourceLocation UseLoc = Undef.second; if (S.isExternalWithNoLinkageType(VD)) { // C++ [basic.link]p8: // A type without linkage shall not be used as the type of a variable // or function with external linkage unless // -- the entity has C language linkage // -- the entity is not odr-used or is defined in the same TU // // As an extension, accept this in cases where the type is externally // visible, since the function or variable actually can be defined in // another translation unit in that case. S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage()) ? diag::ext_undefined_internal_type : diag::err_undefined_internal_type) << isa(VD) << VD; } else if (!VD->isExternallyVisible()) { // FIXME: We can promote this to an error. The function or variable can't // be defined anywhere else, so the program must necessarily violate the // one definition rule. S.Diag(VD->getLocation(), diag::warn_undefined_internal) << isa(VD) << VD; } else if (auto *FD = dyn_cast(VD)) { d595 1 a595 1 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD; d597 1 a597 1 assert(cast(VD)->getMostRecentDecl()->isInline() && d599 1 a599 1 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD; d601 2 a602 2 if (UseLoc.isValid()) S.Diag(UseLoc, diag::note_used_here); d621 1 a621 1 /// Returns true, if all methods and nested classes of the given d638 1 a638 2 Complete = M->isDefined() || M->isDefaulted() || (M->isPure() && !isa(M)); d660 1 a660 1 /// Returns true, if the given CXXRecordDecl is fully defined in this a715 3 SourceLocation StartOfTU = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()); d718 2 a719 13 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU); assert(GlobalModule && "module creation should not fail"); // Enter the scope of the global module. ModuleScopes.push_back({}); ModuleScopes.back().Module = GlobalModule; VisibleModules.setVisible(GlobalModule, StartOfTU); // All declarations created from now on are owned by the global module. auto *TU = Context.getTranslationUnitDecl(); TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible); TU->setLocalOwningModule(GlobalModule); a734 14 // Transfer late parsed template instantiations over to the pending template // instantiation list. During normal compliation, the late template parser // will be installed and instantiating these templates will succeed. // // If we are building a TU prefix for serialization, it is also safe to // transfer these over, even though they are not parsed. The end of the TU // should be outside of any eager template instantiation scope, so when this // AST is deserialized, these templates will not be parsed until the end of // the combined TU. PendingInstantiations.insert(PendingInstantiations.end(), LateParsedInstantiations.begin(), LateParsedInstantiations.end()); LateParsedInstantiations.clear(); a763 1 a765 4 assert(LateParsedInstantiations.empty() && "end of TU template instantiation should not create more " "late-parsed templates"); a771 1 DiagnoseUnterminatedPragmaPack(); a827 11 // If we are building a module interface unit, we need to have seen the // module declaration by now. if (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface && ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit) { // FIXME: Make a better guess as to where to put the module declaration. Diag(getSourceManager().getLocForStartOfFile( getSourceManager().getMainFileID()), diag::err_module_declaration_missing); } d854 5 d876 2 a877 1 T != TEnd; ++T) { d904 1 d908 2 a909 4 // noise. Don't warn for a use from a module: either we should warn on all // file-scope declarations in modules or not at all, but whether the // declaration is used is immaterial. if (!Diags.hasErrorOccurred() && TUKind != TU_Module) { a976 2 // FIXME: Load additional unused private field candidates from the external // source. d1138 1 a1138 2 // Copy the diagnostic printing policy over the ASTContext printing policy. // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292 d1161 1 a1161 1 /// Looks through the macro-expansion chain for the given d1182 1 a1182 1 /// Determines the active Scope associated with the given declaration d1211 1 a1211 1 /// Enter a new function scope d1213 8 a1220 6 if (FunctionScopes.empty()) { // Use PreallocatedFunctionScope to avoid allocating memory when possible. PreallocatedFunctionScope->Clear(); FunctionScopes.push_back(PreallocatedFunctionScope.get()); } else { FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); d1222 2 d1243 2 a1244 2 } llvm_unreachable( d1250 1 a1251 1 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); d1263 1 a1263 2 // Delete the scope unless its our preallocated scope. if (Scope != PreallocatedFunctionScope.get()) d1267 2 a1268 2 void Sema::PushCompoundScope(bool IsStmtExpr) { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr)); d1278 1 a1278 1 /// Determine whether any errors occurred within this function/method/ a1283 15 void Sema::setFunctionHasBranchIntoScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchIntoScope(); } void Sema::setFunctionHasBranchProtectedScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchProtectedScope(); } void Sema::setFunctionHasIndirectGoto() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasIndirectGoto(); } a1298 12 FunctionScopeInfo *Sema::getEnclosingFunction() const { if (FunctionScopes.empty()) return nullptr; for (int e = FunctionScopes.size() - 1; e >= 0; --e) { if (isa(FunctionScopes[e])) continue; return FunctionScopes[e]; } return nullptr; } d1336 2 a1337 1 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false); d1375 19 a1393 1 /// Figure out if an expression could be turned into a call. d1495 1 a1495 1 /// Give notes for a set of overloads. a1520 6 // Don't print overloads for non-default multiversioned functions. if (const auto *FD = Fn->getAsFunction()) { if (FD->isMultiVersion() && !FD->getAttr()->isDefaultVersion()) continue; } @ 1.1.1.13 log @Import clang r337282 from trunk @ text @a21 1 #include "clang/AST/PrettyDeclStackTrace.h" d34 1 a39 1 #include "clang/Sema/TemplateInstCallback.h" d54 2 a55 2 // In diagnostics, we print _Bool as bool if the latter is defined as the // former. a72 43 namespace clang { namespace sema { class SemaPPCallbacks : public PPCallbacks { Sema *S = nullptr; llvm::SmallVector IncludeStack; public: void set(Sema &S) { this->S = &S; } void reset() { S = nullptr; } virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override { if (!S) return; switch (Reason) { case EnterFile: { SourceManager &SM = S->getSourceManager(); SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc)); if (IncludeLoc.isValid()) { IncludeStack.push_back(IncludeLoc); S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc); } break; } case ExitFile: if (!IncludeStack.empty()) S->DiagnoseNonDefaultPragmaPack( Sema::PragmaPackDiagnoseKind::ChangedStateAtExit, IncludeStack.pop_back_val()); break; default: break; } } }; } // end namespace sema } // end namespace clang d90 3 a92 3 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), d96 4 a99 7 TUKind(TUKind), NumSFINAEErrors(0), FullyCheckedComparisonCategories( static_cast(ComparisonCategoryType::Last) + 1), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), d119 1 a119 1 nullptr, ExpressionEvaluationContextRecord::EK_Other); d121 1 a121 1 PreallocatedFunctionScope.reset(new FunctionScopeInfo(Diags)); a124 6 std::unique_ptr Callbacks = llvm::make_unique(); SemaPPCallbackHandler = Callbacks.get(); PP.addPPCallbacks(std::move(Callbacks)); SemaPPCallbackHandler->set(*this); a284 1 d286 4 a289 3 for (sema::FunctionScopeInfo *FSI : FunctionScopes) if (FSI != PreallocatedFunctionScope.get()) delete FSI; a308 4 // Detach from the PP callback handler which outlives Sema since it's owned // by the preprocessor. SemaPPCallbackHandler->reset(); d341 1 a341 1 ///Registers an external source. If an external source already exists, d362 1 a362 1 /// Print out statistics about the semantic analysis. d386 3 a388 2 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant, E->getLocStart())) a393 13 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer) return; if (E->IgnoreParenImpCasts()->getType()->isNullPtrType()) return; // If it is a macro from system header, and if the macro name is not "NULL", // do not warn. SourceLocation MaybeMacroLoc = E->getLocStart(); if (Diags.getSuppressSystemWarnings() && SourceMgr.isInSystemMacro(MaybeMacroLoc) && !findMacroSpelling(MaybeMacroLoc, "NULL")) return; d467 1 a467 1 llvm_unreachable("unknown scalar type kind"); d470 1 a470 1 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector. a531 17 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) { if (auto *FD = dyn_cast(ND)) return FD->isExternC(); return cast(ND)->isExternC(); } /// Determine whether ND is an external-linkage function or variable whose /// type has no linkage. bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) { // Note: it's not quite enough to check whether VD has UniqueExternalLinkage, // because we also want to catch the case where its type has VisibleNoLinkage, // which does not affect the linkage of VD. return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() && !isExternalFormalLinkage(VD->getType()->getLinkage()) && !isFunctionOrVarDeclExternC(VD); } a547 7 if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } a551 1 !isExternalWithNoLinkageType(FD) && a553 2 if (FD->getBuiltinID()) continue; d558 1 a558 8 if (VD->isExternallyVisible() && !isExternalWithNoLinkageType(VD) && !VD->getMostRecentDecl()->isInline()) continue; // Skip VarDecls that lack formal definitions but which we know are in // fact defined somewhere. if (VD->isKnownToBeDefined()) d576 15 a590 25 for (auto Undef : Undefined) { ValueDecl *VD = cast(Undef.first); SourceLocation UseLoc = Undef.second; if (S.isExternalWithNoLinkageType(VD)) { // C++ [basic.link]p8: // A type without linkage shall not be used as the type of a variable // or function with external linkage unless // -- the entity has C language linkage // -- the entity is not odr-used or is defined in the same TU // // As an extension, accept this in cases where the type is externally // visible, since the function or variable actually can be defined in // another translation unit in that case. S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage()) ? diag::ext_undefined_internal_type : diag::err_undefined_internal_type) << isa(VD) << VD; } else if (!VD->isExternallyVisible()) { // FIXME: We can promote this to an error. The function or variable can't // be defined anywhere else, so the program must necessarily violate the // one definition rule. S.Diag(VD->getLocation(), diag::warn_undefined_internal) << isa(VD) << VD; } else if (auto *FD = dyn_cast(VD)) { d595 1 a595 1 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD; d597 1 a597 1 assert(cast(VD)->getMostRecentDecl()->isInline() && d599 1 a599 1 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD; d601 2 a602 2 if (UseLoc.isValid()) S.Diag(UseLoc, diag::note_used_here); d621 1 a621 1 /// Returns true, if all methods and nested classes of the given d638 1 a638 2 Complete = M->isDefined() || M->isDefaulted() || (M->isPure() && !isa(M)); d660 1 a660 1 /// Returns true, if the given CXXRecordDecl is fully defined in this a715 3 SourceLocation StartOfTU = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()); d718 2 a719 13 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU); assert(GlobalModule && "module creation should not fail"); // Enter the scope of the global module. ModuleScopes.push_back({}); ModuleScopes.back().Module = GlobalModule; VisibleModules.setVisible(GlobalModule, StartOfTU); // All declarations created from now on are owned by the global module. auto *TU = Context.getTranslationUnitDecl(); TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible); TU->setLocalOwningModule(GlobalModule); a734 14 // Transfer late parsed template instantiations over to the pending template // instantiation list. During normal compliation, the late template parser // will be installed and instantiating these templates will succeed. // // If we are building a TU prefix for serialization, it is also safe to // transfer these over, even though they are not parsed. The end of the TU // should be outside of any eager template instantiation scope, so when this // AST is deserialized, these templates will not be parsed until the end of // the combined TU. PendingInstantiations.insert(PendingInstantiations.end(), LateParsedInstantiations.begin(), LateParsedInstantiations.end()); LateParsedInstantiations.clear(); a763 1 a765 4 assert(LateParsedInstantiations.empty() && "end of TU template instantiation should not create more " "late-parsed templates"); a771 1 DiagnoseUnterminatedPragmaPack(); a827 11 // If we are building a module interface unit, we need to have seen the // module declaration by now. if (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface && ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit) { // FIXME: Make a better guess as to where to put the module declaration. Diag(getSourceManager().getLocForStartOfFile( getSourceManager().getMainFileID()), diag::err_module_declaration_missing); } d854 5 d876 2 a877 1 T != TEnd; ++T) { d904 1 d908 2 a909 4 // noise. Don't warn for a use from a module: either we should warn on all // file-scope declarations in modules or not at all, but whether the // declaration is used is immaterial. if (!Diags.hasErrorOccurred() && TUKind != TU_Module) { a976 2 // FIXME: Load additional unused private field candidates from the external // source. d1138 1 a1138 2 // Copy the diagnostic printing policy over the ASTContext printing policy. // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292 d1161 1 a1161 1 /// Looks through the macro-expansion chain for the given d1182 1 a1182 1 /// Determines the active Scope associated with the given declaration d1211 1 a1211 1 /// Enter a new function scope d1213 8 a1220 6 if (FunctionScopes.empty()) { // Use PreallocatedFunctionScope to avoid allocating memory when possible. PreallocatedFunctionScope->Clear(); FunctionScopes.push_back(PreallocatedFunctionScope.get()); } else { FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); d1222 2 d1243 2 a1244 2 } llvm_unreachable( d1250 1 a1251 1 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); d1263 1 a1263 2 // Delete the scope unless its our preallocated scope. if (Scope != PreallocatedFunctionScope.get()) d1267 2 a1268 2 void Sema::PushCompoundScope(bool IsStmtExpr) { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr)); d1278 1 a1278 1 /// Determine whether any errors occurred within this function/method/ a1283 15 void Sema::setFunctionHasBranchIntoScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchIntoScope(); } void Sema::setFunctionHasBranchProtectedScope() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasBranchProtectedScope(); } void Sema::setFunctionHasIndirectGoto() { if (!FunctionScopes.empty()) FunctionScopes.back()->setHasIndirectGoto(); } a1298 12 FunctionScopeInfo *Sema::getEnclosingFunction() const { if (FunctionScopes.empty()) return nullptr; for (int e = FunctionScopes.size() - 1; e >= 0; --e) { if (isa(FunctionScopes[e])) continue; return FunctionScopes[e]; } return nullptr; } d1336 2 a1337 1 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false); d1375 19 a1393 1 /// Figure out if an expression could be turned into a call. d1495 1 a1495 1 /// Give notes for a set of overloads. a1520 6 // Don't print overloads for non-default multiversioned functions. if (const auto *FD = Fn->getAsFunction()) { if (FD->isMultiVersion() && !FD->getAttr()->isDefaultVersion()) continue; } @ 1.1.1.14 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file Sema.cpp was added on branch tls-maxphys on 2014-08-19 23:47:30 +0000 @ text @d1 1451 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1451 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// // // 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 actions class which performs semantic analysis and // builds an AST out of a parse stream. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTDiagnostic.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CXXFieldCollector.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/ExternalSemaSource.h" #include "clang/Sema/MultiplexExternalSemaSource.h" #include "clang/Sema/ObjCMethodList.h" #include "clang/Sema/PrettyDeclStackTrace.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaConsumer.h" #include "clang/Sema/TemplateDeduction.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/CrashRecoveryContext.h" using namespace clang; using namespace sema; SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) { return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts); } ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); } PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, const Preprocessor &PP) { PrintingPolicy Policy = Context.getPrintingPolicy(); Policy.Bool = Context.getLangOpts().Bool; if (!Policy.Bool) { if (const MacroInfo * BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) { Policy.Bool = BoolMacro->isObjectLike() && BoolMacro->getNumTokens() == 1 && BoolMacro->getReplacementToken(0).is(tok::kw__Bool); } } return Policy; } void Sema::ActOnTranslationUnitScope(Scope *S) { TUScope = S; PushDeclContext(S, Context.getTranslationUnitDecl()); VAListTagName = PP.getIdentifierInfo("__va_list_tag"); } Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter) : ExternalSource(nullptr), isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), CollectStats(false), CodeCompleter(CodeCompleter), CurContext(nullptr), OriginalLexicalContext(nullptr), PackContext(nullptr), MSStructPragmaOn(false), MSPointerToMemberRepresentationMethod( LangOpts.getMSPointerToMemberRepresentationMethod()), VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), IsBuildingRecoveryCallExpr(false), ExprNeedsCleanups(false), LateTemplateParser(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr), InitArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr), InitDictionaryWithObjectsMethod(nullptr), ArrayAllocObjectsMethod(nullptr), DictAllocObjectsMethod(nullptr), GlobalNewDeleteDeclared(false), TUKind(TUKind), NumSFINAEErrors(0), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), VarDataSharingAttributesStack(nullptr), CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) { TUScope = nullptr; LoadedExternalKnownNamespaces = false; for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) NSNumberLiteralMethods[I] = nullptr; if (getLangOpts().ObjC1) NSAPIObj.reset(new NSAPI(Context)); if (getLangOpts().CPlusPlus) FieldCollector.reset(new CXXFieldCollector()); // Tell diagnostics how to render things from the AST library. PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); ExprEvalContexts.push_back( ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, false, nullptr, false)); FunctionScopes.push_back(new FunctionScopeInfo(Diags)); // Initilization of data sharing attributes stack for OpenMP InitDataSharingAttributesStack(); } void Sema::addImplicitTypedef(StringRef Name, QualType T) { DeclarationName DN = &Context.Idents.get(Name); if (IdResolver.begin(DN) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope); } void Sema::Initialize() { // Tell the AST consumer about this Sema object. Consumer.Initialize(Context); // FIXME: Isn't this redundant with the initialization above? if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->InitializeSema(*this); // Tell the external Sema source about this Sema object. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->InitializeSema(*this); // Initialize predefined 128-bit integer types, if needed. if (Context.getTargetInfo().hasInt128Type()) { // If either of the 128-bit integer types are unavailable to name lookup, // define them now. DeclarationName Int128 = &Context.Idents.get("__int128_t"); if (IdResolver.begin(Int128) == IdResolver.end()) PushOnScopeChains(Context.getInt128Decl(), TUScope); DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); if (IdResolver.begin(UInt128) == IdResolver.end()) PushOnScopeChains(Context.getUInt128Decl(), TUScope); } // Initialize predefined Objective-C types: if (PP.getLangOpts().ObjC1) { // If 'SEL' does not yet refer to any declarations, make it refer to the // predefined 'SEL'. DeclarationName SEL = &Context.Idents.get("SEL"); if (IdResolver.begin(SEL) == IdResolver.end()) PushOnScopeChains(Context.getObjCSelDecl(), TUScope); // If 'id' does not yet refer to any declarations, make it refer to the // predefined 'id'. DeclarationName Id = &Context.Idents.get("id"); if (IdResolver.begin(Id) == IdResolver.end()) PushOnScopeChains(Context.getObjCIdDecl(), TUScope); // Create the built-in typedef for 'Class'. DeclarationName Class = &Context.Idents.get("Class"); if (IdResolver.begin(Class) == IdResolver.end()) PushOnScopeChains(Context.getObjCClassDecl(), TUScope); // Create the built-in forward declaratino for 'Protocol'. DeclarationName Protocol = &Context.Idents.get("Protocol"); if (IdResolver.begin(Protocol) == IdResolver.end()) PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); } // Initialize Microsoft "predefined C++ types". if (PP.getLangOpts().MSVCCompat && PP.getLangOpts().CPlusPlus) { if (IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class), TUScope); addImplicitTypedef("size_t", Context.getSizeType()); } // Initialize predefined OpenCL types. if (PP.getLangOpts().OpenCL) { addImplicitTypedef("image1d_t", Context.OCLImage1dTy); addImplicitTypedef("image1d_array_t", Context.OCLImage1dArrayTy); addImplicitTypedef("image1d_buffer_t", Context.OCLImage1dBufferTy); addImplicitTypedef("image2d_t", Context.OCLImage2dTy); addImplicitTypedef("image2d_array_t", Context.OCLImage2dArrayTy); addImplicitTypedef("image3d_t", Context.OCLImage3dTy); addImplicitTypedef("sampler_t", Context.OCLSamplerTy); addImplicitTypedef("event_t", Context.OCLEventTy); } DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); } Sema::~Sema() { llvm::DeleteContainerSeconds(LateParsedTemplateMap); if (PackContext) FreePackedContext(); if (VisContext) FreeVisContext(); // Kill all the active scopes. for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I) delete FunctionScopes[I]; if (FunctionScopes.size() == 1) delete FunctionScopes[0]; // Tell the SemaConsumer to forget about us; we're going out of scope. if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->ForgetSema(); // Detach from the external Sema source. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->ForgetSema(); // If Sema's ExternalSource is the multiplexer - we own it. if (isMultiplexExternalSource) delete ExternalSource; // Destroys data sharing attributes stack for OpenMP DestroyDataSharingAttributesStack(); } /// makeUnavailableInSystemHeader - There is an error in the current /// context. If we're still in a system header, and we can plausibly /// make the relevant declaration unavailable instead of erroring, do /// so and return true. bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, StringRef msg) { // If we're not in a function, it's an error. FunctionDecl *fn = dyn_cast(CurContext); if (!fn) return false; // If we're in template instantiation, it's an error. if (!ActiveTemplateInstantiations.empty()) return false; // If that function's not in a system header, it's an error. if (!Context.getSourceManager().isInSystemHeader(loc)) return false; // If the function is already unavailable, it's not an error. if (fn->hasAttr()) return true; fn->addAttr(UnavailableAttr::CreateImplicit(Context, msg, loc)); return true; } ASTMutationListener *Sema::getASTMutationListener() const { return getASTConsumer().GetASTMutationListener(); } ///\brief Registers an external source. If an external source already exists, /// creates a multiplex external source and appends to it. /// ///\param[in] E - A non-null external sema source. /// void Sema::addExternalSource(ExternalSemaSource *E) { assert(E && "Cannot use with NULL ptr"); if (!ExternalSource) { ExternalSource = E; return; } if (isMultiplexExternalSource) static_cast(ExternalSource)->addSource(*E); else { ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E); isMultiplexExternalSource = true; } } /// \brief Print out statistics about the semantic analysis. void Sema::PrintStats() const { llvm::errs() << "\n*** Semantic Analysis Stats:\n"; llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; BumpAlloc.PrintStats(); AnalysisWarnings.PrintStats(); } /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. /// If there is already an implicit cast, merge into the existing one. /// The result is of the given category. ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, CastKind Kind, ExprValueKind VK, const CXXCastPath *BasePath, CheckedConversionKind CCK) { #ifndef NDEBUG if (VK == VK_RValue && !E->isRValue()) { switch (Kind) { default: llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast " "kind"); case CK_LValueToRValue: case CK_ArrayToPointerDecay: case CK_FunctionToPointerDecay: case CK_ToVoid: break; } } assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); #endif QualType ExprTy = Context.getCanonicalType(E->getType()); QualType TypeTy = Context.getCanonicalType(Ty); if (ExprTy == TypeTy) return E; // If this is a derived-to-base cast to a through a virtual base, we // need a vtable. if (Kind == CK_DerivedToBase && BasePathInvolvesVirtualBase(*BasePath)) { QualType T = E->getType(); if (const PointerType *Pointer = T->getAs()) T = Pointer->getPointeeType(); if (const RecordType *RecordTy = T->getAs()) MarkVTableUsed(E->getLocStart(), cast(RecordTy->getDecl())); } if (ImplicitCastExpr *ImpCast = dyn_cast(E)) { if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { ImpCast->setType(Ty); ImpCast->setValueKind(VK); return E; } } return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK); } /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding /// to the conversion from scalar type ScalarTy to the Boolean type. CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { switch (ScalarTy->getScalarTypeKind()) { case Type::STK_Bool: return CK_NoOp; case Type::STK_CPointer: return CK_PointerToBoolean; case Type::STK_BlockPointer: return CK_PointerToBoolean; case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; case Type::STK_Integral: return CK_IntegralToBoolean; case Type::STK_Floating: return CK_FloatingToBoolean; case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; } return CK_Invalid; } /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { if (D->getMostRecentDecl()->isUsed()) return true; if (D->isExternallyVisible()) return true; if (const FunctionDecl *FD = dyn_cast(D)) { // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const FunctionDecl *DeclToCheck; if (FD->hasBody(DeclToCheck)) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = FD->getMostRecentDecl(); if (DeclToCheck != FD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } if (const VarDecl *VD = dyn_cast(D)) { // If a variable usable in constant expressions is referenced, // don't warn if it isn't used: if the value of a variable is required // for the computation of a constant expression, it doesn't make sense to // warn even if the variable isn't odr-used. (isReferenced doesn't // precisely reflect that, but it's a decent approximation.) if (VD->isReferenced() && VD->isUsableInConstantExpressions(SemaRef->Context)) return true; // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const VarDecl *DeclToCheck = VD->getDefinition(); if (DeclToCheck) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = VD->getMostRecentDecl(); if (DeclToCheck != VD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } return false; } /// Obtains a sorted list of functions that are undefined but ODR-used. void Sema::getUndefinedButUsed( SmallVectorImpl > &Undefined) { for (llvm::DenseMap::iterator I = UndefinedButUsed.begin(), E = UndefinedButUsed.end(); I != E; ++I) { NamedDecl *ND = I->first; // Ignore attributes that have become invalid. if (ND->isInvalidDecl()) continue; // __attribute__((weakref)) is basically a definition. if (ND->hasAttr()) continue; if (FunctionDecl *FD = dyn_cast(ND)) { if (FD->isDefined()) continue; if (FD->isExternallyVisible() && !FD->getMostRecentDecl()->isInlined()) continue; } else { if (cast(ND)->hasDefinition() != VarDecl::DeclarationOnly) continue; if (ND->isExternallyVisible()) continue; } Undefined.push_back(std::make_pair(ND, I->second)); } // Sort (in order of use site) so that we're not dependent on the iteration // order through an llvm::DenseMap. SourceManager &SM = Context.getSourceManager(); std::sort(Undefined.begin(), Undefined.end(), [&SM](const std::pair &l, const std::pair &r) { if (l.second.isValid() && !r.second.isValid()) return true; if (!l.second.isValid() && r.second.isValid()) return false; if (l.second != r.second) return SM.isBeforeInTranslationUnit(l.second, r.second); return SM.isBeforeInTranslationUnit(l.first->getLocation(), r.first->getLocation()); }); } /// checkUndefinedButUsed - Check for undefined objects with internal linkage /// or that are inline. static void checkUndefinedButUsed(Sema &S) { if (S.UndefinedButUsed.empty()) return; // Collect all the still-undefined entities with internal linkage. SmallVector, 16> Undefined; S.getUndefinedButUsed(Undefined); if (Undefined.empty()) return; for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { NamedDecl *ND = I->first; if (ND->hasAttr() || ND->hasAttr()) { // An exported function will always be emitted when defined, so even if // the function is inline, it doesn't have to be emitted in this TU. An // imported function implies that it has been exported somewhere else. continue; } if (!ND->isExternallyVisible()) { S.Diag(ND->getLocation(), diag::warn_undefined_internal) << isa(ND) << ND; } else { assert(cast(ND)->getMostRecentDecl()->isInlined() && "used object requires definition but isn't inline or internal?"); S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND; } if (I->second.isValid()) S.Diag(I->second, diag::note_used_here); } } void Sema::LoadExternalWeakUndeclaredIdentifiers() { if (!ExternalSource) return; SmallVector, 4> WeakIDs; ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) { llvm::DenseMap::iterator Pos = WeakUndeclaredIdentifiers.find(WeakIDs[I].first); if (Pos != WeakUndeclaredIdentifiers.end()) continue; WeakUndeclaredIdentifiers.insert(WeakIDs[I]); } } typedef llvm::DenseMap RecordCompleteMap; /// \brief Returns true, if all methods and nested classes of the given /// CXXRecordDecl are defined in this translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = MNCComplete.find(RD); if (Cache != MNCComplete.end()) return Cache->second; if (!RD->isCompleteDefinition()) return false; bool Complete = true; for (DeclContext::decl_iterator I = RD->decls_begin(), E = RD->decls_end(); I != E && Complete; ++I) { if (const CXXMethodDecl *M = dyn_cast(*I)) Complete = M->isDefined() || (M->isPure() && !isa(M)); else if (const FunctionTemplateDecl *F = dyn_cast(*I)) Complete = F->getTemplatedDecl()->isDefined(); else if (const CXXRecordDecl *R = dyn_cast(*I)) { if (R->isInjectedClassName()) continue; if (R->hasDefinition()) Complete = MethodsAndNestedClassesComplete(R->getDefinition(), MNCComplete); else Complete = false; } } MNCComplete[RD] = Complete; return Complete; } /// \brief Returns true, if the given CXXRecordDecl is fully defined in this /// translation unit, i.e. all methods are defined or pure virtual and all /// friends, friend functions and nested classes are fully defined in this /// translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool IsRecordFullyDefined(const CXXRecordDecl *RD, RecordCompleteMap &RecordsComplete, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); if (Cache != RecordsComplete.end()) return Cache->second; bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), E = RD->friend_end(); I != E && Complete; ++I) { // Check if friend classes and methods are complete. if (TypeSourceInfo *TSI = (*I)->getFriendType()) { // Friend classes are available as the TypeSourceInfo of the FriendDecl. if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); else Complete = false; } else { // Friend functions are available through the NamedDecl of FriendDecl. if (const FunctionDecl *FD = dyn_cast((*I)->getFriendDecl())) Complete = FD->isDefined(); else // This is a template friend, give up. Complete = false; } } RecordsComplete[RD] = Complete; return Complete; } /// ActOnEndOfTranslationUnit - This is called at the very end of the /// translation unit when EOF is reached and all but the top-level scope is /// popped. void Sema::ActOnEndOfTranslationUnit() { assert(DelayedDiagnostics.getCurrentPool() == nullptr && "reached end of translation unit with a pool attached?"); // If code completion is enabled, don't perform any end-of-translation-unit // work. if (PP.isCodeCompletionEnabled()) return; // Complete translation units and modules define vtables and perform implicit // instantiations. PCH files do not. if (TUKind != TU_Prefix) { DiagnoseUseOfUnimplementedSelectors(); // If any dynamic classes have their key function defined within // this translation unit, then those vtables are considered "used" and must // be emitted. for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource), E = DynamicClasses.end(); I != E; ++I) { assert(!(*I)->isDependentType() && "Should not see dependent types here!"); if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { const FunctionDecl *Definition = nullptr; if (KeyFunction->hasBody(Definition)) MarkVTableUsed(Definition->getLocation(), *I, true); } } // If DefinedUsedVTables ends up marking any virtual member functions it // might lead to more pending template instantiations, which we then need // to instantiate. DefineUsedVTables(); // C++: Perform implicit template instantiations. // // FIXME: When we perform these implicit instantiations, we do not // carefully keep track of the point of instantiation (C++ [temp.point]). // This means that name lookup that occurs within the template // instantiation will always happen at the end of the translation unit, // so it will find some names that are not required to be found. This is // valid, but we could do better by diagnosing if an instantiation uses a // name that was not visible at its first point of instantiation. if (ExternalSource) { // Load pending instantiations from the external source. SmallVector Pending; ExternalSource->ReadPendingInstantiations(Pending); PendingInstantiations.insert(PendingInstantiations.begin(), Pending.begin(), Pending.end()); } PerformPendingInstantiations(); CheckDelayedMemberExceptionSpecs(); } // All delayed member exception specs should be checked or we end up accepting // incompatible declarations. assert(DelayedDefaultedMemberExceptionSpecs.empty()); assert(DelayedDestructorExceptionSpecChecks.empty()); // Remove file scoped decls that turned out to be used. UnusedFileScopedDecls.erase( std::remove_if(UnusedFileScopedDecls.begin(nullptr, true), UnusedFileScopedDecls.end(), std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)), UnusedFileScopedDecls.end()); if (TUKind == TU_Prefix) { // Translation unit prefixes don't need any of the checking below. TUScope = nullptr; return; } // Check for #pragma weak identifiers that were never declared // FIXME: This will cause diagnostics to be emitted in a non-determinstic // order! Iterating over a densemap like this is bad. LoadExternalWeakUndeclaredIdentifiers(); for (llvm::DenseMap::iterator I = WeakUndeclaredIdentifiers.begin(), E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { if (I->second.getUsed()) continue; Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) << I->first; } if (LangOpts.CPlusPlus11 && !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation())) CheckDelegatingCtorCycles(); if (TUKind == TU_Module) { // If we are building a module, resolve all of the exported declarations // now. if (Module *CurrentModule = PP.getCurrentModule()) { ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); SmallVector Stack; Stack.push_back(CurrentModule); while (!Stack.empty()) { Module *Mod = Stack.pop_back_val(); // Resolve the exported declarations and conflicts. // FIXME: Actually complain, once we figure out how to teach the // diagnostic client to deal with complaints in the module map at this // point. ModMap.resolveExports(Mod, /*Complain=*/false); ModMap.resolveUses(Mod, /*Complain=*/false); ModMap.resolveConflicts(Mod, /*Complain=*/false); // Queue the submodules, so their exports will also be resolved. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) { Stack.push_back(*Sub); } } } // Modules don't need any of the checking below. TUScope = nullptr; return; } // C99 6.9.2p2: // A declaration of an identifier for an object that has file // scope without an initializer, and without a storage-class // specifier or with the storage-class specifier static, // constitutes a tentative definition. If a translation unit // contains one or more tentative definitions for an identifier, // and the translation unit contains no external definition for // that identifier, then the behavior is exactly as if the // translation unit contains a file scope declaration of that // identifier, with the composite type as of the end of the // translation unit, with an initializer equal to 0. llvm::SmallSet Seen; for (TentativeDefinitionsType::iterator T = TentativeDefinitions.begin(ExternalSource), TEnd = TentativeDefinitions.end(); T != TEnd; ++T) { VarDecl *VD = (*T)->getActingDefinition(); // If the tentative definition was completed, getActingDefinition() returns // null. If we've already seen this variable before, insert()'s second // return value is false. if (!VD || VD->isInvalidDecl() || !Seen.insert(VD)) continue; if (const IncompleteArrayType *ArrayT = Context.getAsIncompleteArrayType(VD->getType())) { // Set the length of the array to 1 (C99 6.9.2p5). Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One, ArrayType::Normal, 0); VD->setType(T); } else if (RequireCompleteType(VD->getLocation(), VD->getType(), diag::err_tentative_def_incomplete_type)) VD->setInvalidDecl(); CheckCompleteVariableDeclaration(VD); // Notify the consumer that we've completed a tentative definition. if (!VD->isInvalidDecl()) Consumer.CompleteTentativeDefinition(VD); } // If there were errors, disable 'unused' warnings since they will mostly be // noise. if (!Diags.hasErrorOccurred()) { // Output warning for unused file scoped decls. for (UnusedFileScopedDeclsType::iterator I = UnusedFileScopedDecls.begin(ExternalSource), E = UnusedFileScopedDecls.end(); I != E; ++I) { if (ShouldRemoveFromUnused(this, *I)) continue; if (const FunctionDecl *FD = dyn_cast(*I)) { const FunctionDecl *DiagD; if (!FD->hasBody(DiagD)) DiagD = FD; if (DiagD->isDeleted()) continue; // Deleted functions are supposed to be unused. if (DiagD->isReferenced()) { if (isa(DiagD)) Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) << DiagD->getDeclName(); else { if (FD->getStorageClass() == SC_Static && !FD->isInlineSpecified() && !SourceMgr.isInMainFile( SourceMgr.getExpansionLoc(FD->getLocation()))) Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) << DiagD->getDeclName(); else Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*function*/0 << DiagD->getDeclName(); } } else { Diag(DiagD->getLocation(), isa(DiagD) ? diag::warn_unused_member_function : diag::warn_unused_function) << DiagD->getDeclName(); } } else { const VarDecl *DiagD = cast(*I)->getDefinition(); if (!DiagD) DiagD = cast(*I); if (DiagD->isReferenced()) { Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*variable*/1 << DiagD->getDeclName(); } else if (DiagD->getType().isConstQualified()) { Diag(DiagD->getLocation(), diag::warn_unused_const_variable) << DiagD->getDeclName(); } else { Diag(DiagD->getLocation(), diag::warn_unused_variable) << DiagD->getDeclName(); } } } if (ExternalSource) ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); checkUndefinedButUsed(*this); } if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) { RecordCompleteMap RecordsComplete; RecordCompleteMap MNCComplete; for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), E = UnusedPrivateFields.end(); I != E; ++I) { const NamedDecl *D = *I; const CXXRecordDecl *RD = dyn_cast(D->getDeclContext()); if (RD && !RD->isUnion() && IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { Diag(D->getLocation(), diag::warn_unused_private_field) << D->getDeclName(); } } } // Check we've noticed that we're no longer parsing the initializer for every // variable. If we miss cases, then at best we have a performance issue and // at worst a rejects-valid bug. assert(ParsingInitForAutoVars.empty() && "Didn't unmark var as having its initializer parsed"); TUScope = nullptr; } //===----------------------------------------------------------------------===// // Helper functions. //===----------------------------------------------------------------------===// DeclContext *Sema::getFunctionLevelDeclContext() { DeclContext *DC = CurContext; while (true) { if (isa(DC) || isa(DC) || isa(DC)) { DC = DC->getParent(); } else if (isa(DC) && cast(DC)->getOverloadedOperator() == OO_Call && cast(DC->getParent())->isLambda()) { DC = DC->getParent()->getParent(); } else break; } return DC; } /// getCurFunctionDecl - If inside of a function body, this returns a pointer /// to the function decl for the function being parsed. If we're currently /// in a 'block', this returns the containing context. FunctionDecl *Sema::getCurFunctionDecl() { DeclContext *DC = getFunctionLevelDeclContext(); return dyn_cast(DC); } ObjCMethodDecl *Sema::getCurMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); while (isa(DC)) DC = DC->getParent(); return dyn_cast(DC); } NamedDecl *Sema::getCurFunctionOrMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); if (isa(DC) || isa(DC)) return cast(DC); return nullptr; } void Sema::EmitCurrentDiagnostic(unsigned DiagID) { // FIXME: It doesn't make sense to me that DiagID is an incoming argument here // and yet we also use the current diag ID on the DiagnosticsEngine. This has // been made more painfully obvious by the refactor that introduced this // function, but it is possible that the incoming argument can be // eliminnated. If it truly cannot be (for example, there is some reentrancy // issue I am not seeing yet), then there should at least be a clarifying // comment somewhere. if (Optional Info = isSFINAEContext()) { switch (DiagnosticIDs::getDiagnosticSFINAEResponse( Diags.getCurrentDiagID())) { case DiagnosticIDs::SFINAE_Report: // We'll report the diagnostic below. break; case DiagnosticIDs::SFINAE_SubstitutionFailure: // Count this failure so that we know that template argument deduction // has failed. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; case DiagnosticIDs::SFINAE_AccessControl: { // Per C++ Core Issue 1170, access control is part of SFINAE. // Additionally, the AccessCheckingSFINAE flag can be used to temporarily // make access control a part of SFINAE for the purposes of checking // type traits. if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) break; SourceLocation Loc = Diags.getCurrentDiagLoc(); // Suppress this diagnostic. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); // Now the diagnostic state is clear, produce a C++98 compatibility // warning. Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); // The last diagnostic which Sema produced was ignored. Suppress any // notes attached to it. Diags.setLastDiagnosticIgnored(); return; } case DiagnosticIDs::SFINAE_Suppress: // Make a copy of this suppressed diagnostic and store it with the // template-deduction information; if (*Info) { Diagnostic DiagInfo(&Diags); (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } // Suppress this diagnostic. Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; } } // Set up the context's printing policy based on our current state. Context.setPrintingPolicy(getPrintingPolicy()); // Emit the diagnostic. if (!Diags.EmitCurrentDiagnostic()) return; // If this is not a note, and we're in a template instantiation // that is different from the last template instantiation where // we emitted an error, print a template instantiation // backtrace. if (!DiagnosticIDs::isBuiltinNote(DiagID) && !ActiveTemplateInstantiations.empty() && ActiveTemplateInstantiations.back() != LastTemplateInstantiationErrorContext) { PrintInstantiationStack(); LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); } } Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); PD.Emit(Builder); return Builder; } /// \brief Looks through the macro-expansion chain for the given /// location, looking for a macro expansion with the given name. /// If one is found, returns true and sets the location to that /// expansion loc. bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { SourceLocation loc = locref; if (!loc.isMacroID()) return false; // There's no good way right now to look at the intermediate // expansions, so just jump to the expansion location. loc = getSourceManager().getExpansionLoc(loc); // If that's written with the name, stop here. SmallVector buffer; if (getPreprocessor().getSpelling(loc, buffer) == name) { locref = loc; return true; } return false; } /// \brief Determines the active Scope associated with the given declaration /// context. /// /// This routine maps a declaration context to the active Scope object that /// represents that declaration context in the parser. It is typically used /// from "scope-less" code (e.g., template instantiation, lazy creation of /// declarations) that injects a name for name-lookup purposes and, therefore, /// must update the Scope. /// /// \returns The scope corresponding to the given declaraion context, or NULL /// if no such scope is open. Scope *Sema::getScopeForContext(DeclContext *Ctx) { if (!Ctx) return nullptr; Ctx = Ctx->getPrimaryContext(); for (Scope *S = getCurScope(); S; S = S->getParent()) { // Ignore scopes that cannot have declarations. This is important for // out-of-line definitions of static class members. if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) if (DeclContext *Entity = S->getEntity()) if (Ctx == Entity->getPrimaryContext()) return S; } return nullptr; } /// \brief Enter a new function scope void Sema::PushFunctionScope() { if (FunctionScopes.size() == 1) { // Use the "top" function scope rather than having to allocate // memory for a new scope. FunctionScopes.back()->Clear(); FunctionScopes.push_back(FunctionScopes.back()); return; } FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); } void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), BlockScope, Block)); } LambdaScopeInfo *Sema::PushLambdaScope() { LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); FunctionScopes.push_back(LSI); return LSI; } void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { if (LambdaScopeInfo *const LSI = getCurLambda()) { LSI->AutoTemplateParameterDepth = Depth; return; } llvm_unreachable( "Remove assertion if intentionally called in a non-lambda context."); } void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, const Decl *D, const BlockExpr *blkExpr) { FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); assert(!FunctionScopes.empty() && "mismatched push/pop!"); // Issue any analysis-based warnings. if (WP && D) AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); else for (const auto &PUD : Scope->PossiblyUnreachableDiags) Diag(PUD.Loc, PUD.PD); if (FunctionScopes.back() != Scope) delete Scope; } void Sema::PushCompoundScope() { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); } void Sema::PopCompoundScope() { FunctionScopeInfo *CurFunction = getCurFunction(); assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); CurFunction->CompoundScopes.pop_back(); } /// \brief Determine whether any errors occurred within this function/method/ /// block. bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); } BlockScopeInfo *Sema::getCurBlock() { if (FunctionScopes.empty()) return nullptr; auto CurBSI = dyn_cast(FunctionScopes.back()); if (CurBSI && CurBSI->TheDecl && !CurBSI->TheDecl->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } return CurBSI; } LambdaScopeInfo *Sema::getCurLambda() { if (FunctionScopes.empty()) return nullptr; auto CurLSI = dyn_cast(FunctionScopes.back()); if (CurLSI && CurLSI->Lambda && !CurLSI->Lambda->Encloses(CurContext)) { // We have switched contexts due to template instantiation. assert(!ActiveTemplateInstantiations.empty()); return nullptr; } return CurLSI; } // We have a generic lambda if we parsed auto parameters, or we have // an associated template parameter list. LambdaScopeInfo *Sema::getCurGenericLambda() { if (LambdaScopeInfo *LSI = getCurLambda()) { return (LSI->AutoTemplateParams.size() || LSI->GLTemplateParameterList) ? LSI : nullptr; } return nullptr; } void Sema::ActOnComment(SourceRange Comment) { if (!LangOpts.RetainCommentsFromSystemHeaders && SourceMgr.isInSystemHeader(Comment.getBegin())) return; RawComment RC(SourceMgr, Comment, false, LangOpts.CommentOpts.ParseAllComments); if (RC.isAlmostTrailingComment()) { SourceRange MagicMarkerRange(Comment.getBegin(), Comment.getBegin().getLocWithOffset(3)); StringRef MagicMarkerText; switch (RC.getKind()) { case RawComment::RCK_OrdinaryBCPL: MagicMarkerText = "///<"; break; case RawComment::RCK_OrdinaryC: MagicMarkerText = "/**<"; break; default: llvm_unreachable("if this is an almost Doxygen comment, " "it should be ordinary"); } Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); } Context.addComment(RC); } // Pin this vtable to this file. ExternalSemaSource::~ExternalSemaSource() {} void ExternalSemaSource::ReadMethodPool(Selector Sel) { } void ExternalSemaSource::ReadKnownNamespaces( SmallVectorImpl &Namespaces) { } void ExternalSemaSource::ReadUndefinedButUsed( llvm::DenseMap &Undefined) { } void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { SourceLocation Loc = this->Loc; if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); if (Loc.isValid()) { Loc.print(OS, S.getSourceManager()); OS << ": "; } OS << Message; if (TheDecl && isa(TheDecl)) { std::string Name = cast(TheDecl)->getNameAsString(); if (!Name.empty()) OS << " '" << Name << '\''; } OS << '\n'; } /// \brief Figure out if an expression could be turned into a call. /// /// Use this when trying to recover from an error where the programmer may have /// written just the name of a function instead of actually calling it. /// /// \param E - The expression to examine. /// \param ZeroArgCallReturnTy - If the expression can be turned into a call /// with no arguments, this parameter is set to the type returned by such a /// call; otherwise, it is set to an empty QualType. /// \param OverloadSet - If the expression is an overloaded function /// name, this parameter is populated with the decls of the various overloads. bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &OverloadSet) { ZeroArgCallReturnTy = QualType(); OverloadSet.clear(); const OverloadExpr *Overloads = nullptr; bool IsMemExpr = false; if (E.getType() == Context.OverloadTy) { OverloadExpr::FindResult FR = OverloadExpr::find(const_cast(&E)); // Ignore overloads that are pointer-to-member constants. if (FR.HasFormOfMemberPointer) return false; Overloads = FR.Expression; } else if (E.getType() == Context.BoundMemberTy) { Overloads = dyn_cast(E.IgnoreParens()); IsMemExpr = true; } bool Ambiguous = false; if (Overloads) { for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { OverloadSet.addDecl(*it); // Check whether the function is a non-template, non-member which takes no // arguments. if (IsMemExpr) continue; if (const FunctionDecl *OverloadDecl = dyn_cast((*it)->getUnderlyingDecl())) { if (OverloadDecl->getMinRequiredArguments() == 0) { if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) { ZeroArgCallReturnTy = QualType(); Ambiguous = true; } else ZeroArgCallReturnTy = OverloadDecl->getReturnType(); } } } // If it's not a member, use better machinery to try to resolve the call if (!IsMemExpr) return !ZeroArgCallReturnTy.isNull(); } // Attempt to call the member with no arguments - this will correctly handle // member templates with defaults/deduction of template arguments, overloads // with default arguments, etc. if (IsMemExpr && !E.isTypeDependent()) { bool Suppress = getDiagnostics().getSuppressAllDiagnostics(); getDiagnostics().setSuppressAllDiagnostics(true); ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(), None, SourceLocation()); getDiagnostics().setSuppressAllDiagnostics(Suppress); if (R.isUsable()) { ZeroArgCallReturnTy = R.get()->getType(); return true; } return false; } if (const DeclRefExpr *DeclRef = dyn_cast(E.IgnoreParens())) { if (const FunctionDecl *Fun = dyn_cast(DeclRef->getDecl())) { if (Fun->getMinRequiredArguments() == 0) ZeroArgCallReturnTy = Fun->getReturnType(); return true; } } // We don't have an expression that's convenient to get a FunctionDecl from, // but we can at least check if the type is "function of 0 arguments". QualType ExprTy = E.getType(); const FunctionType *FunTy = nullptr; QualType PointeeTy = ExprTy->getPointeeType(); if (!PointeeTy.isNull()) FunTy = PointeeTy->getAs(); if (!FunTy) FunTy = ExprTy->getAs(); if (const FunctionProtoType *FPT = dyn_cast_or_null(FunTy)) { if (FPT->getNumParams() == 0) ZeroArgCallReturnTy = FunTy->getReturnType(); return true; } return false; } /// \brief Give notes for a set of overloads. /// /// A companion to tryExprAsCall. In cases when the name that the programmer /// wrote was an overloaded function, we may be able to make some guesses about /// plausible overloads based on their return types; such guesses can be handed /// off to this method to be emitted as notes. /// /// \param Overloads - The overloads to note. /// \param FinalNoteLoc - If we've suppressed printing some overloads due to /// -fshow-overloads=best, this is the location to attach to the note about too /// many candidates. Typically this will be the location of the original /// ill-formed expression. static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc) { int ShownOverloads = 0; int SuppressedOverloads = 0; for (UnresolvedSetImpl::iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { // FIXME: Magic number for max shown overloads stolen from // OverloadCandidateSet::NoteCandidates. if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { ++SuppressedOverloads; continue; } NamedDecl *Fn = (*It)->getUnderlyingDecl(); S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); ++ShownOverloads; } if (SuppressedOverloads) S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) << SuppressedOverloads; } static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool (*IsPlausibleResult)(QualType)) { if (!IsPlausibleResult) return noteOverloads(S, Overloads, Loc); UnresolvedSet<2> PlausibleOverloads; for (OverloadExpr::decls_iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { const FunctionDecl *OverloadDecl = cast(*It); QualType OverloadResultTy = OverloadDecl->getReturnType(); if (IsPlausibleResult(OverloadResultTy)) PlausibleOverloads.addDecl(It.getDecl()); } noteOverloads(S, PlausibleOverloads, Loc); } /// Determine whether the given expression can be called by just /// putting parentheses after it. Notably, expressions with unary /// operators can't be because the unary operator will start parsing /// outside the call. static bool IsCallableWithAppend(Expr *E) { E = E->IgnoreImplicit(); return (!isa(E) && !isa(E) && !isa(E) && !isa(E)); } bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain, bool (*IsPlausibleResult)(QualType)) { SourceLocation Loc = E.get()->getExprLoc(); SourceRange Range = E.get()->getSourceRange(); QualType ZeroArgCallTy; UnresolvedSet<4> Overloads; if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && !ZeroArgCallTy.isNull() && (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { // At this point, we know E is potentially callable with 0 // arguments and that it returns something of a reasonable type, // so we can emit a fixit and carry on pretending that E was // actually a CallExpr. SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd()); Diag(Loc, PD) << /*zero-arg*/ 1 << Range << (IsCallableWithAppend(E.get()) ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") : FixItHint()); notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); // FIXME: Try this before emitting the fixit, and suppress diagnostics // while doing so. E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None, Range.getEnd().getLocWithOffset(1)); return true; } if (!ForceComplain) return false; Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); E = ExprError(); return true; } IdentifierInfo *Sema::getSuperIdentifier() const { if (!Ident_super) Ident_super = &Context.Idents.get("super"); return Ident_super; } IdentifierInfo *Sema::getFloat128Identifier() const { if (!Ident___float128) Ident___float128 = &Context.Idents.get("__float128"); return Ident___float128; } void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K) { CapturingScopeInfo *CSI = new CapturedRegionScopeInfo( getDiagnostics(), S, CD, RD, CD->getContextParam(), K); CSI->ReturnType = Context.VoidTy; FunctionScopes.push_back(CSI); } CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { if (FunctionScopes.empty()) return nullptr; return dyn_cast(FunctionScopes.back()); } @ 1.1.1.5.4.1 log @file Sema.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:29 +0000 @ text @d1 1423 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1423 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// // // 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 actions class which performs semantic analysis and // builds an AST out of a parse stream. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTDiagnostic.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CXXFieldCollector.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/ExternalSemaSource.h" #include "clang/Sema/MultiplexExternalSemaSource.h" #include "clang/Sema/ObjCMethodList.h" #include "clang/Sema/PrettyDeclStackTrace.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaConsumer.h" #include "clang/Sema/TemplateDeduction.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/CrashRecoveryContext.h" using namespace clang; using namespace sema; PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, const Preprocessor &PP) { PrintingPolicy Policy = Context.getPrintingPolicy(); Policy.Bool = Context.getLangOpts().Bool; if (!Policy.Bool) { if (const MacroInfo * BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) { Policy.Bool = BoolMacro->isObjectLike() && BoolMacro->getNumTokens() == 1 && BoolMacro->getReplacementToken(0).is(tok::kw__Bool); } } return Policy; } void Sema::ActOnTranslationUnitScope(Scope *S) { TUScope = S; PushDeclContext(S, Context.getTranslationUnitDecl()); VAListTagName = PP.getIdentifierInfo("__va_list_tag"); } Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter) : ExternalSource(0), isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), CollectStats(false), CodeCompleter(CodeCompleter), CurContext(0), OriginalLexicalContext(0), PackContext(0), MSStructPragmaOn(false), MSPointerToMemberRepresentationMethod( LangOpts.getMSPointerToMemberRepresentationMethod()), VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), VisContext(0), IsBuildingRecoveryCallExpr(false), ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0), IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0), NSNumberDecl(0), NSStringDecl(0), StringWithUTF8StringMethod(0), NSArrayDecl(0), ArrayWithObjectsMethod(0), NSDictionaryDecl(0), DictionaryWithObjectsMethod(0), GlobalNewDeleteDeclared(false), TUKind(TUKind), NumSFINAEErrors(0), AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(0), DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), VarDataSharingAttributesStack(0), CurScope(0), Ident_super(0), Ident___float128(0) { TUScope = 0; LoadedExternalKnownNamespaces = false; for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) NSNumberLiteralMethods[I] = 0; if (getLangOpts().ObjC1) NSAPIObj.reset(new NSAPI(Context)); if (getLangOpts().CPlusPlus) FieldCollector.reset(new CXXFieldCollector()); // Tell diagnostics how to render things from the AST library. PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); ExprEvalContexts.push_back( ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, false, 0, false)); FunctionScopes.push_back(new FunctionScopeInfo(Diags)); // Initilization of data sharing attributes stack for OpenMP InitDataSharingAttributesStack(); } void Sema::addImplicitTypedef(StringRef Name, QualType T) { DeclarationName DN = &Context.Idents.get(Name); if (IdResolver.begin(DN) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope); } void Sema::Initialize() { // Tell the AST consumer about this Sema object. Consumer.Initialize(Context); // FIXME: Isn't this redundant with the initialization above? if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->InitializeSema(*this); // Tell the external Sema source about this Sema object. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->InitializeSema(*this); // Initialize predefined 128-bit integer types, if needed. if (PP.getTargetInfo().hasInt128Type()) { // If either of the 128-bit integer types are unavailable to name lookup, // define them now. DeclarationName Int128 = &Context.Idents.get("__int128_t"); if (IdResolver.begin(Int128) == IdResolver.end()) PushOnScopeChains(Context.getInt128Decl(), TUScope); DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); if (IdResolver.begin(UInt128) == IdResolver.end()) PushOnScopeChains(Context.getUInt128Decl(), TUScope); } // Initialize predefined Objective-C types: if (PP.getLangOpts().ObjC1) { // If 'SEL' does not yet refer to any declarations, make it refer to the // predefined 'SEL'. DeclarationName SEL = &Context.Idents.get("SEL"); if (IdResolver.begin(SEL) == IdResolver.end()) PushOnScopeChains(Context.getObjCSelDecl(), TUScope); // If 'id' does not yet refer to any declarations, make it refer to the // predefined 'id'. DeclarationName Id = &Context.Idents.get("id"); if (IdResolver.begin(Id) == IdResolver.end()) PushOnScopeChains(Context.getObjCIdDecl(), TUScope); // Create the built-in typedef for 'Class'. DeclarationName Class = &Context.Idents.get("Class"); if (IdResolver.begin(Class) == IdResolver.end()) PushOnScopeChains(Context.getObjCClassDecl(), TUScope); // Create the built-in forward declaratino for 'Protocol'. DeclarationName Protocol = &Context.Idents.get("Protocol"); if (IdResolver.begin(Protocol) == IdResolver.end()) PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); } // Initialize Microsoft "predefined C++ types". if (PP.getLangOpts().MSVCCompat && PP.getLangOpts().CPlusPlus) { if (IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class), TUScope); addImplicitTypedef("size_t", Context.getSizeType()); } // Initialize predefined OpenCL types. if (PP.getLangOpts().OpenCL) { addImplicitTypedef("image1d_t", Context.OCLImage1dTy); addImplicitTypedef("image1d_array_t", Context.OCLImage1dArrayTy); addImplicitTypedef("image1d_buffer_t", Context.OCLImage1dBufferTy); addImplicitTypedef("image2d_t", Context.OCLImage2dTy); addImplicitTypedef("image2d_array_t", Context.OCLImage2dArrayTy); addImplicitTypedef("image3d_t", Context.OCLImage3dTy); addImplicitTypedef("sampler_t", Context.OCLSamplerTy); addImplicitTypedef("event_t", Context.OCLEventTy); } DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); } Sema::~Sema() { llvm::DeleteContainerSeconds(LateParsedTemplateMap); if (PackContext) FreePackedContext(); if (VisContext) FreeVisContext(); // Kill all the active scopes. for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I) delete FunctionScopes[I]; if (FunctionScopes.size() == 1) delete FunctionScopes[0]; // Tell the SemaConsumer to forget about us; we're going out of scope. if (SemaConsumer *SC = dyn_cast(&Consumer)) SC->ForgetSema(); // Detach from the external Sema source. if (ExternalSemaSource *ExternalSema = dyn_cast_or_null(Context.getExternalSource())) ExternalSema->ForgetSema(); // If Sema's ExternalSource is the multiplexer - we own it. if (isMultiplexExternalSource) delete ExternalSource; // Destroys data sharing attributes stack for OpenMP DestroyDataSharingAttributesStack(); } /// makeUnavailableInSystemHeader - There is an error in the current /// context. If we're still in a system header, and we can plausibly /// make the relevant declaration unavailable instead of erroring, do /// so and return true. bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, StringRef msg) { // If we're not in a function, it's an error. FunctionDecl *fn = dyn_cast(CurContext); if (!fn) return false; // If we're in template instantiation, it's an error. if (!ActiveTemplateInstantiations.empty()) return false; // If that function's not in a system header, it's an error. if (!Context.getSourceManager().isInSystemHeader(loc)) return false; // If the function is already unavailable, it's not an error. if (fn->hasAttr()) return true; fn->addAttr(UnavailableAttr::CreateImplicit(Context, msg, loc)); return true; } ASTMutationListener *Sema::getASTMutationListener() const { return getASTConsumer().GetASTMutationListener(); } ///\brief Registers an external source. If an external source already exists, /// creates a multiplex external source and appends to it. /// ///\param[in] E - A non-null external sema source. /// void Sema::addExternalSource(ExternalSemaSource *E) { assert(E && "Cannot use with NULL ptr"); if (!ExternalSource) { ExternalSource = E; return; } if (isMultiplexExternalSource) static_cast(ExternalSource)->addSource(*E); else { ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E); isMultiplexExternalSource = true; } } /// \brief Print out statistics about the semantic analysis. void Sema::PrintStats() const { llvm::errs() << "\n*** Semantic Analysis Stats:\n"; llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; BumpAlloc.PrintStats(); AnalysisWarnings.PrintStats(); } /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. /// If there is already an implicit cast, merge into the existing one. /// The result is of the given category. ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, CastKind Kind, ExprValueKind VK, const CXXCastPath *BasePath, CheckedConversionKind CCK) { #ifndef NDEBUG if (VK == VK_RValue && !E->isRValue()) { switch (Kind) { default: assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind"); case CK_LValueToRValue: case CK_ArrayToPointerDecay: case CK_FunctionToPointerDecay: case CK_ToVoid: break; } } assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); #endif QualType ExprTy = Context.getCanonicalType(E->getType()); QualType TypeTy = Context.getCanonicalType(Ty); if (ExprTy == TypeTy) return Owned(E); // If this is a derived-to-base cast to a through a virtual base, we // need a vtable. if (Kind == CK_DerivedToBase && BasePathInvolvesVirtualBase(*BasePath)) { QualType T = E->getType(); if (const PointerType *Pointer = T->getAs()) T = Pointer->getPointeeType(); if (const RecordType *RecordTy = T->getAs()) MarkVTableUsed(E->getLocStart(), cast(RecordTy->getDecl())); } if (ImplicitCastExpr *ImpCast = dyn_cast(E)) { if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { ImpCast->setType(Ty); ImpCast->setValueKind(VK); return Owned(E); } } return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK)); } /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding /// to the conversion from scalar type ScalarTy to the Boolean type. CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { switch (ScalarTy->getScalarTypeKind()) { case Type::STK_Bool: return CK_NoOp; case Type::STK_CPointer: return CK_PointerToBoolean; case Type::STK_BlockPointer: return CK_PointerToBoolean; case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; case Type::STK_Integral: return CK_IntegralToBoolean; case Type::STK_Floating: return CK_FloatingToBoolean; case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; } return CK_Invalid; } /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { if (D->getMostRecentDecl()->isUsed()) return true; if (D->isExternallyVisible()) return true; if (const FunctionDecl *FD = dyn_cast(D)) { // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const FunctionDecl *DeclToCheck; if (FD->hasBody(DeclToCheck)) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = FD->getMostRecentDecl(); if (DeclToCheck != FD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } if (const VarDecl *VD = dyn_cast(D)) { // If a variable usable in constant expressions is referenced, // don't warn if it isn't used: if the value of a variable is required // for the computation of a constant expression, it doesn't make sense to // warn even if the variable isn't odr-used. (isReferenced doesn't // precisely reflect that, but it's a decent approximation.) if (VD->isReferenced() && VD->isUsableInConstantExpressions(SemaRef->Context)) return true; // UnusedFileScopedDecls stores the first declaration. // The declaration may have become definition so check again. const VarDecl *DeclToCheck = VD->getDefinition(); if (DeclToCheck) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); // Later redecls may add new information resulting in not having to warn, // so check again. DeclToCheck = VD->getMostRecentDecl(); if (DeclToCheck != VD) return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); } return false; } namespace { struct SortUndefinedButUsed { const SourceManager &SM; explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {} bool operator()(const std::pair &l, const std::pair &r) const { if (l.second.isValid() && !r.second.isValid()) return true; if (!l.second.isValid() && r.second.isValid()) return false; if (l.second != r.second) return SM.isBeforeInTranslationUnit(l.second, r.second); return SM.isBeforeInTranslationUnit(l.first->getLocation(), r.first->getLocation()); } }; } /// Obtains a sorted list of functions that are undefined but ODR-used. void Sema::getUndefinedButUsed( SmallVectorImpl > &Undefined) { for (llvm::DenseMap::iterator I = UndefinedButUsed.begin(), E = UndefinedButUsed.end(); I != E; ++I) { NamedDecl *ND = I->first; // Ignore attributes that have become invalid. if (ND->isInvalidDecl()) continue; // __attribute__((weakref)) is basically a definition. if (ND->hasAttr()) continue; if (FunctionDecl *FD = dyn_cast(ND)) { if (FD->isDefined()) continue; if (FD->isExternallyVisible() && !FD->getMostRecentDecl()->isInlined()) continue; } else { if (cast(ND)->hasDefinition() != VarDecl::DeclarationOnly) continue; if (ND->isExternallyVisible()) continue; } Undefined.push_back(std::make_pair(ND, I->second)); } // Sort (in order of use site) so that we're not dependent on the iteration // order through an llvm::DenseMap. std::sort(Undefined.begin(), Undefined.end(), SortUndefinedButUsed(Context.getSourceManager())); } /// checkUndefinedButUsed - Check for undefined objects with internal linkage /// or that are inline. static void checkUndefinedButUsed(Sema &S) { if (S.UndefinedButUsed.empty()) return; // Collect all the still-undefined entities with internal linkage. SmallVector, 16> Undefined; S.getUndefinedButUsed(Undefined); if (Undefined.empty()) return; for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { NamedDecl *ND = I->first; if (!ND->isExternallyVisible()) { S.Diag(ND->getLocation(), diag::warn_undefined_internal) << isa(ND) << ND; } else { assert(cast(ND)->getMostRecentDecl()->isInlined() && "used object requires definition but isn't inline or internal?"); S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND; } if (I->second.isValid()) S.Diag(I->second, diag::note_used_here); } } void Sema::LoadExternalWeakUndeclaredIdentifiers() { if (!ExternalSource) return; SmallVector, 4> WeakIDs; ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) { llvm::DenseMap::iterator Pos = WeakUndeclaredIdentifiers.find(WeakIDs[I].first); if (Pos != WeakUndeclaredIdentifiers.end()) continue; WeakUndeclaredIdentifiers.insert(WeakIDs[I]); } } typedef llvm::DenseMap RecordCompleteMap; /// \brief Returns true, if all methods and nested classes of the given /// CXXRecordDecl are defined in this translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = MNCComplete.find(RD); if (Cache != MNCComplete.end()) return Cache->second; if (!RD->isCompleteDefinition()) return false; bool Complete = true; for (DeclContext::decl_iterator I = RD->decls_begin(), E = RD->decls_end(); I != E && Complete; ++I) { if (const CXXMethodDecl *M = dyn_cast(*I)) Complete = M->isDefined() || (M->isPure() && !isa(M)); else if (const FunctionTemplateDecl *F = dyn_cast(*I)) Complete = F->getTemplatedDecl()->isDefined(); else if (const CXXRecordDecl *R = dyn_cast(*I)) { if (R->isInjectedClassName()) continue; if (R->hasDefinition()) Complete = MethodsAndNestedClassesComplete(R->getDefinition(), MNCComplete); else Complete = false; } } MNCComplete[RD] = Complete; return Complete; } /// \brief Returns true, if the given CXXRecordDecl is fully defined in this /// translation unit, i.e. all methods are defined or pure virtual and all /// friends, friend functions and nested classes are fully defined in this /// translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all /// definitions are actually read. static bool IsRecordFullyDefined(const CXXRecordDecl *RD, RecordCompleteMap &RecordsComplete, RecordCompleteMap &MNCComplete) { RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); if (Cache != RecordsComplete.end()) return Cache->second; bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), E = RD->friend_end(); I != E && Complete; ++I) { // Check if friend classes and methods are complete. if (TypeSourceInfo *TSI = (*I)->getFriendType()) { // Friend classes are available as the TypeSourceInfo of the FriendDecl. if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); else Complete = false; } else { // Friend functions are available through the NamedDecl of FriendDecl. if (const FunctionDecl *FD = dyn_cast((*I)->getFriendDecl())) Complete = FD->isDefined(); else // This is a template friend, give up. Complete = false; } } RecordsComplete[RD] = Complete; return Complete; } /// ActOnEndOfTranslationUnit - This is called at the very end of the /// translation unit when EOF is reached and all but the top-level scope is /// popped. void Sema::ActOnEndOfTranslationUnit() { assert(DelayedDiagnostics.getCurrentPool() == NULL && "reached end of translation unit with a pool attached?"); // If code completion is enabled, don't perform any end-of-translation-unit // work. if (PP.isCodeCompletionEnabled()) return; // Complete translation units and modules define vtables and perform implicit // instantiations. PCH files do not. if (TUKind != TU_Prefix) { DiagnoseUseOfUnimplementedSelectors(); // If any dynamic classes have their key function defined within // this translation unit, then those vtables are considered "used" and must // be emitted. for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource), E = DynamicClasses.end(); I != E; ++I) { assert(!(*I)->isDependentType() && "Should not see dependent types here!"); if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { const FunctionDecl *Definition = 0; if (KeyFunction->hasBody(Definition)) MarkVTableUsed(Definition->getLocation(), *I, true); } } // If DefinedUsedVTables ends up marking any virtual member functions it // might lead to more pending template instantiations, which we then need // to instantiate. DefineUsedVTables(); // C++: Perform implicit template instantiations. // // FIXME: When we perform these implicit instantiations, we do not // carefully keep track of the point of instantiation (C++ [temp.point]). // This means that name lookup that occurs within the template // instantiation will always happen at the end of the translation unit, // so it will find some names that are not required to be found. This is // valid, but we could do better by diagnosing if an instantiation uses a // name that was not visible at its first point of instantiation. PerformPendingInstantiations(); CheckDelayedMemberExceptionSpecs(); } // All delayed member exception specs should be checked or we end up accepting // incompatible declarations. assert(DelayedDefaultedMemberExceptionSpecs.empty()); assert(DelayedDestructorExceptionSpecChecks.empty()); // Remove file scoped decls that turned out to be used. UnusedFileScopedDecls.erase( std::remove_if(UnusedFileScopedDecls.begin(0, true), UnusedFileScopedDecls.end(), std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)), UnusedFileScopedDecls.end()); if (TUKind == TU_Prefix) { // Translation unit prefixes don't need any of the checking below. TUScope = 0; return; } // Check for #pragma weak identifiers that were never declared // FIXME: This will cause diagnostics to be emitted in a non-determinstic // order! Iterating over a densemap like this is bad. LoadExternalWeakUndeclaredIdentifiers(); for (llvm::DenseMap::iterator I = WeakUndeclaredIdentifiers.begin(), E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { if (I->second.getUsed()) continue; Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) << I->first; } if (LangOpts.CPlusPlus11 && Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle, SourceLocation()) != DiagnosticsEngine::Ignored) CheckDelegatingCtorCycles(); if (TUKind == TU_Module) { // If we are building a module, resolve all of the exported declarations // now. if (Module *CurrentModule = PP.getCurrentModule()) { ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); SmallVector Stack; Stack.push_back(CurrentModule); while (!Stack.empty()) { Module *Mod = Stack.pop_back_val(); // Resolve the exported declarations and conflicts. // FIXME: Actually complain, once we figure out how to teach the // diagnostic client to deal with complaints in the module map at this // point. ModMap.resolveExports(Mod, /*Complain=*/false); ModMap.resolveUses(Mod, /*Complain=*/false); ModMap.resolveConflicts(Mod, /*Complain=*/false); // Queue the submodules, so their exports will also be resolved. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) { Stack.push_back(*Sub); } } } // Modules don't need any of the checking below. TUScope = 0; return; } // C99 6.9.2p2: // A declaration of an identifier for an object that has file // scope without an initializer, and without a storage-class // specifier or with the storage-class specifier static, // constitutes a tentative definition. If a translation unit // contains one or more tentative definitions for an identifier, // and the translation unit contains no external definition for // that identifier, then the behavior is exactly as if the // translation unit contains a file scope declaration of that // identifier, with the composite type as of the end of the // translation unit, with an initializer equal to 0. llvm::SmallSet Seen; for (TentativeDefinitionsType::iterator T = TentativeDefinitions.begin(ExternalSource), TEnd = TentativeDefinitions.end(); T != TEnd; ++T) { VarDecl *VD = (*T)->getActingDefinition(); // If the tentative definition was completed, getActingDefinition() returns // null. If we've already seen this variable before, insert()'s second // return value is false. if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) continue; if (const IncompleteArrayType *ArrayT = Context.getAsIncompleteArrayType(VD->getType())) { // Set the length of the array to 1 (C99 6.9.2p5). Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One, ArrayType::Normal, 0); VD->setType(T); } else if (RequireCompleteType(VD->getLocation(), VD->getType(), diag::err_tentative_def_incomplete_type)) VD->setInvalidDecl(); CheckCompleteVariableDeclaration(VD); // Notify the consumer that we've completed a tentative definition. if (!VD->isInvalidDecl()) Consumer.CompleteTentativeDefinition(VD); } // If there were errors, disable 'unused' warnings since they will mostly be // noise. if (!Diags.hasErrorOccurred()) { // Output warning for unused file scoped decls. for (UnusedFileScopedDeclsType::iterator I = UnusedFileScopedDecls.begin(ExternalSource), E = UnusedFileScopedDecls.end(); I != E; ++I) { if (ShouldRemoveFromUnused(this, *I)) continue; if (const FunctionDecl *FD = dyn_cast(*I)) { const FunctionDecl *DiagD; if (!FD->hasBody(DiagD)) DiagD = FD; if (DiagD->isDeleted()) continue; // Deleted functions are supposed to be unused. if (DiagD->isReferenced()) { if (isa(DiagD)) Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) << DiagD->getDeclName(); else { if (FD->getStorageClass() == SC_Static && !FD->isInlineSpecified() && !SourceMgr.isInMainFile( SourceMgr.getExpansionLoc(FD->getLocation()))) Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) << DiagD->getDeclName(); else Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*function*/0 << DiagD->getDeclName(); } } else { Diag(DiagD->getLocation(), isa(DiagD) ? diag::warn_unused_member_function : diag::warn_unused_function) << DiagD->getDeclName(); } } else { const VarDecl *DiagD = cast(*I)->getDefinition(); if (!DiagD) DiagD = cast(*I); if (DiagD->isReferenced()) { Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) << /*variable*/1 << DiagD->getDeclName(); } else if (DiagD->getType().isConstQualified()) { Diag(DiagD->getLocation(), diag::warn_unused_const_variable) << DiagD->getDeclName(); } else { Diag(DiagD->getLocation(), diag::warn_unused_variable) << DiagD->getDeclName(); } } } if (ExternalSource) ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); checkUndefinedButUsed(*this); } if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, SourceLocation()) != DiagnosticsEngine::Ignored) { RecordCompleteMap RecordsComplete; RecordCompleteMap MNCComplete; for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), E = UnusedPrivateFields.end(); I != E; ++I) { const NamedDecl *D = *I; const CXXRecordDecl *RD = dyn_cast(D->getDeclContext()); if (RD && !RD->isUnion() && IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { Diag(D->getLocation(), diag::warn_unused_private_field) << D->getDeclName(); } } } // Check we've noticed that we're no longer parsing the initializer for every // variable. If we miss cases, then at best we have a performance issue and // at worst a rejects-valid bug. assert(ParsingInitForAutoVars.empty() && "Didn't unmark var as having its initializer parsed"); TUScope = 0; } //===----------------------------------------------------------------------===// // Helper functions. //===----------------------------------------------------------------------===// DeclContext *Sema::getFunctionLevelDeclContext() { DeclContext *DC = CurContext; while (true) { if (isa(DC) || isa(DC) || isa(DC)) { DC = DC->getParent(); } else if (isa(DC) && cast(DC)->getOverloadedOperator() == OO_Call && cast(DC->getParent())->isLambda()) { DC = DC->getParent()->getParent(); } else break; } return DC; } /// getCurFunctionDecl - If inside of a function body, this returns a pointer /// to the function decl for the function being parsed. If we're currently /// in a 'block', this returns the containing context. FunctionDecl *Sema::getCurFunctionDecl() { DeclContext *DC = getFunctionLevelDeclContext(); return dyn_cast(DC); } ObjCMethodDecl *Sema::getCurMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); while (isa(DC)) DC = DC->getParent(); return dyn_cast(DC); } NamedDecl *Sema::getCurFunctionOrMethodDecl() { DeclContext *DC = getFunctionLevelDeclContext(); if (isa(DC) || isa(DC)) return cast(DC); return 0; } void Sema::EmitCurrentDiagnostic(unsigned DiagID) { // FIXME: It doesn't make sense to me that DiagID is an incoming argument here // and yet we also use the current diag ID on the DiagnosticsEngine. This has // been made more painfully obvious by the refactor that introduced this // function, but it is possible that the incoming argument can be // eliminnated. If it truly cannot be (for example, there is some reentrancy // issue I am not seeing yet), then there should at least be a clarifying // comment somewhere. if (Optional Info = isSFINAEContext()) { switch (DiagnosticIDs::getDiagnosticSFINAEResponse( Diags.getCurrentDiagID())) { case DiagnosticIDs::SFINAE_Report: // We'll report the diagnostic below. break; case DiagnosticIDs::SFINAE_SubstitutionFailure: // Count this failure so that we know that template argument deduction // has failed. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; case DiagnosticIDs::SFINAE_AccessControl: { // Per C++ Core Issue 1170, access control is part of SFINAE. // Additionally, the AccessCheckingSFINAE flag can be used to temporarily // make access control a part of SFINAE for the purposes of checking // type traits. if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) break; SourceLocation Loc = Diags.getCurrentDiagLoc(); // Suppress this diagnostic. ++NumSFINAEErrors; // Make a copy of this suppressed diagnostic and store it with the // template-deduction information. if (*Info && !(*Info)->hasSFINAEDiagnostic()) { Diagnostic DiagInfo(&Diags); (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } Diags.setLastDiagnosticIgnored(); Diags.Clear(); // Now the diagnostic state is clear, produce a C++98 compatibility // warning. Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); // The last diagnostic which Sema produced was ignored. Suppress any // notes attached to it. Diags.setLastDiagnosticIgnored(); return; } case DiagnosticIDs::SFINAE_Suppress: // Make a copy of this suppressed diagnostic and store it with the // template-deduction information; if (*Info) { Diagnostic DiagInfo(&Diags); (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); } // Suppress this diagnostic. Diags.setLastDiagnosticIgnored(); Diags.Clear(); return; } } // Set up the context's printing policy based on our current state. Context.setPrintingPolicy(getPrintingPolicy()); // Emit the diagnostic. if (!Diags.EmitCurrentDiagnostic()) return; // If this is not a note, and we're in a template instantiation // that is different from the last template instantiation where // we emitted an error, print a template instantiation // backtrace. if (!DiagnosticIDs::isBuiltinNote(DiagID) && !ActiveTemplateInstantiations.empty() && ActiveTemplateInstantiations.back() != LastTemplateInstantiationErrorContext) { PrintInstantiationStack(); LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); } } Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); PD.Emit(Builder); return Builder; } /// \brief Looks through the macro-expansion chain for the given /// location, looking for a macro expansion with the given name. /// If one is found, returns true and sets the location to that /// expansion loc. bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { SourceLocation loc = locref; if (!loc.isMacroID()) return false; // There's no good way right now to look at the intermediate // expansions, so just jump to the expansion location. loc = getSourceManager().getExpansionLoc(loc); // If that's written with the name, stop here. SmallVector buffer; if (getPreprocessor().getSpelling(loc, buffer) == name) { locref = loc; return true; } return false; } /// \brief Determines the active Scope associated with the given declaration /// context. /// /// This routine maps a declaration context to the active Scope object that /// represents that declaration context in the parser. It is typically used /// from "scope-less" code (e.g., template instantiation, lazy creation of /// declarations) that injects a name for name-lookup purposes and, therefore, /// must update the Scope. /// /// \returns The scope corresponding to the given declaraion context, or NULL /// if no such scope is open. Scope *Sema::getScopeForContext(DeclContext *Ctx) { if (!Ctx) return 0; Ctx = Ctx->getPrimaryContext(); for (Scope *S = getCurScope(); S; S = S->getParent()) { // Ignore scopes that cannot have declarations. This is important for // out-of-line definitions of static class members. if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) if (DeclContext *Entity = S->getEntity()) if (Ctx == Entity->getPrimaryContext()) return S; } return 0; } /// \brief Enter a new function scope void Sema::PushFunctionScope() { if (FunctionScopes.size() == 1) { // Use the "top" function scope rather than having to allocate // memory for a new scope. FunctionScopes.back()->Clear(); FunctionScopes.push_back(FunctionScopes.back()); return; } FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); } void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), BlockScope, Block)); } LambdaScopeInfo *Sema::PushLambdaScope() { LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); FunctionScopes.push_back(LSI); return LSI; } void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { if (LambdaScopeInfo *const LSI = getCurLambda()) { LSI->AutoTemplateParameterDepth = Depth; return; } llvm_unreachable( "Remove assertion if intentionally called in a non-lambda context."); } void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, const Decl *D, const BlockExpr *blkExpr) { FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); assert(!FunctionScopes.empty() && "mismatched push/pop!"); // Issue any analysis-based warnings. if (WP && D) AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); else { for (SmallVectorImpl::iterator i = Scope->PossiblyUnreachableDiags.begin(), e = Scope->PossiblyUnreachableDiags.end(); i != e; ++i) { const sema::PossiblyUnreachableDiag &D = *i; Diag(D.Loc, D.PD); } } if (FunctionScopes.back() != Scope) { delete Scope; } } void Sema::PushCompoundScope() { getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); } void Sema::PopCompoundScope() { FunctionScopeInfo *CurFunction = getCurFunction(); assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); CurFunction->CompoundScopes.pop_back(); } /// \brief Determine whether any errors occurred within this function/method/ /// block. bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); } BlockScopeInfo *Sema::getCurBlock() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } LambdaScopeInfo *Sema::getCurLambda() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } // We have a generic lambda if we parsed auto parameters, or we have // an associated template parameter list. LambdaScopeInfo *Sema::getCurGenericLambda() { if (LambdaScopeInfo *LSI = getCurLambda()) { return (LSI->AutoTemplateParams.size() || LSI->GLTemplateParameterList) ? LSI : 0; } return 0; } void Sema::ActOnComment(SourceRange Comment) { if (!LangOpts.RetainCommentsFromSystemHeaders && SourceMgr.isInSystemHeader(Comment.getBegin())) return; RawComment RC(SourceMgr, Comment, false, LangOpts.CommentOpts.ParseAllComments); if (RC.isAlmostTrailingComment()) { SourceRange MagicMarkerRange(Comment.getBegin(), Comment.getBegin().getLocWithOffset(3)); StringRef MagicMarkerText; switch (RC.getKind()) { case RawComment::RCK_OrdinaryBCPL: MagicMarkerText = "///<"; break; case RawComment::RCK_OrdinaryC: MagicMarkerText = "/**<"; break; default: llvm_unreachable("if this is an almost Doxygen comment, " "it should be ordinary"); } Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); } Context.addComment(RC); } // Pin this vtable to this file. ExternalSemaSource::~ExternalSemaSource() {} void ExternalSemaSource::ReadMethodPool(Selector Sel) { } void ExternalSemaSource::ReadKnownNamespaces( SmallVectorImpl &Namespaces) { } void ExternalSemaSource::ReadUndefinedButUsed( llvm::DenseMap &Undefined) { } void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { SourceLocation Loc = this->Loc; if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); if (Loc.isValid()) { Loc.print(OS, S.getSourceManager()); OS << ": "; } OS << Message; if (TheDecl && isa(TheDecl)) { std::string Name = cast(TheDecl)->getNameAsString(); if (!Name.empty()) OS << " '" << Name << '\''; } OS << '\n'; } /// \brief Figure out if an expression could be turned into a call. /// /// Use this when trying to recover from an error where the programmer may have /// written just the name of a function instead of actually calling it. /// /// \param E - The expression to examine. /// \param ZeroArgCallReturnTy - If the expression can be turned into a call /// with no arguments, this parameter is set to the type returned by such a /// call; otherwise, it is set to an empty QualType. /// \param OverloadSet - If the expression is an overloaded function /// name, this parameter is populated with the decls of the various overloads. bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &OverloadSet) { ZeroArgCallReturnTy = QualType(); OverloadSet.clear(); const OverloadExpr *Overloads = NULL; bool IsMemExpr = false; if (E.getType() == Context.OverloadTy) { OverloadExpr::FindResult FR = OverloadExpr::find(const_cast(&E)); // Ignore overloads that are pointer-to-member constants. if (FR.HasFormOfMemberPointer) return false; Overloads = FR.Expression; } else if (E.getType() == Context.BoundMemberTy) { Overloads = dyn_cast(E.IgnoreParens()); IsMemExpr = true; } bool Ambiguous = false; if (Overloads) { for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { OverloadSet.addDecl(*it); // Check whether the function is a non-template, non-member which takes no // arguments. if (IsMemExpr) continue; if (const FunctionDecl *OverloadDecl = dyn_cast((*it)->getUnderlyingDecl())) { if (OverloadDecl->getMinRequiredArguments() == 0) { if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) { ZeroArgCallReturnTy = QualType(); Ambiguous = true; } else ZeroArgCallReturnTy = OverloadDecl->getReturnType(); } } } // If it's not a member, use better machinery to try to resolve the call if (!IsMemExpr) return !ZeroArgCallReturnTy.isNull(); } // Attempt to call the member with no arguments - this will correctly handle // member templates with defaults/deduction of template arguments, overloads // with default arguments, etc. if (IsMemExpr && !E.isTypeDependent()) { bool Suppress = getDiagnostics().getSuppressAllDiagnostics(); getDiagnostics().setSuppressAllDiagnostics(true); ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None, SourceLocation()); getDiagnostics().setSuppressAllDiagnostics(Suppress); if (R.isUsable()) { ZeroArgCallReturnTy = R.get()->getType(); return true; } return false; } if (const DeclRefExpr *DeclRef = dyn_cast(E.IgnoreParens())) { if (const FunctionDecl *Fun = dyn_cast(DeclRef->getDecl())) { if (Fun->getMinRequiredArguments() == 0) ZeroArgCallReturnTy = Fun->getReturnType(); return true; } } // We don't have an expression that's convenient to get a FunctionDecl from, // but we can at least check if the type is "function of 0 arguments". QualType ExprTy = E.getType(); const FunctionType *FunTy = NULL; QualType PointeeTy = ExprTy->getPointeeType(); if (!PointeeTy.isNull()) FunTy = PointeeTy->getAs(); if (!FunTy) FunTy = ExprTy->getAs(); if (const FunctionProtoType *FPT = dyn_cast_or_null(FunTy)) { if (FPT->getNumParams() == 0) ZeroArgCallReturnTy = FunTy->getReturnType(); return true; } return false; } /// \brief Give notes for a set of overloads. /// /// A companion to tryExprAsCall. In cases when the name that the programmer /// wrote was an overloaded function, we may be able to make some guesses about /// plausible overloads based on their return types; such guesses can be handed /// off to this method to be emitted as notes. /// /// \param Overloads - The overloads to note. /// \param FinalNoteLoc - If we've suppressed printing some overloads due to /// -fshow-overloads=best, this is the location to attach to the note about too /// many candidates. Typically this will be the location of the original /// ill-formed expression. static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc) { int ShownOverloads = 0; int SuppressedOverloads = 0; for (UnresolvedSetImpl::iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { // FIXME: Magic number for max shown overloads stolen from // OverloadCandidateSet::NoteCandidates. if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { ++SuppressedOverloads; continue; } NamedDecl *Fn = (*It)->getUnderlyingDecl(); S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); ++ShownOverloads; } if (SuppressedOverloads) S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) << SuppressedOverloads; } static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool (*IsPlausibleResult)(QualType)) { if (!IsPlausibleResult) return noteOverloads(S, Overloads, Loc); UnresolvedSet<2> PlausibleOverloads; for (OverloadExpr::decls_iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { const FunctionDecl *OverloadDecl = cast(*It); QualType OverloadResultTy = OverloadDecl->getReturnType(); if (IsPlausibleResult(OverloadResultTy)) PlausibleOverloads.addDecl(It.getDecl()); } noteOverloads(S, PlausibleOverloads, Loc); } /// Determine whether the given expression can be called by just /// putting parentheses after it. Notably, expressions with unary /// operators can't be because the unary operator will start parsing /// outside the call. static bool IsCallableWithAppend(Expr *E) { E = E->IgnoreImplicit(); return (!isa(E) && !isa(E) && !isa(E) && !isa(E)); } bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain, bool (*IsPlausibleResult)(QualType)) { SourceLocation Loc = E.get()->getExprLoc(); SourceRange Range = E.get()->getSourceRange(); QualType ZeroArgCallTy; UnresolvedSet<4> Overloads; if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && !ZeroArgCallTy.isNull() && (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { // At this point, we know E is potentially callable with 0 // arguments and that it returns something of a reasonable type, // so we can emit a fixit and carry on pretending that E was // actually a CallExpr. SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd()); Diag(Loc, PD) << /*zero-arg*/ 1 << Range << (IsCallableWithAppend(E.get()) ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") : FixItHint()); notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); // FIXME: Try this before emitting the fixit, and suppress diagnostics // while doing so. E = ActOnCallExpr(0, E.take(), Range.getEnd(), None, Range.getEnd().getLocWithOffset(1)); return true; } if (!ForceComplain) return false; Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); E = ExprError(); return true; } IdentifierInfo *Sema::getSuperIdentifier() const { if (!Ident_super) Ident_super = &Context.Idents.get("super"); return Ident_super; } IdentifierInfo *Sema::getFloat128Identifier() const { if (!Ident___float128) Ident___float128 = &Context.Idents.get("__float128"); return Ident___float128; } void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K) { CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD, CD->getContextParam(), K); CSI->ReturnType = Context.VoidTy; FunctionScopes.push_back(CSI); } CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { if (FunctionScopes.empty()) return 0; return dyn_cast(FunctionScopes.back()); } @