Chris Lattner | ddd6fc8 | 2006-11-10 04:58:55 +0000 | [diff] [blame] | 1 | //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// |
Chris Lattner | 3e7bd4e | 2006-08-17 05:51:27 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 5b12ab8 | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | 3e7bd4e | 2006-08-17 05:51:27 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Chris Lattner | ddd6fc8 | 2006-11-10 04:58:55 +0000 | [diff] [blame] | 10 | // This file implements the actions class which performs semantic analysis and |
| 11 | // builds an AST out of a parse stream. |
Chris Lattner | 3e7bd4e | 2006-08-17 05:51:27 +0000 | [diff] [blame] | 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
John McCall | b45a1e7 | 2010-08-26 02:13:20 +0000 | [diff] [blame] | 15 | #include "clang/Sema/SemaInternal.h" |
Chris Lattner | cb6a382 | 2006-11-10 06:20:45 +0000 | [diff] [blame] | 16 | #include "clang/AST/ASTContext.h" |
Douglas Gregor | 639cccc | 2010-02-09 22:26:47 +0000 | [diff] [blame] | 17 | #include "clang/AST/ASTDiagnostic.h" |
John McCall | 28a0cf7 | 2010-08-25 07:42:41 +0000 | [diff] [blame] | 18 | #include "clang/AST/DeclCXX.h" |
Daniel Jasper | 0baec549 | 2012-06-06 08:32:04 +0000 | [diff] [blame] | 19 | #include "clang/AST/DeclFriend.h" |
Daniel Dunbar | 6e8aa53 | 2008-08-11 05:35:13 +0000 | [diff] [blame] | 20 | #include "clang/AST/DeclObjC.h" |
Daniel Dunbar | 221fa94 | 2008-08-11 04:54:23 +0000 | [diff] [blame] | 21 | #include "clang/AST/Expr.h" |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 22 | #include "clang/AST/ExprCXX.h" |
Chris Lattner | c8e630e | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 23 | #include "clang/AST/StmtCXX.h" |
Douglas Gregor | 75644d5 | 2011-09-20 18:13:03 +0000 | [diff] [blame] | 24 | #include "clang/Basic/FileManager.h" |
Anders Carlsson | f68079e | 2009-08-26 22:33:56 +0000 | [diff] [blame] | 25 | #include "clang/Basic/PartialDiagnostic.h" |
Chris Lattner | 7d4f5c4 | 2009-04-30 06:18:40 +0000 | [diff] [blame] | 26 | #include "clang/Basic/TargetInfo.h" |
Chandler Carruth | 3a02247 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 27 | #include "clang/Lex/HeaderSearch.h" |
| 28 | #include "clang/Lex/Preprocessor.h" |
| 29 | #include "clang/Sema/CXXFieldCollector.h" |
| 30 | #include "clang/Sema/DelayedDiagnostic.h" |
| 31 | #include "clang/Sema/ExternalSemaSource.h" |
| 32 | #include "clang/Sema/MultiplexExternalSemaSource.h" |
| 33 | #include "clang/Sema/ObjCMethodList.h" |
| 34 | #include "clang/Sema/PrettyDeclStackTrace.h" |
| 35 | #include "clang/Sema/Scope.h" |
| 36 | #include "clang/Sema/ScopeInfo.h" |
| 37 | #include "clang/Sema/SemaConsumer.h" |
| 38 | #include "clang/Sema/TemplateDeduction.h" |
| 39 | #include "llvm/ADT/APFloat.h" |
| 40 | #include "llvm/ADT/DenseMap.h" |
| 41 | #include "llvm/ADT/SmallSet.h" |
| 42 | #include "llvm/Support/CrashRecoveryContext.h" |
Chris Lattner | c11438c | 2006-08-18 05:17:52 +0000 | [diff] [blame] | 43 | using namespace clang; |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 44 | using namespace sema; |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 45 | |
Argyrios Kyrtzidis | 8d05ca7 | 2012-01-17 02:15:51 +0000 | [diff] [blame] | 46 | PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, |
| 47 | const Preprocessor &PP) { |
Douglas Gregor | 75acd92 | 2011-09-27 23:30:47 +0000 | [diff] [blame] | 48 | PrintingPolicy Policy = Context.getPrintingPolicy(); |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 49 | Policy.Bool = Context.getLangOpts().Bool; |
Douglas Gregor | 75acd92 | 2011-09-27 23:30:47 +0000 | [diff] [blame] | 50 | if (!Policy.Bool) { |
Argyrios Kyrtzidis | 09c9e81 | 2013-02-20 00:54:57 +0000 | [diff] [blame] | 51 | if (const MacroInfo * |
| 52 | BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) { |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 53 | Policy.Bool = BoolMacro->isObjectLike() && |
Douglas Gregor | 75acd92 | 2011-09-27 23:30:47 +0000 | [diff] [blame] | 54 | BoolMacro->getNumTokens() == 1 && |
| 55 | BoolMacro->getReplacementToken(0).is(tok::kw__Bool); |
| 56 | } |
| 57 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 58 | |
Douglas Gregor | 75acd92 | 2011-09-27 23:30:47 +0000 | [diff] [blame] | 59 | return Policy; |
| 60 | } |
| 61 | |
Douglas Gregor | f11096c | 2010-08-25 18:07:12 +0000 | [diff] [blame] | 62 | void Sema::ActOnTranslationUnitScope(Scope *S) { |
Steve Naroff | c62adb6 | 2007-10-09 22:01:59 +0000 | [diff] [blame] | 63 | TUScope = S; |
Douglas Gregor | 91f8421 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 64 | PushDeclContext(S, Context.getTranslationUnitDecl()); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 65 | |
John McCall | f24d7bb | 2010-05-28 18:45:08 +0000 | [diff] [blame] | 66 | VAListTagName = PP.getIdentifierInfo("__va_list_tag"); |
Steve Naroff | 7f549f1 | 2007-10-10 21:53:07 +0000 | [diff] [blame] | 67 | } |
| 68 | |
Douglas Gregor | 54feb84 | 2009-04-14 16:27:31 +0000 | [diff] [blame] | 69 | Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, |
Douglas Gregor | 69f74f8 | 2011-08-25 22:30:56 +0000 | [diff] [blame] | 70 | TranslationUnitKind TUKind, |
Daniel Dunbar | 242ea9a | 2009-11-13 08:58:20 +0000 | [diff] [blame] | 71 | CodeCompleteConsumer *CodeCompleter) |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 72 | : ExternalSource(0), |
Axel Naumann | dd433f0 | 2012-10-18 19:05:02 +0000 | [diff] [blame] | 73 | isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()), |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 74 | LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 75 | Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), |
Axel Naumann | dd433f0 | 2012-10-18 19:05:02 +0000 | [diff] [blame] | 76 | CollectStats(false), CodeCompleter(CodeCompleter), |
Argyrios Kyrtzidis | 9321ad3 | 2011-10-06 23:23:20 +0000 | [diff] [blame] | 77 | CurContext(0), OriginalLexicalContext(0), |
David Majnemer | 4bb0980 | 2014-02-10 19:50:15 +0000 | [diff] [blame] | 78 | PackContext(0), MSStructPragmaOn(false), |
David Majnemer | 86c318f | 2014-02-11 21:05:00 +0000 | [diff] [blame] | 79 | MSPointerToMemberRepresentationMethod( |
Reid Kleckner | c0dca6d | 2014-02-12 23:50:26 +0000 | [diff] [blame] | 80 | LangOpts.getMSPointerToMemberRepresentationMethod()), |
| 81 | VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), |
David Majnemer | 86c318f | 2014-02-11 21:05:00 +0000 | [diff] [blame] | 82 | VisContext(0), |
Richard Smith | 88d67f3 | 2012-09-25 04:46:05 +0000 | [diff] [blame] | 83 | IsBuildingRecoveryCallExpr(false), |
John McCall | 28fc709 | 2011-11-10 05:35:25 +0000 | [diff] [blame] | 84 | ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0), |
Sebastian Redl | 2bfa104 | 2012-01-17 22:49:33 +0000 | [diff] [blame] | 85 | IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0), |
Benjamin Kramer | e499345 | 2012-04-22 20:43:35 +0000 | [diff] [blame] | 86 | NSNumberDecl(0), |
| 87 | NSStringDecl(0), StringWithUTF8StringMethod(0), |
| 88 | NSArrayDecl(0), ArrayWithObjectsMethod(0), |
Ted Kremenek | e65b086 | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 89 | NSDictionaryDecl(0), DictionaryWithObjectsMethod(0), |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 90 | GlobalNewDeleteDeclared(false), |
Douglas Gregor | 69f74f8 | 2011-08-25 22:30:56 +0000 | [diff] [blame] | 91 | TUKind(TUKind), |
Peter Collingbourne | dec2c86 | 2014-02-24 20:45:14 +0000 | [diff] [blame] | 92 | NumSFINAEErrors(0), |
Douglas Gregor | edb7685 | 2011-01-27 22:31:44 +0000 | [diff] [blame] | 93 | AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), |
Douglas Gregor | 840bd6c | 2010-12-20 22:05:00 +0000 | [diff] [blame] | 94 | NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), |
Richard Smith | 1fff95c | 2013-09-12 23:28:08 +0000 | [diff] [blame] | 95 | CurrentInstantiationScope(0), DisableTypoCorrection(false), |
| 96 | TyposCorrected(0), AnalysisWarnings(*this), |
| 97 | VarDataSharingAttributesStack(0), CurScope(0), |
Alexey Bataev | 758e55e | 2013-09-06 18:03:48 +0000 | [diff] [blame] | 98 | Ident_super(0), Ident___float128(0) |
Douglas Gregor | 84d49a2 | 2009-11-11 21:54:23 +0000 | [diff] [blame] | 99 | { |
Steve Naroff | 7f549f1 | 2007-10-10 21:53:07 +0000 | [diff] [blame] | 100 | TUScope = 0; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 101 | |
Douglas Gregor | c2fa169 | 2011-06-28 16:20:02 +0000 | [diff] [blame] | 102 | LoadedExternalKnownNamespaces = false; |
Ted Kremenek | e65b086 | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 103 | for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) |
| 104 | NSNumberLiteralMethods[I] = 0; |
| 105 | |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 106 | if (getLangOpts().ObjC1) |
Ted Kremenek | e65b086 | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 107 | NSAPIObj.reset(new NSAPI(Context)); |
| 108 | |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 109 | if (getLangOpts().CPlusPlus) |
Argyrios Kyrtzidis | ed98342 | 2008-07-01 10:37:29 +0000 | [diff] [blame] | 110 | FieldCollector.reset(new CXXFieldCollector()); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 111 | |
Chris Lattner | 6a2ed6f | 2008-11-23 09:13:29 +0000 | [diff] [blame] | 112 | // Tell diagnostics how to render things from the AST library. |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 113 | PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, |
Douglas Gregor | 639cccc | 2010-02-09 22:26:47 +0000 | [diff] [blame] | 114 | &Context); |
Douglas Gregor | ff790f1 | 2009-11-26 00:44:06 +0000 | [diff] [blame] | 115 | |
| 116 | ExprEvalContexts.push_back( |
Richard Smith | fd555f6 | 2012-02-22 02:04:18 +0000 | [diff] [blame] | 117 | ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, |
| 118 | false, 0, false)); |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 119 | |
Argyrios Kyrtzidis | f51ec1d | 2010-11-19 00:19:15 +0000 | [diff] [blame] | 120 | FunctionScopes.push_back(new FunctionScopeInfo(Diags)); |
Alexey Bataev | 758e55e | 2013-09-06 18:03:48 +0000 | [diff] [blame] | 121 | |
| 122 | // Initilization of data sharing attributes stack for OpenMP |
| 123 | InitDataSharingAttributesStack(); |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 124 | } |
| 125 | |
Alp Toker | f22856a | 2013-12-18 15:29:05 +0000 | [diff] [blame] | 126 | void Sema::addImplicitTypedef(StringRef Name, QualType T) { |
| 127 | DeclarationName DN = &Context.Idents.get(Name); |
| 128 | if (IdResolver.begin(DN) == IdResolver.end()) |
| 129 | PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope); |
| 130 | } |
| 131 | |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 132 | void Sema::Initialize() { |
| 133 | // Tell the AST consumer about this Sema object. |
| 134 | Consumer.Initialize(Context); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 135 | |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 136 | // FIXME: Isn't this redundant with the initialization above? |
| 137 | if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) |
| 138 | SC->InitializeSema(*this); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 139 | |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 140 | // Tell the external Sema source about this Sema object. |
| 141 | if (ExternalSemaSource *ExternalSema |
| 142 | = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) |
| 143 | ExternalSema->InitializeSema(*this); |
Douglas Gregor | 3ea7269 | 2011-08-12 05:46:01 +0000 | [diff] [blame] | 144 | |
Douglas Gregor | 801c99d | 2011-08-12 06:49:56 +0000 | [diff] [blame] | 145 | // Initialize predefined 128-bit integer types, if needed. |
Richard Smith | e6a56db | 2012-11-29 05:41:51 +0000 | [diff] [blame] | 146 | if (PP.getTargetInfo().hasInt128Type()) { |
Douglas Gregor | 801c99d | 2011-08-12 06:49:56 +0000 | [diff] [blame] | 147 | // If either of the 128-bit integer types are unavailable to name lookup, |
| 148 | // define them now. |
| 149 | DeclarationName Int128 = &Context.Idents.get("__int128_t"); |
Douglas Gregor | 935bc7a2 | 2011-10-27 09:33:13 +0000 | [diff] [blame] | 150 | if (IdResolver.begin(Int128) == IdResolver.end()) |
Douglas Gregor | 801c99d | 2011-08-12 06:49:56 +0000 | [diff] [blame] | 151 | PushOnScopeChains(Context.getInt128Decl(), TUScope); |
| 152 | |
| 153 | DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); |
Douglas Gregor | 935bc7a2 | 2011-10-27 09:33:13 +0000 | [diff] [blame] | 154 | if (IdResolver.begin(UInt128) == IdResolver.end()) |
Douglas Gregor | 801c99d | 2011-08-12 06:49:56 +0000 | [diff] [blame] | 155 | PushOnScopeChains(Context.getUInt128Decl(), TUScope); |
| 156 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 157 | |
Douglas Gregor | 801c99d | 2011-08-12 06:49:56 +0000 | [diff] [blame] | 158 | |
Douglas Gregor | 3ea7269 | 2011-08-12 05:46:01 +0000 | [diff] [blame] | 159 | // Initialize predefined Objective-C types: |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 160 | if (PP.getLangOpts().ObjC1) { |
Douglas Gregor | 52e0280 | 2011-08-12 06:17:30 +0000 | [diff] [blame] | 161 | // If 'SEL' does not yet refer to any declarations, make it refer to the |
| 162 | // predefined 'SEL'. |
| 163 | DeclarationName SEL = &Context.Idents.get("SEL"); |
Douglas Gregor | 935bc7a2 | 2011-10-27 09:33:13 +0000 | [diff] [blame] | 164 | if (IdResolver.begin(SEL) == IdResolver.end()) |
Douglas Gregor | 52e0280 | 2011-08-12 06:17:30 +0000 | [diff] [blame] | 165 | PushOnScopeChains(Context.getObjCSelDecl(), TUScope); |
| 166 | |
Douglas Gregor | 3ea7269 | 2011-08-12 05:46:01 +0000 | [diff] [blame] | 167 | // If 'id' does not yet refer to any declarations, make it refer to the |
| 168 | // predefined 'id'. |
| 169 | DeclarationName Id = &Context.Idents.get("id"); |
Douglas Gregor | 935bc7a2 | 2011-10-27 09:33:13 +0000 | [diff] [blame] | 170 | if (IdResolver.begin(Id) == IdResolver.end()) |
Douglas Gregor | 3ea7269 | 2011-08-12 05:46:01 +0000 | [diff] [blame] | 171 | PushOnScopeChains(Context.getObjCIdDecl(), TUScope); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 172 | |
Douglas Gregor | 0a58618 | 2011-08-12 05:59:41 +0000 | [diff] [blame] | 173 | // Create the built-in typedef for 'Class'. |
| 174 | DeclarationName Class = &Context.Idents.get("Class"); |
Douglas Gregor | 935bc7a2 | 2011-10-27 09:33:13 +0000 | [diff] [blame] | 175 | if (IdResolver.begin(Class) == IdResolver.end()) |
Douglas Gregor | 0a58618 | 2011-08-12 05:59:41 +0000 | [diff] [blame] | 176 | PushOnScopeChains(Context.getObjCClassDecl(), TUScope); |
Douglas Gregor | d53ae83 | 2012-01-17 18:09:05 +0000 | [diff] [blame] | 177 | |
| 178 | // Create the built-in forward declaratino for 'Protocol'. |
| 179 | DeclarationName Protocol = &Context.Idents.get("Protocol"); |
| 180 | if (IdResolver.begin(Protocol) == IdResolver.end()) |
| 181 | PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); |
Douglas Gregor | 3ea7269 | 2011-08-12 05:46:01 +0000 | [diff] [blame] | 182 | } |
Meador Inge | 5d3fb22 | 2012-06-16 03:34:49 +0000 | [diff] [blame] | 183 | |
Alp Toker | e1fab52 | 2014-01-04 15:25:02 +0000 | [diff] [blame] | 184 | // Initialize Microsoft "predefined C++ types". |
Alp Toker | bfa3934 | 2014-01-14 12:51:41 +0000 | [diff] [blame] | 185 | if (PP.getLangOpts().MSVCCompat && PP.getLangOpts().CPlusPlus) { |
Alp Toker | e1fab52 | 2014-01-04 15:25:02 +0000 | [diff] [blame] | 186 | if (IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) |
| 187 | PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class), |
| 188 | TUScope); |
David Majnemer | 1de3691 | 2014-01-14 06:19:35 +0000 | [diff] [blame] | 189 | |
| 190 | addImplicitTypedef("size_t", Context.getSizeType()); |
Alp Toker | e1fab52 | 2014-01-04 15:25:02 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Alp Toker | f22856a | 2013-12-18 15:29:05 +0000 | [diff] [blame] | 193 | // Initialize predefined OpenCL types. |
| 194 | if (PP.getLangOpts().OpenCL) { |
| 195 | addImplicitTypedef("image1d_t", Context.OCLImage1dTy); |
| 196 | addImplicitTypedef("image1d_array_t", Context.OCLImage1dArrayTy); |
| 197 | addImplicitTypedef("image1d_buffer_t", Context.OCLImage1dBufferTy); |
| 198 | addImplicitTypedef("image2d_t", Context.OCLImage2dTy); |
| 199 | addImplicitTypedef("image2d_array_t", Context.OCLImage2dArrayTy); |
| 200 | addImplicitTypedef("image3d_t", Context.OCLImage3dTy); |
| 201 | addImplicitTypedef("sampler_t", Context.OCLSamplerTy); |
| 202 | addImplicitTypedef("event_t", Context.OCLEventTy); |
| 203 | } |
| 204 | |
Meador Inge | 5d3fb22 | 2012-06-16 03:34:49 +0000 | [diff] [blame] | 205 | DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); |
| 206 | if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) |
| 207 | PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); |
Steve Naroff | 38d31b4 | 2007-02-28 01:22:02 +0000 | [diff] [blame] | 208 | } |
Chris Lattner | cb6a382 | 2006-11-10 06:20:45 +0000 | [diff] [blame] | 209 | |
Anton Korobeynikov | 55bcea1 | 2010-01-10 12:58:08 +0000 | [diff] [blame] | 210 | Sema::~Sema() { |
Reid Kleckner | 588c937 | 2014-02-19 23:44:52 +0000 | [diff] [blame] | 211 | llvm::DeleteContainerSeconds(LateParsedTemplateMap); |
Anton Korobeynikov | 55bcea1 | 2010-01-10 12:58:08 +0000 | [diff] [blame] | 212 | if (PackContext) FreePackedContext(); |
Eli Friedman | 570024a | 2010-08-05 06:57:20 +0000 | [diff] [blame] | 213 | if (VisContext) FreeVisContext(); |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 214 | // Kill all the active scopes. |
| 215 | for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I) |
| 216 | delete FunctionScopes[I]; |
| 217 | if (FunctionScopes.size() == 1) |
| 218 | delete FunctionScopes[0]; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 219 | |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 220 | // Tell the SemaConsumer to forget about us; we're going out of scope. |
| 221 | if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) |
| 222 | SC->ForgetSema(); |
| 223 | |
| 224 | // Detach from the external Sema source. |
| 225 | if (ExternalSemaSource *ExternalSema |
Douglas Gregor | 6fd55e0 | 2010-08-13 03:15:25 +0000 | [diff] [blame] | 226 | = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) |
Douglas Gregor | 5c6f10b | 2010-08-12 22:51:45 +0000 | [diff] [blame] | 227 | ExternalSema->ForgetSema(); |
Axel Naumann | dd433f0 | 2012-10-18 19:05:02 +0000 | [diff] [blame] | 228 | |
| 229 | // If Sema's ExternalSource is the multiplexer - we own it. |
| 230 | if (isMultiplexExternalSource) |
| 231 | delete ExternalSource; |
Alexey Bataev | 758e55e | 2013-09-06 18:03:48 +0000 | [diff] [blame] | 232 | |
| 233 | // Destroys data sharing attributes stack for OpenMP |
| 234 | DestroyDataSharingAttributesStack(); |
Anton Korobeynikov | 55bcea1 | 2010-01-10 12:58:08 +0000 | [diff] [blame] | 235 | } |
| 236 | |
John McCall | 31168b0 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 237 | /// makeUnavailableInSystemHeader - There is an error in the current |
| 238 | /// context. If we're still in a system header, and we can plausibly |
| 239 | /// make the relevant declaration unavailable instead of erroring, do |
| 240 | /// so and return true. |
| 241 | bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 242 | StringRef msg) { |
John McCall | 31168b0 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 243 | // If we're not in a function, it's an error. |
| 244 | FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext); |
| 245 | if (!fn) return false; |
| 246 | |
| 247 | // If we're in template instantiation, it's an error. |
| 248 | if (!ActiveTemplateInstantiations.empty()) |
| 249 | return false; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 250 | |
John McCall | 31168b0 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 251 | // If that function's not in a system header, it's an error. |
| 252 | if (!Context.getSourceManager().isInSystemHeader(loc)) |
| 253 | return false; |
| 254 | |
| 255 | // If the function is already unavailable, it's not an error. |
| 256 | if (fn->hasAttr<UnavailableAttr>()) return true; |
| 257 | |
Aaron Ballman | 36a5350 | 2014-01-16 13:03:14 +0000 | [diff] [blame] | 258 | fn->addAttr(UnavailableAttr::CreateImplicit(Context, msg, loc)); |
John McCall | 31168b0 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 259 | return true; |
| 260 | } |
| 261 | |
Sebastian Redl | ab238a7 | 2011-04-24 16:28:06 +0000 | [diff] [blame] | 262 | ASTMutationListener *Sema::getASTMutationListener() const { |
| 263 | return getASTConsumer().GetASTMutationListener(); |
| 264 | } |
| 265 | |
Axel Naumann | dd433f0 | 2012-10-18 19:05:02 +0000 | [diff] [blame] | 266 | ///\brief Registers an external source. If an external source already exists, |
| 267 | /// creates a multiplex external source and appends to it. |
| 268 | /// |
| 269 | ///\param[in] E - A non-null external sema source. |
| 270 | /// |
| 271 | void Sema::addExternalSource(ExternalSemaSource *E) { |
| 272 | assert(E && "Cannot use with NULL ptr"); |
| 273 | |
| 274 | if (!ExternalSource) { |
| 275 | ExternalSource = E; |
| 276 | return; |
| 277 | } |
| 278 | |
| 279 | if (isMultiplexExternalSource) |
| 280 | static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E); |
| 281 | else { |
| 282 | ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E); |
| 283 | isMultiplexExternalSource = true; |
| 284 | } |
| 285 | } |
| 286 | |
Chandler Carruth | b4836ea | 2011-07-06 16:21:37 +0000 | [diff] [blame] | 287 | /// \brief Print out statistics about the semantic analysis. |
| 288 | void Sema::PrintStats() const { |
| 289 | llvm::errs() << "\n*** Semantic Analysis Stats:\n"; |
| 290 | llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; |
| 291 | |
| 292 | BumpAlloc.PrintStats(); |
| 293 | AnalysisWarnings.PrintStats(); |
| 294 | } |
| 295 | |
Richard Smith | 507840d | 2011-11-29 22:48:16 +0000 | [diff] [blame] | 296 | /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. |
| 297 | /// If there is already an implicit cast, merge into the existing one. |
| 298 | /// The result is of the given category. |
| 299 | ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, |
| 300 | CastKind Kind, ExprValueKind VK, |
| 301 | const CXXCastPath *BasePath, |
| 302 | CheckedConversionKind CCK) { |
Richard Smith | 508ebf3 | 2011-10-28 03:31:48 +0000 | [diff] [blame] | 303 | #ifndef NDEBUG |
| 304 | if (VK == VK_RValue && !E->isRValue()) { |
| 305 | switch (Kind) { |
| 306 | default: |
| 307 | assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind"); |
| 308 | case CK_LValueToRValue: |
| 309 | case CK_ArrayToPointerDecay: |
| 310 | case CK_FunctionToPointerDecay: |
| 311 | case CK_ToVoid: |
| 312 | break; |
| 313 | } |
| 314 | } |
Richard Smith | 4a905b6 | 2011-11-10 23:32:36 +0000 | [diff] [blame] | 315 | assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); |
Richard Smith | 508ebf3 | 2011-10-28 03:31:48 +0000 | [diff] [blame] | 316 | #endif |
| 317 | |
John Wiegley | 0129629 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 318 | QualType ExprTy = Context.getCanonicalType(E->getType()); |
Mon P Wang | 74b3207 | 2008-09-04 08:38:01 +0000 | [diff] [blame] | 319 | QualType TypeTy = Context.getCanonicalType(Ty); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 320 | |
Mon P Wang | 74b3207 | 2008-09-04 08:38:01 +0000 | [diff] [blame] | 321 | if (ExprTy == TypeTy) |
John Wiegley | 0129629 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 322 | return Owned(E); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 323 | |
Douglas Gregor | 88d292c | 2010-05-13 16:44:06 +0000 | [diff] [blame] | 324 | // If this is a derived-to-base cast to a through a virtual base, we |
| 325 | // need a vtable. |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 326 | if (Kind == CK_DerivedToBase && |
John McCall | cf14216 | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 327 | BasePathInvolvesVirtualBase(*BasePath)) { |
John Wiegley | 0129629 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 328 | QualType T = E->getType(); |
Douglas Gregor | 88d292c | 2010-05-13 16:44:06 +0000 | [diff] [blame] | 329 | if (const PointerType *Pointer = T->getAs<PointerType>()) |
| 330 | T = Pointer->getPointeeType(); |
| 331 | if (const RecordType *RecordTy = T->getAs<RecordType>()) |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 332 | MarkVTableUsed(E->getLocStart(), |
Douglas Gregor | 88d292c | 2010-05-13 16:44:06 +0000 | [diff] [blame] | 333 | cast<CXXRecordDecl>(RecordTy->getDecl())); |
| 334 | } |
Anders Carlsson | 4e66cda | 2009-09-15 05:28:24 +0000 | [diff] [blame] | 335 | |
Richard Smith | 507840d | 2011-11-29 22:48:16 +0000 | [diff] [blame] | 336 | if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) { |
| 337 | if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { |
| 338 | ImpCast->setType(Ty); |
| 339 | ImpCast->setValueKind(VK); |
| 340 | return Owned(E); |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK)); |
Sebastian Redl | c57d34b | 2010-07-20 04:20:21 +0000 | [diff] [blame] | 345 | } |
| 346 | |
Abramo Bagnara | 7ccce98 | 2011-04-07 09:26:19 +0000 | [diff] [blame] | 347 | /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding |
| 348 | /// to the conversion from scalar type ScalarTy to the Boolean type. |
| 349 | CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { |
| 350 | switch (ScalarTy->getScalarTypeKind()) { |
| 351 | case Type::STK_Bool: return CK_NoOp; |
John McCall | 9320b87 | 2011-09-09 05:25:32 +0000 | [diff] [blame] | 352 | case Type::STK_CPointer: return CK_PointerToBoolean; |
| 353 | case Type::STK_BlockPointer: return CK_PointerToBoolean; |
| 354 | case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; |
Abramo Bagnara | 7ccce98 | 2011-04-07 09:26:19 +0000 | [diff] [blame] | 355 | case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; |
| 356 | case Type::STK_Integral: return CK_IntegralToBoolean; |
| 357 | case Type::STK_Floating: return CK_FloatingToBoolean; |
| 358 | case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; |
| 359 | case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; |
| 360 | } |
| 361 | return CK_Invalid; |
| 362 | } |
| 363 | |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 364 | /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. |
| 365 | static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { |
Rafael Espindola | 820fa70 | 2013-01-08 19:43:34 +0000 | [diff] [blame] | 366 | if (D->getMostRecentDecl()->isUsed()) |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 367 | return true; |
| 368 | |
Rafael Espindola | 3ae0005 | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 369 | if (D->isExternallyVisible()) |
Rafael Espindola | 0e0d009 | 2013-03-14 03:07:35 +0000 | [diff] [blame] | 370 | return true; |
| 371 | |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 372 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { |
| 373 | // UnusedFileScopedDecls stores the first declaration. |
| 374 | // The declaration may have become definition so check again. |
| 375 | const FunctionDecl *DeclToCheck; |
| 376 | if (FD->hasBody(DeclToCheck)) |
| 377 | return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); |
| 378 | |
| 379 | // Later redecls may add new information resulting in not having to warn, |
| 380 | // so check again. |
Douglas Gregor | ec9fd13 | 2012-01-14 16:38:05 +0000 | [diff] [blame] | 381 | DeclToCheck = FD->getMostRecentDecl(); |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 382 | if (DeclToCheck != FD) |
| 383 | return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); |
| 384 | } |
| 385 | |
| 386 | if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { |
Eli Friedman | a5dfebd | 2013-09-10 21:10:25 +0000 | [diff] [blame] | 387 | // If a variable usable in constant expressions is referenced, |
| 388 | // don't warn if it isn't used: if the value of a variable is required |
| 389 | // for the computation of a constant expression, it doesn't make sense to |
| 390 | // warn even if the variable isn't odr-used. (isReferenced doesn't |
| 391 | // precisely reflect that, but it's a decent approximation.) |
| 392 | if (VD->isReferenced() && |
| 393 | VD->isUsableInConstantExpressions(SemaRef->Context)) |
| 394 | return true; |
| 395 | |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 396 | // UnusedFileScopedDecls stores the first declaration. |
| 397 | // The declaration may have become definition so check again. |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 398 | const VarDecl *DeclToCheck = VD->getDefinition(); |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 399 | if (DeclToCheck) |
| 400 | return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); |
| 401 | |
| 402 | // Later redecls may add new information resulting in not having to warn, |
| 403 | // so check again. |
Douglas Gregor | ec9fd13 | 2012-01-14 16:38:05 +0000 | [diff] [blame] | 404 | DeclToCheck = VD->getMostRecentDecl(); |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 405 | if (DeclToCheck != VD) |
| 406 | return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); |
| 407 | } |
| 408 | |
| 409 | return false; |
| 410 | } |
| 411 | |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 412 | /// Obtains a sorted list of functions that are undefined but ODR-used. |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 413 | void Sema::getUndefinedButUsed( |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 414 | SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) { |
| 415 | for (llvm::DenseMap<NamedDecl *, SourceLocation>::iterator |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 416 | I = UndefinedButUsed.begin(), E = UndefinedButUsed.end(); |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 417 | I != E; ++I) { |
| 418 | NamedDecl *ND = I->first; |
| 419 | |
| 420 | // Ignore attributes that have become invalid. |
| 421 | if (ND->isInvalidDecl()) continue; |
| 422 | |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 423 | // __attribute__((weakref)) is basically a definition. |
| 424 | if (ND->hasAttr<WeakRefAttr>()) continue; |
| 425 | |
| 426 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { |
| 427 | if (FD->isDefined()) |
| 428 | continue; |
Rafael Espindola | 3ae0005 | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 429 | if (FD->isExternallyVisible() && |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 430 | !FD->getMostRecentDecl()->isInlined()) |
| 431 | continue; |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 432 | } else { |
| 433 | if (cast<VarDecl>(ND)->hasDefinition() != VarDecl::DeclarationOnly) |
| 434 | continue; |
Rafael Espindola | 3ae0005 | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 435 | if (ND->isExternallyVisible()) |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 436 | continue; |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 437 | } |
| 438 | |
| 439 | Undefined.push_back(std::make_pair(ND, I->second)); |
| 440 | } |
| 441 | |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 442 | // Sort (in order of use site) so that we're not dependent on the iteration |
| 443 | // order through an llvm::DenseMap. |
Benjamin Kramer | bbdd764 | 2014-03-01 14:48:57 +0000 | [diff] [blame] | 444 | SourceManager &SM = Context.getSourceManager(); |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 445 | std::sort(Undefined.begin(), Undefined.end(), |
Benjamin Kramer | bbdd764 | 2014-03-01 14:48:57 +0000 | [diff] [blame] | 446 | [&SM](const std::pair<NamedDecl *, SourceLocation> &l, |
| 447 | const std::pair<NamedDecl *, SourceLocation> &r) { |
| 448 | if (l.second.isValid() && !r.second.isValid()) |
| 449 | return true; |
| 450 | if (!l.second.isValid() && r.second.isValid()) |
| 451 | return false; |
| 452 | if (l.second != r.second) |
| 453 | return SM.isBeforeInTranslationUnit(l.second, r.second); |
| 454 | return SM.isBeforeInTranslationUnit(l.first->getLocation(), |
| 455 | r.first->getLocation()); |
| 456 | }); |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 457 | } |
| 458 | |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 459 | /// checkUndefinedButUsed - Check for undefined objects with internal linkage |
| 460 | /// or that are inline. |
| 461 | static void checkUndefinedButUsed(Sema &S) { |
| 462 | if (S.UndefinedButUsed.empty()) return; |
John McCall | 8377967 | 2011-02-19 02:53:41 +0000 | [diff] [blame] | 463 | |
| 464 | // Collect all the still-undefined entities with internal linkage. |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 465 | SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined; |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 466 | S.getUndefinedButUsed(Undefined); |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 467 | if (Undefined.empty()) return; |
John McCall | 8377967 | 2011-02-19 02:53:41 +0000 | [diff] [blame] | 468 | |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 469 | for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator |
| 470 | I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { |
| 471 | NamedDecl *ND = I->first; |
John McCall | 8377967 | 2011-02-19 02:53:41 +0000 | [diff] [blame] | 472 | |
Rafael Espindola | 3ae0005 | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 473 | if (!ND->isExternallyVisible()) { |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 474 | S.Diag(ND->getLocation(), diag::warn_undefined_internal) |
| 475 | << isa<VarDecl>(ND) << ND; |
| 476 | } else { |
| 477 | assert(cast<FunctionDecl>(ND)->getMostRecentDecl()->isInlined() && |
| 478 | "used object requires definition but isn't inline or internal?"); |
| 479 | S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND; |
| 480 | } |
| 481 | if (I->second.isValid()) |
| 482 | S.Diag(I->second, diag::note_used_here); |
John McCall | 8377967 | 2011-02-19 02:53:41 +0000 | [diff] [blame] | 483 | } |
| 484 | } |
| 485 | |
Douglas Gregor | 1c4bfe5 | 2011-07-28 18:09:57 +0000 | [diff] [blame] | 486 | void Sema::LoadExternalWeakUndeclaredIdentifiers() { |
| 487 | if (!ExternalSource) |
| 488 | return; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 489 | |
Douglas Gregor | 1c4bfe5 | 2011-07-28 18:09:57 +0000 | [diff] [blame] | 490 | SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs; |
| 491 | ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); |
| 492 | for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) { |
| 493 | llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos |
| 494 | = WeakUndeclaredIdentifiers.find(WeakIDs[I].first); |
| 495 | if (Pos != WeakUndeclaredIdentifiers.end()) |
| 496 | continue; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 497 | |
Douglas Gregor | 1c4bfe5 | 2011-07-28 18:09:57 +0000 | [diff] [blame] | 498 | WeakUndeclaredIdentifiers.insert(WeakIDs[I]); |
| 499 | } |
| 500 | } |
| 501 | |
Daniel Jasper | 0baec549 | 2012-06-06 08:32:04 +0000 | [diff] [blame] | 502 | |
| 503 | typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap; |
| 504 | |
| 505 | /// \brief Returns true, if all methods and nested classes of the given |
| 506 | /// CXXRecordDecl are defined in this translation unit. |
| 507 | /// |
| 508 | /// Should only be called from ActOnEndOfTranslationUnit so that all |
| 509 | /// definitions are actually read. |
| 510 | static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, |
| 511 | RecordCompleteMap &MNCComplete) { |
| 512 | RecordCompleteMap::iterator Cache = MNCComplete.find(RD); |
| 513 | if (Cache != MNCComplete.end()) |
| 514 | return Cache->second; |
| 515 | if (!RD->isCompleteDefinition()) |
| 516 | return false; |
| 517 | bool Complete = true; |
| 518 | for (DeclContext::decl_iterator I = RD->decls_begin(), |
| 519 | E = RD->decls_end(); |
| 520 | I != E && Complete; ++I) { |
| 521 | if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I)) |
| 522 | Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M)); |
Daniel Jasper | e99c2bf | 2012-06-14 20:56:06 +0000 | [diff] [blame] | 523 | else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I)) |
| 524 | Complete = F->getTemplatedDecl()->isDefined(); |
Daniel Jasper | 0baec549 | 2012-06-06 08:32:04 +0000 | [diff] [blame] | 525 | else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) { |
| 526 | if (R->isInjectedClassName()) |
| 527 | continue; |
| 528 | if (R->hasDefinition()) |
| 529 | Complete = MethodsAndNestedClassesComplete(R->getDefinition(), |
| 530 | MNCComplete); |
| 531 | else |
| 532 | Complete = false; |
| 533 | } |
| 534 | } |
| 535 | MNCComplete[RD] = Complete; |
| 536 | return Complete; |
| 537 | } |
| 538 | |
| 539 | /// \brief Returns true, if the given CXXRecordDecl is fully defined in this |
| 540 | /// translation unit, i.e. all methods are defined or pure virtual and all |
| 541 | /// friends, friend functions and nested classes are fully defined in this |
| 542 | /// translation unit. |
| 543 | /// |
| 544 | /// Should only be called from ActOnEndOfTranslationUnit so that all |
| 545 | /// definitions are actually read. |
| 546 | static bool IsRecordFullyDefined(const CXXRecordDecl *RD, |
| 547 | RecordCompleteMap &RecordsComplete, |
| 548 | RecordCompleteMap &MNCComplete) { |
| 549 | RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); |
| 550 | if (Cache != RecordsComplete.end()) |
| 551 | return Cache->second; |
| 552 | bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); |
| 553 | for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), |
| 554 | E = RD->friend_end(); |
| 555 | I != E && Complete; ++I) { |
| 556 | // Check if friend classes and methods are complete. |
| 557 | if (TypeSourceInfo *TSI = (*I)->getFriendType()) { |
| 558 | // Friend classes are available as the TypeSourceInfo of the FriendDecl. |
| 559 | if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) |
| 560 | Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); |
| 561 | else |
| 562 | Complete = false; |
| 563 | } else { |
| 564 | // Friend functions are available through the NamedDecl of FriendDecl. |
| 565 | if (const FunctionDecl *FD = |
| 566 | dyn_cast<FunctionDecl>((*I)->getFriendDecl())) |
| 567 | Complete = FD->isDefined(); |
| 568 | else |
| 569 | // This is a template friend, give up. |
| 570 | Complete = false; |
| 571 | } |
| 572 | } |
| 573 | RecordsComplete[RD] = Complete; |
| 574 | return Complete; |
| 575 | } |
| 576 | |
Chris Lattner | f440440 | 2008-08-23 03:19:52 +0000 | [diff] [blame] | 577 | /// ActOnEndOfTranslationUnit - This is called at the very end of the |
| 578 | /// translation unit when EOF is reached and all but the top-level scope is |
| 579 | /// popped. |
Argyrios Kyrtzidis | 7f76d11 | 2010-08-05 09:48:16 +0000 | [diff] [blame] | 580 | void Sema::ActOnEndOfTranslationUnit() { |
John McCall | 2ec8537 | 2012-05-07 06:16:41 +0000 | [diff] [blame] | 581 | assert(DelayedDiagnostics.getCurrentPool() == NULL |
| 582 | && "reached end of translation unit with a pool attached?"); |
| 583 | |
Douglas Gregor | c459b51 | 2012-08-17 22:17:36 +0000 | [diff] [blame] | 584 | // If code completion is enabled, don't perform any end-of-translation-unit |
| 585 | // work. |
| 586 | if (PP.isCodeCompletionEnabled()) |
| 587 | return; |
| 588 | |
Richard Smith | 0e5d7b8 | 2013-07-25 23:08:39 +0000 | [diff] [blame] | 589 | // Complete translation units and modules define vtables and perform implicit |
| 590 | // instantiations. PCH files do not. |
| 591 | if (TUKind != TU_Prefix) { |
Argyrios Kyrtzidis | b6c6a58 | 2012-02-07 16:50:53 +0000 | [diff] [blame] | 592 | DiagnoseUseOfUnimplementedSelectors(); |
| 593 | |
Chandler Carruth | 88bfa5e | 2010-12-12 21:36:11 +0000 | [diff] [blame] | 594 | // If any dynamic classes have their key function defined within |
| 595 | // this translation unit, then those vtables are considered "used" and must |
| 596 | // be emitted. |
Douglas Gregor | 3200219 | 2011-07-28 00:53:40 +0000 | [diff] [blame] | 597 | for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource), |
| 598 | E = DynamicClasses.end(); |
| 599 | I != E; ++I) { |
| 600 | assert(!(*I)->isDependentType() && |
Anders Carlsson | e771e76 | 2011-01-25 18:08:22 +0000 | [diff] [blame] | 601 | "Should not see dependent types here!"); |
John McCall | 6bd2a89 | 2013-01-25 22:31:03 +0000 | [diff] [blame] | 602 | if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) { |
Chandler Carruth | 88bfa5e | 2010-12-12 21:36:11 +0000 | [diff] [blame] | 603 | const FunctionDecl *Definition = 0; |
| 604 | if (KeyFunction->hasBody(Definition)) |
Douglas Gregor | 3200219 | 2011-07-28 00:53:40 +0000 | [diff] [blame] | 605 | MarkVTableUsed(Definition->getLocation(), *I, true); |
Chandler Carruth | 88bfa5e | 2010-12-12 21:36:11 +0000 | [diff] [blame] | 606 | } |
| 607 | } |
| 608 | |
Nick Lewycky | 67c4d0f | 2011-05-31 07:58:42 +0000 | [diff] [blame] | 609 | // If DefinedUsedVTables ends up marking any virtual member functions it |
| 610 | // might lead to more pending template instantiations, which we then need |
| 611 | // to instantiate. |
| 612 | DefineUsedVTables(); |
Argyrios Kyrtzidis | 7f76d11 | 2010-08-05 09:48:16 +0000 | [diff] [blame] | 613 | |
Nick Lewycky | 67c4d0f | 2011-05-31 07:58:42 +0000 | [diff] [blame] | 614 | // C++: Perform implicit template instantiations. |
| 615 | // |
| 616 | // FIXME: When we perform these implicit instantiations, we do not |
| 617 | // carefully keep track of the point of instantiation (C++ [temp.point]). |
| 618 | // This means that name lookup that occurs within the template |
| 619 | // instantiation will always happen at the end of the translation unit, |
Richard Smith | 0e5d7b8 | 2013-07-25 23:08:39 +0000 | [diff] [blame] | 620 | // so it will find some names that are not required to be found. This is |
| 621 | // valid, but we could do better by diagnosing if an instantiation uses a |
| 622 | // name that was not visible at its first point of instantiation. |
Richard Smith | 0ac1b8f | 2014-03-22 01:43:32 +0000 | [diff] [blame^] | 623 | if (ExternalSource) { |
| 624 | // Load pending instantiations from the external source. |
| 625 | SmallVector<PendingImplicitInstantiation, 4> Pending; |
| 626 | ExternalSource->ReadPendingInstantiations(Pending); |
| 627 | PendingInstantiations.insert(PendingInstantiations.begin(), |
| 628 | Pending.begin(), Pending.end()); |
| 629 | } |
Nick Lewycky | 67c4d0f | 2011-05-31 07:58:42 +0000 | [diff] [blame] | 630 | PerformPendingInstantiations(); |
Richard Smith | 0ac1b8f | 2014-03-22 01:43:32 +0000 | [diff] [blame^] | 631 | |
Alp Toker | ae3a944 | 2013-10-18 05:54:19 +0000 | [diff] [blame] | 632 | CheckDelayedMemberExceptionSpecs(); |
Nick Lewycky | ef4f456 | 2010-11-25 00:35:20 +0000 | [diff] [blame] | 633 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 634 | |
Alp Toker | ae3a944 | 2013-10-18 05:54:19 +0000 | [diff] [blame] | 635 | // All delayed member exception specs should be checked or we end up accepting |
| 636 | // incompatible declarations. |
| 637 | assert(DelayedDefaultedMemberExceptionSpecs.empty()); |
| 638 | assert(DelayedDestructorExceptionSpecChecks.empty()); |
| 639 | |
Argyrios Kyrtzidis | 35672e7 | 2010-08-13 18:42:17 +0000 | [diff] [blame] | 640 | // Remove file scoped decls that turned out to be used. |
Daniel Jasper | 9ba6f9b | 2013-04-30 06:43:16 +0000 | [diff] [blame] | 641 | UnusedFileScopedDecls.erase( |
| 642 | std::remove_if(UnusedFileScopedDecls.begin(0, true), |
| 643 | UnusedFileScopedDecls.end(), |
| 644 | std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)), |
| 645 | UnusedFileScopedDecls.end()); |
Douglas Gregor | fb8b27d | 2010-04-09 17:41:13 +0000 | [diff] [blame] | 646 | |
Douglas Gregor | 69f74f8 | 2011-08-25 22:30:56 +0000 | [diff] [blame] | 647 | if (TUKind == TU_Prefix) { |
| 648 | // Translation unit prefixes don't need any of the checking below. |
Douglas Gregor | b14904c | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 649 | TUScope = 0; |
Argyrios Kyrtzidis | ee1afa3 | 2010-08-05 09:48:08 +0000 | [diff] [blame] | 650 | return; |
Douglas Gregor | b14904c | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 651 | } |
Argyrios Kyrtzidis | ee1afa3 | 2010-08-05 09:48:08 +0000 | [diff] [blame] | 652 | |
Chris Lattner | 0c79736 | 2009-09-08 18:19:27 +0000 | [diff] [blame] | 653 | // Check for #pragma weak identifiers that were never declared |
| 654 | // FIXME: This will cause diagnostics to be emitted in a non-determinstic |
| 655 | // order! Iterating over a densemap like this is bad. |
Douglas Gregor | 1c4bfe5 | 2011-07-28 18:09:57 +0000 | [diff] [blame] | 656 | LoadExternalWeakUndeclaredIdentifiers(); |
Ryan Flynn | 7d470f3 | 2009-07-30 03:15:39 +0000 | [diff] [blame] | 657 | for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator |
Chris Lattner | 0c79736 | 2009-09-08 18:19:27 +0000 | [diff] [blame] | 658 | I = WeakUndeclaredIdentifiers.begin(), |
| 659 | E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { |
| 660 | if (I->second.getUsed()) continue; |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 661 | |
Chris Lattner | 0c79736 | 2009-09-08 18:19:27 +0000 | [diff] [blame] | 662 | Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) |
| 663 | << I->first; |
Ryan Flynn | 7d470f3 | 2009-07-30 03:15:39 +0000 | [diff] [blame] | 664 | } |
| 665 | |
Argyrios Kyrtzidis | ffb3558 | 2013-03-14 04:44:56 +0000 | [diff] [blame] | 666 | if (LangOpts.CPlusPlus11 && |
| 667 | Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle, |
| 668 | SourceLocation()) |
| 669 | != DiagnosticsEngine::Ignored) |
| 670 | CheckDelegatingCtorCycles(); |
| 671 | |
Douglas Gregor | 69f74f8 | 2011-08-25 22:30:56 +0000 | [diff] [blame] | 672 | if (TUKind == TU_Module) { |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 673 | // If we are building a module, resolve all of the exported declarations |
| 674 | // now. |
| 675 | if (Module *CurrentModule = PP.getCurrentModule()) { |
| 676 | ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 677 | |
Dmitri Gribenko | f857950 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 678 | SmallVector<Module *, 2> Stack; |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 679 | Stack.push_back(CurrentModule); |
| 680 | while (!Stack.empty()) { |
Robert Wilhelm | 25284cc | 2013-08-23 16:11:15 +0000 | [diff] [blame] | 681 | Module *Mod = Stack.pop_back_val(); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 682 | |
Douglas Gregor | fb91265 | 2013-03-20 21:10:35 +0000 | [diff] [blame] | 683 | // Resolve the exported declarations and conflicts. |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 684 | // FIXME: Actually complain, once we figure out how to teach the |
Douglas Gregor | fb91265 | 2013-03-20 21:10:35 +0000 | [diff] [blame] | 685 | // diagnostic client to deal with complaints in the module map at this |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 686 | // point. |
| 687 | ModMap.resolveExports(Mod, /*Complain=*/false); |
Daniel Jasper | ba7f2f7 | 2013-09-24 09:14:14 +0000 | [diff] [blame] | 688 | ModMap.resolveUses(Mod, /*Complain=*/false); |
Douglas Gregor | fb91265 | 2013-03-20 21:10:35 +0000 | [diff] [blame] | 689 | ModMap.resolveConflicts(Mod, /*Complain=*/false); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 690 | |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 691 | // Queue the submodules, so their exports will also be resolved. |
Douglas Gregor | eb90e83 | 2012-01-04 23:32:19 +0000 | [diff] [blame] | 692 | for (Module::submodule_iterator Sub = Mod->submodule_begin(), |
| 693 | SubEnd = Mod->submodule_end(); |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 694 | Sub != SubEnd; ++Sub) { |
Douglas Gregor | eb90e83 | 2012-01-04 23:32:19 +0000 | [diff] [blame] | 695 | Stack.push_back(*Sub); |
Douglas Gregor | 2b82c2a | 2011-12-02 01:47:07 +0000 | [diff] [blame] | 696 | } |
| 697 | } |
| 698 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 699 | |
Douglas Gregor | 69f74f8 | 2011-08-25 22:30:56 +0000 | [diff] [blame] | 700 | // Modules don't need any of the checking below. |
| 701 | TUScope = 0; |
| 702 | return; |
| 703 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 704 | |
Douglas Gregor | 0760fa1 | 2009-03-10 23:43:53 +0000 | [diff] [blame] | 705 | // C99 6.9.2p2: |
| 706 | // A declaration of an identifier for an object that has file |
| 707 | // scope without an initializer, and without a storage-class |
| 708 | // specifier or with the storage-class specifier static, |
| 709 | // constitutes a tentative definition. If a translation unit |
| 710 | // contains one or more tentative definitions for an identifier, |
| 711 | // and the translation unit contains no external definition for |
| 712 | // that identifier, then the behavior is exactly as if the |
| 713 | // translation unit contains a file scope declaration of that |
| 714 | // identifier, with the composite type as of the end of the |
| 715 | // translation unit, with an initializer equal to 0. |
Sebastian Redl | 35351a9 | 2010-01-31 22:27:38 +0000 | [diff] [blame] | 716 | llvm::SmallSet<VarDecl *, 32> Seen; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 717 | for (TentativeDefinitionsType::iterator |
Douglas Gregor | eb08bd4 | 2011-07-27 20:58:46 +0000 | [diff] [blame] | 718 | T = TentativeDefinitions.begin(ExternalSource), |
| 719 | TEnd = TentativeDefinitions.end(); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 720 | T != TEnd; ++T) |
Douglas Gregor | eb08bd4 | 2011-07-27 20:58:46 +0000 | [diff] [blame] | 721 | { |
| 722 | VarDecl *VD = (*T)->getActingDefinition(); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 723 | |
Sebastian Redl | 35351a9 | 2010-01-31 22:27:38 +0000 | [diff] [blame] | 724 | // If the tentative definition was completed, getActingDefinition() returns |
| 725 | // null. If we've already seen this variable before, insert()'s second |
| 726 | // return value is false. |
| 727 | if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) |
Douglas Gregor | beecd58 | 2009-04-21 17:11:58 +0000 | [diff] [blame] | 728 | continue; |
| 729 | |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 730 | if (const IncompleteArrayType *ArrayT |
Douglas Gregor | beecd58 | 2009-04-21 17:11:58 +0000 | [diff] [blame] | 731 | = Context.getAsIncompleteArrayType(VD->getType())) { |
Chris Lattner | 0c79736 | 2009-09-08 18:19:27 +0000 | [diff] [blame] | 732 | // Set the length of the array to 1 (C99 6.9.2p5). |
| 733 | Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); |
| 734 | llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); |
John McCall | c5b8225 | 2009-10-16 00:14:28 +0000 | [diff] [blame] | 735 | QualType T = Context.getConstantArrayType(ArrayT->getElementType(), |
| 736 | One, ArrayType::Normal, 0); |
Chris Lattner | 0c79736 | 2009-09-08 18:19:27 +0000 | [diff] [blame] | 737 | VD->setType(T); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 738 | } else if (RequireCompleteType(VD->getLocation(), VD->getType(), |
Douglas Gregor | beecd58 | 2009-04-21 17:11:58 +0000 | [diff] [blame] | 739 | diag::err_tentative_def_incomplete_type)) |
| 740 | VD->setInvalidDecl(); |
| 741 | |
Eli Friedman | 7d14b3c | 2012-10-23 20:19:32 +0000 | [diff] [blame] | 742 | CheckCompleteVariableDeclaration(VD); |
| 743 | |
Douglas Gregor | beecd58 | 2009-04-21 17:11:58 +0000 | [diff] [blame] | 744 | // Notify the consumer that we've completed a tentative definition. |
| 745 | if (!VD->isInvalidDecl()) |
| 746 | Consumer.CompleteTentativeDefinition(VD); |
| 747 | |
Douglas Gregor | 0760fa1 | 2009-03-10 23:43:53 +0000 | [diff] [blame] | 748 | } |
Argyrios Kyrtzidis | 77fd99f | 2011-01-31 07:04:37 +0000 | [diff] [blame] | 749 | |
| 750 | // If there were errors, disable 'unused' warnings since they will mostly be |
| 751 | // noise. |
| 752 | if (!Diags.hasErrorOccurred()) { |
| 753 | // Output warning for unused file scoped decls. |
Douglas Gregor | a94a154 | 2011-07-27 21:45:57 +0000 | [diff] [blame] | 754 | for (UnusedFileScopedDeclsType::iterator |
| 755 | I = UnusedFileScopedDecls.begin(ExternalSource), |
Argyrios Kyrtzidis | 77fd99f | 2011-01-31 07:04:37 +0000 | [diff] [blame] | 756 | E = UnusedFileScopedDecls.end(); I != E; ++I) { |
Douglas Gregor | a94a154 | 2011-07-27 21:45:57 +0000 | [diff] [blame] | 757 | if (ShouldRemoveFromUnused(this, *I)) |
| 758 | continue; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 759 | |
Argyrios Kyrtzidis | 77fd99f | 2011-01-31 07:04:37 +0000 | [diff] [blame] | 760 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { |
| 761 | const FunctionDecl *DiagD; |
| 762 | if (!FD->hasBody(DiagD)) |
| 763 | DiagD = FD; |
Argyrios Kyrtzidis | e028314 | 2011-03-03 17:47:42 +0000 | [diff] [blame] | 764 | if (DiagD->isDeleted()) |
| 765 | continue; // Deleted functions are supposed to be unused. |
Argyrios Kyrtzidis | 1618023 | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 766 | if (DiagD->isReferenced()) { |
| 767 | if (isa<CXXMethodDecl>(DiagD)) |
| 768 | Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) |
| 769 | << DiagD->getDeclName(); |
Fariborz Jahanian | 91fc39e | 2012-06-27 19:43:29 +0000 | [diff] [blame] | 770 | else { |
Rafael Espindola | 6ae7e50 | 2013-04-03 19:27:57 +0000 | [diff] [blame] | 771 | if (FD->getStorageClass() == SC_Static && |
Fariborz Jahanian | 91fc39e | 2012-06-27 19:43:29 +0000 | [diff] [blame] | 772 | !FD->isInlineSpecified() && |
Eli Friedman | 5ba37d5 | 2013-08-22 00:27:10 +0000 | [diff] [blame] | 773 | !SourceMgr.isInMainFile( |
Fariborz Jahanian | 91fc39e | 2012-06-27 19:43:29 +0000 | [diff] [blame] | 774 | SourceMgr.getExpansionLoc(FD->getLocation()))) |
| 775 | Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) |
| 776 | << DiagD->getDeclName(); |
| 777 | else |
| 778 | Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) |
| 779 | << /*function*/0 << DiagD->getDeclName(); |
| 780 | } |
Argyrios Kyrtzidis | 1618023 | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 781 | } else { |
| 782 | Diag(DiagD->getLocation(), |
| 783 | isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function |
| 784 | : diag::warn_unused_function) |
| 785 | << DiagD->getDeclName(); |
| 786 | } |
Argyrios Kyrtzidis | 77fd99f | 2011-01-31 07:04:37 +0000 | [diff] [blame] | 787 | } else { |
| 788 | const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition(); |
| 789 | if (!DiagD) |
| 790 | DiagD = cast<VarDecl>(*I); |
Argyrios Kyrtzidis | 1618023 | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 791 | if (DiagD->isReferenced()) { |
| 792 | Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) |
| 793 | << /*variable*/1 << DiagD->getDeclName(); |
Daniel Jasper | c531dae | 2013-09-11 10:37:35 +0000 | [diff] [blame] | 794 | } else if (DiagD->getType().isConstQualified()) { |
| 795 | Diag(DiagD->getLocation(), diag::warn_unused_const_variable) |
| 796 | << DiagD->getDeclName(); |
Eli Friedman | 5ef2175 | 2013-09-10 03:05:56 +0000 | [diff] [blame] | 797 | } else { |
Argyrios Kyrtzidis | 1618023 | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 798 | Diag(DiagD->getLocation(), diag::warn_unused_variable) |
Matt Beaumont-Gay | e1368a1 | 2013-04-10 00:47:10 +0000 | [diff] [blame] | 799 | << DiagD->getDeclName(); |
Argyrios Kyrtzidis | 1618023 | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 800 | } |
Argyrios Kyrtzidis | 77fd99f | 2011-01-31 07:04:37 +0000 | [diff] [blame] | 801 | } |
Argyrios Kyrtzidis | 1b30d9c | 2010-08-15 01:15:20 +0000 | [diff] [blame] | 802 | } |
John McCall | 8377967 | 2011-02-19 02:53:41 +0000 | [diff] [blame] | 803 | |
Nick Lewycky | 8334af8 | 2013-01-26 00:35:08 +0000 | [diff] [blame] | 804 | if (ExternalSource) |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 805 | ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); |
| 806 | checkUndefinedButUsed(*this); |
Argyrios Kyrtzidis | 35672e7 | 2010-08-13 18:42:17 +0000 | [diff] [blame] | 807 | } |
Douglas Gregor | b14904c | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 808 | |
Daniel Jasper | 0baec549 | 2012-06-06 08:32:04 +0000 | [diff] [blame] | 809 | if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, |
| 810 | SourceLocation()) |
| 811 | != DiagnosticsEngine::Ignored) { |
| 812 | RecordCompleteMap RecordsComplete; |
| 813 | RecordCompleteMap MNCComplete; |
| 814 | for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), |
| 815 | E = UnusedPrivateFields.end(); I != E; ++I) { |
| 816 | const NamedDecl *D = *I; |
| 817 | const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); |
| 818 | if (RD && !RD->isUnion() && |
| 819 | IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { |
| 820 | Diag(D->getLocation(), diag::warn_unused_private_field) |
| 821 | << D->getDeclName(); |
| 822 | } |
| 823 | } |
| 824 | } |
| 825 | |
Richard Smith | b2bc2e6 | 2011-02-21 20:05:19 +0000 | [diff] [blame] | 826 | // Check we've noticed that we're no longer parsing the initializer for every |
| 827 | // variable. If we miss cases, then at best we have a performance issue and |
| 828 | // at worst a rejects-valid bug. |
| 829 | assert(ParsingInitForAutoVars.empty() && |
| 830 | "Didn't unmark var as having its initializer parsed"); |
| 831 | |
Douglas Gregor | b14904c | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 832 | TUScope = 0; |
Chris Lattner | f440440 | 2008-08-23 03:19:52 +0000 | [diff] [blame] | 833 | } |
| 834 | |
| 835 | |
Chris Lattner | c11438c | 2006-08-18 05:17:52 +0000 | [diff] [blame] | 836 | //===----------------------------------------------------------------------===// |
Chris Lattner | eaafe122 | 2006-11-10 05:17:58 +0000 | [diff] [blame] | 837 | // Helper functions. |
| 838 | //===----------------------------------------------------------------------===// |
| 839 | |
Anders Carlsson | b26ab81 | 2009-08-08 17:45:02 +0000 | [diff] [blame] | 840 | DeclContext *Sema::getFunctionLevelDeclContext() { |
John McCall | b878801 | 2009-12-19 10:53:49 +0000 | [diff] [blame] | 841 | DeclContext *DC = CurContext; |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 842 | |
Eli Friedman | 73a0409 | 2012-01-07 04:59:52 +0000 | [diff] [blame] | 843 | while (true) { |
Tareq A. Siraj | 6dfa25a | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 844 | if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) { |
Eli Friedman | 73a0409 | 2012-01-07 04:59:52 +0000 | [diff] [blame] | 845 | DC = DC->getParent(); |
| 846 | } else if (isa<CXXMethodDecl>(DC) && |
Douglas Gregor | 1a22d28 | 2012-02-12 17:34:23 +0000 | [diff] [blame] | 847 | cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && |
Eli Friedman | 73a0409 | 2012-01-07 04:59:52 +0000 | [diff] [blame] | 848 | cast<CXXRecordDecl>(DC->getParent())->isLambda()) { |
| 849 | DC = DC->getParent()->getParent(); |
| 850 | } |
| 851 | else break; |
| 852 | } |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 853 | |
Anders Carlsson | b26ab81 | 2009-08-08 17:45:02 +0000 | [diff] [blame] | 854 | return DC; |
| 855 | } |
| 856 | |
Chris Lattner | 7941395 | 2008-12-04 23:50:19 +0000 | [diff] [blame] | 857 | /// getCurFunctionDecl - If inside of a function body, this returns a pointer |
| 858 | /// to the function decl for the function being parsed. If we're currently |
| 859 | /// in a 'block', this returns the containing context. |
| 860 | FunctionDecl *Sema::getCurFunctionDecl() { |
Anders Carlsson | b26ab81 | 2009-08-08 17:45:02 +0000 | [diff] [blame] | 861 | DeclContext *DC = getFunctionLevelDeclContext(); |
Chris Lattner | 7941395 | 2008-12-04 23:50:19 +0000 | [diff] [blame] | 862 | return dyn_cast<FunctionDecl>(DC); |
| 863 | } |
| 864 | |
Daniel Dunbar | 6e8aa53 | 2008-08-11 05:35:13 +0000 | [diff] [blame] | 865 | ObjCMethodDecl *Sema::getCurMethodDecl() { |
Anders Carlsson | b26ab81 | 2009-08-08 17:45:02 +0000 | [diff] [blame] | 866 | DeclContext *DC = getFunctionLevelDeclContext(); |
Fariborz Jahanian | deac9ac | 2013-05-31 21:51:12 +0000 | [diff] [blame] | 867 | while (isa<RecordDecl>(DC)) |
| 868 | DC = DC->getParent(); |
Steve Naroff | ecf2bb8 | 2008-11-17 16:28:52 +0000 | [diff] [blame] | 869 | return dyn_cast<ObjCMethodDecl>(DC); |
Daniel Dunbar | 6e8aa53 | 2008-08-11 05:35:13 +0000 | [diff] [blame] | 870 | } |
Chris Lattner | 7941395 | 2008-12-04 23:50:19 +0000 | [diff] [blame] | 871 | |
| 872 | NamedDecl *Sema::getCurFunctionOrMethodDecl() { |
Anders Carlsson | b26ab81 | 2009-08-08 17:45:02 +0000 | [diff] [blame] | 873 | DeclContext *DC = getFunctionLevelDeclContext(); |
Chris Lattner | 7941395 | 2008-12-04 23:50:19 +0000 | [diff] [blame] | 874 | if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) |
Douglas Gregor | 6e6ad60 | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 875 | return cast<NamedDecl>(DC); |
Chris Lattner | 7941395 | 2008-12-04 23:50:19 +0000 | [diff] [blame] | 876 | return 0; |
| 877 | } |
| 878 | |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 879 | void Sema::EmitCurrentDiagnostic(unsigned DiagID) { |
| 880 | // FIXME: It doesn't make sense to me that DiagID is an incoming argument here |
| 881 | // and yet we also use the current diag ID on the DiagnosticsEngine. This has |
| 882 | // been made more painfully obvious by the refactor that introduced this |
| 883 | // function, but it is possible that the incoming argument can be |
| 884 | // eliminnated. If it truly cannot be (for example, there is some reentrancy |
| 885 | // issue I am not seeing yet), then there should at least be a clarifying |
| 886 | // comment somewhere. |
David Blaikie | 05785d1 | 2013-02-20 22:23:23 +0000 | [diff] [blame] | 887 | if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 888 | switch (DiagnosticIDs::getDiagnosticSFINAEResponse( |
| 889 | Diags.getCurrentDiagID())) { |
Argyrios Kyrtzidis | d004064 | 2010-11-18 20:06:41 +0000 | [diff] [blame] | 890 | case DiagnosticIDs::SFINAE_Report: |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 891 | // We'll report the diagnostic below. |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 892 | break; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 893 | |
Argyrios Kyrtzidis | d004064 | 2010-11-18 20:06:41 +0000 | [diff] [blame] | 894 | case DiagnosticIDs::SFINAE_SubstitutionFailure: |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 895 | // Count this failure so that we know that template argument deduction |
| 896 | // has failed. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 897 | ++NumSFINAEErrors; |
Richard Smith | 9ca6461 | 2012-05-07 09:03:25 +0000 | [diff] [blame] | 898 | |
| 899 | // Make a copy of this suppressed diagnostic and store it with the |
| 900 | // template-deduction information. |
| 901 | if (*Info && !(*Info)->hasSFINAEDiagnostic()) { |
| 902 | Diagnostic DiagInfo(&Diags); |
| 903 | (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), |
| 904 | PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); |
| 905 | } |
| 906 | |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 907 | Diags.setLastDiagnosticIgnored(); |
| 908 | Diags.Clear(); |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 909 | return; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 910 | |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 911 | case DiagnosticIDs::SFINAE_AccessControl: { |
| 912 | // Per C++ Core Issue 1170, access control is part of SFINAE. |
Daniel Dunbar | a25002f | 2012-03-13 18:30:54 +0000 | [diff] [blame] | 913 | // Additionally, the AccessCheckingSFINAE flag can be used to temporarily |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 914 | // make access control a part of SFINAE for the purposes of checking |
| 915 | // type traits. |
Richard Smith | 2bf7fdb | 2013-01-02 11:42:31 +0000 | [diff] [blame] | 916 | if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 917 | break; |
| 918 | |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 919 | SourceLocation Loc = Diags.getCurrentDiagLoc(); |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 920 | |
| 921 | // Suppress this diagnostic. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 922 | ++NumSFINAEErrors; |
Richard Smith | 9ca6461 | 2012-05-07 09:03:25 +0000 | [diff] [blame] | 923 | |
| 924 | // Make a copy of this suppressed diagnostic and store it with the |
| 925 | // template-deduction information. |
| 926 | if (*Info && !(*Info)->hasSFINAEDiagnostic()) { |
| 927 | Diagnostic DiagInfo(&Diags); |
| 928 | (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), |
| 929 | PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); |
| 930 | } |
| 931 | |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 932 | Diags.setLastDiagnosticIgnored(); |
| 933 | Diags.Clear(); |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 934 | |
| 935 | // Now the diagnostic state is clear, produce a C++98 compatibility |
| 936 | // warning. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 937 | Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 938 | |
| 939 | // The last diagnostic which Sema produced was ignored. Suppress any |
| 940 | // notes attached to it. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 941 | Diags.setLastDiagnosticIgnored(); |
Richard Smith | 38c0e04 | 2011-10-19 00:07:01 +0000 | [diff] [blame] | 942 | return; |
| 943 | } |
| 944 | |
Argyrios Kyrtzidis | d004064 | 2010-11-18 20:06:41 +0000 | [diff] [blame] | 945 | case DiagnosticIDs::SFINAE_Suppress: |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 946 | // Make a copy of this suppressed diagnostic and store it with the |
| 947 | // template-deduction information; |
Richard Smith | 9ca6461 | 2012-05-07 09:03:25 +0000 | [diff] [blame] | 948 | if (*Info) { |
| 949 | Diagnostic DiagInfo(&Diags); |
Douglas Gregor | edb7685 | 2011-01-27 22:31:44 +0000 | [diff] [blame] | 950 | (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), |
Richard Smith | 9ca6461 | 2012-05-07 09:03:25 +0000 | [diff] [blame] | 951 | PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); |
| 952 | } |
| 953 | |
| 954 | // Suppress this diagnostic. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 955 | Diags.setLastDiagnosticIgnored(); |
| 956 | Diags.Clear(); |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 957 | return; |
| 958 | } |
| 959 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 960 | |
Douglas Gregor | 75acd92 | 2011-09-27 23:30:47 +0000 | [diff] [blame] | 961 | // Set up the context's printing policy based on our current state. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 962 | Context.setPrintingPolicy(getPrintingPolicy()); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 963 | |
Douglas Gregor | 5bb5e4a | 2010-10-12 23:32:35 +0000 | [diff] [blame] | 964 | // Emit the diagnostic. |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 965 | if (!Diags.EmitCurrentDiagnostic()) |
Douglas Gregor | 3383451 | 2009-06-14 07:33:30 +0000 | [diff] [blame] | 966 | return; |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 967 | |
Douglas Gregor | da17bd3 | 2009-03-20 22:48:49 +0000 | [diff] [blame] | 968 | // If this is not a note, and we're in a template instantiation |
| 969 | // that is different from the last template instantiation where |
| 970 | // we emitted an error, print a template instantiation |
| 971 | // backtrace. |
Argyrios Kyrtzidis | d004064 | 2010-11-18 20:06:41 +0000 | [diff] [blame] | 972 | if (!DiagnosticIDs::isBuiltinNote(DiagID) && |
Daniel Dunbar | d671ab9 | 2012-03-14 09:49:32 +0000 | [diff] [blame] | 973 | !ActiveTemplateInstantiations.empty() && |
| 974 | ActiveTemplateInstantiations.back() |
| 975 | != LastTemplateInstantiationErrorContext) { |
| 976 | PrintInstantiationStack(); |
| 977 | LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); |
Douglas Gregor | da17bd3 | 2009-03-20 22:48:49 +0000 | [diff] [blame] | 978 | } |
| 979 | } |
Douglas Gregor | c6d5edd | 2009-07-02 17:08:52 +0000 | [diff] [blame] | 980 | |
Anders Carlsson | f68079e | 2009-08-26 22:33:56 +0000 | [diff] [blame] | 981 | Sema::SemaDiagnosticBuilder |
| 982 | Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { |
| 983 | SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); |
| 984 | PD.Emit(Builder); |
Mike Stump | 11289f4 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 985 | |
Anders Carlsson | f68079e | 2009-08-26 22:33:56 +0000 | [diff] [blame] | 986 | return Builder; |
| 987 | } |
| 988 | |
Chandler Carruth | c22845a | 2011-07-26 05:40:03 +0000 | [diff] [blame] | 989 | /// \brief Looks through the macro-expansion chain for the given |
| 990 | /// location, looking for a macro expansion with the given name. |
John McCall | 462c055 | 2011-03-08 07:59:04 +0000 | [diff] [blame] | 991 | /// If one is found, returns true and sets the location to that |
Chandler Carruth | c22845a | 2011-07-26 05:40:03 +0000 | [diff] [blame] | 992 | /// expansion loc. |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 993 | bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { |
John McCall | 462c055 | 2011-03-08 07:59:04 +0000 | [diff] [blame] | 994 | SourceLocation loc = locref; |
| 995 | if (!loc.isMacroID()) return false; |
| 996 | |
| 997 | // There's no good way right now to look at the intermediate |
Chandler Carruth | c22845a | 2011-07-26 05:40:03 +0000 | [diff] [blame] | 998 | // expansions, so just jump to the expansion location. |
Chandler Carruth | 35f5320 | 2011-07-25 16:49:02 +0000 | [diff] [blame] | 999 | loc = getSourceManager().getExpansionLoc(loc); |
John McCall | 462c055 | 2011-03-08 07:59:04 +0000 | [diff] [blame] | 1000 | |
| 1001 | // If that's written with the name, stop here. |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 1002 | SmallVector<char, 16> buffer; |
John McCall | 462c055 | 2011-03-08 07:59:04 +0000 | [diff] [blame] | 1003 | if (getPreprocessor().getSpelling(loc, buffer) == name) { |
| 1004 | locref = loc; |
| 1005 | return true; |
| 1006 | } |
| 1007 | return false; |
| 1008 | } |
| 1009 | |
Douglas Gregor | 0be31a2 | 2010-07-02 17:43:08 +0000 | [diff] [blame] | 1010 | /// \brief Determines the active Scope associated with the given declaration |
| 1011 | /// context. |
| 1012 | /// |
| 1013 | /// This routine maps a declaration context to the active Scope object that |
| 1014 | /// represents that declaration context in the parser. It is typically used |
| 1015 | /// from "scope-less" code (e.g., template instantiation, lazy creation of |
| 1016 | /// declarations) that injects a name for name-lookup purposes and, therefore, |
| 1017 | /// must update the Scope. |
| 1018 | /// |
| 1019 | /// \returns The scope corresponding to the given declaraion context, or NULL |
| 1020 | /// if no such scope is open. |
| 1021 | Scope *Sema::getScopeForContext(DeclContext *Ctx) { |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1022 | |
Douglas Gregor | 0be31a2 | 2010-07-02 17:43:08 +0000 | [diff] [blame] | 1023 | if (!Ctx) |
| 1024 | return 0; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1025 | |
Douglas Gregor | 0be31a2 | 2010-07-02 17:43:08 +0000 | [diff] [blame] | 1026 | Ctx = Ctx->getPrimaryContext(); |
| 1027 | for (Scope *S = getCurScope(); S; S = S->getParent()) { |
Sebastian Redl | caef9ab | 2010-07-08 23:07:34 +0000 | [diff] [blame] | 1028 | // Ignore scopes that cannot have declarations. This is important for |
| 1029 | // out-of-line definitions of static class members. |
| 1030 | if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) |
Ted Kremenek | c37877d | 2013-10-08 17:08:03 +0000 | [diff] [blame] | 1031 | if (DeclContext *Entity = S->getEntity()) |
Sebastian Redl | caef9ab | 2010-07-08 23:07:34 +0000 | [diff] [blame] | 1032 | if (Ctx == Entity->getPrimaryContext()) |
| 1033 | return S; |
Douglas Gregor | 0be31a2 | 2010-07-02 17:43:08 +0000 | [diff] [blame] | 1034 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1035 | |
Douglas Gregor | 0be31a2 | 2010-07-02 17:43:08 +0000 | [diff] [blame] | 1036 | return 0; |
| 1037 | } |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1038 | |
| 1039 | /// \brief Enter a new function scope |
| 1040 | void Sema::PushFunctionScope() { |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 1041 | if (FunctionScopes.size() == 1) { |
| 1042 | // Use the "top" function scope rather than having to allocate |
| 1043 | // memory for a new scope. |
Argyrios Kyrtzidis | f51ec1d | 2010-11-19 00:19:15 +0000 | [diff] [blame] | 1044 | FunctionScopes.back()->Clear(); |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 1045 | FunctionScopes.push_back(FunctionScopes.back()); |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1046 | return; |
| 1047 | } |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1048 | |
Argyrios Kyrtzidis | f51ec1d | 2010-11-19 00:19:15 +0000 | [diff] [blame] | 1049 | FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1050 | } |
| 1051 | |
| 1052 | void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { |
Argyrios Kyrtzidis | f51ec1d | 2010-11-19 00:19:15 +0000 | [diff] [blame] | 1053 | FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1054 | BlockScope, Block)); |
| 1055 | } |
| 1056 | |
Faisal Vali | 97d8c33 | 2013-11-12 01:46:33 +0000 | [diff] [blame] | 1057 | LambdaScopeInfo *Sema::PushLambdaScope() { |
Faisal Vali | 524ca28 | 2013-11-12 01:40:44 +0000 | [diff] [blame] | 1058 | LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); |
| 1059 | FunctionScopes.push_back(LSI); |
| 1060 | return LSI; |
Faisal Vali | 2b391ab | 2013-09-26 19:54:12 +0000 | [diff] [blame] | 1061 | } |
| 1062 | |
| 1063 | void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { |
| 1064 | if (LambdaScopeInfo *const LSI = getCurLambda()) { |
| 1065 | LSI->AutoTemplateParameterDepth = Depth; |
| 1066 | return; |
| 1067 | } |
| 1068 | llvm_unreachable( |
| 1069 | "Remove assertion if intentionally called in a non-lambda context."); |
Eli Friedman | 71c8055 | 2012-01-05 03:35:19 +0000 | [diff] [blame] | 1070 | } |
| 1071 | |
| 1072 | void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, |
| 1073 | const Decl *D, const BlockExpr *blkExpr) { |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1074 | FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 1075 | assert(!FunctionScopes.empty() && "mismatched push/pop!"); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1076 | |
Ted Kremenek | 1767a27 | 2011-02-23 01:51:48 +0000 | [diff] [blame] | 1077 | // Issue any analysis-based warnings. |
| 1078 | if (WP && D) |
Ted Kremenek | cc7f1f8 | 2011-02-23 01:51:53 +0000 | [diff] [blame] | 1079 | AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); |
Ted Kremenek | 3427fac | 2011-02-23 01:52:04 +0000 | [diff] [blame] | 1080 | else { |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 1081 | for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator |
Ted Kremenek | 3427fac | 2011-02-23 01:52:04 +0000 | [diff] [blame] | 1082 | i = Scope->PossiblyUnreachableDiags.begin(), |
| 1083 | e = Scope->PossiblyUnreachableDiags.end(); |
| 1084 | i != e; ++i) { |
| 1085 | const sema::PossiblyUnreachableDiag &D = *i; |
| 1086 | Diag(D.Loc, D.PD); |
| 1087 | } |
| 1088 | } |
Ted Kremenek | 1767a27 | 2011-02-23 01:51:48 +0000 | [diff] [blame] | 1089 | |
Ted Kremenek | 3427fac | 2011-02-23 01:52:04 +0000 | [diff] [blame] | 1090 | if (FunctionScopes.back() != Scope) { |
John McCall | aab3e41 | 2010-08-25 08:40:02 +0000 | [diff] [blame] | 1091 | delete Scope; |
Ted Kremenek | 3427fac | 2011-02-23 01:52:04 +0000 | [diff] [blame] | 1092 | } |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1093 | } |
| 1094 | |
Dmitri Gribenko | 800ddf3 | 2012-02-14 22:14:32 +0000 | [diff] [blame] | 1095 | void Sema::PushCompoundScope() { |
| 1096 | getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); |
| 1097 | } |
| 1098 | |
| 1099 | void Sema::PopCompoundScope() { |
| 1100 | FunctionScopeInfo *CurFunction = getCurFunction(); |
| 1101 | assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); |
| 1102 | |
| 1103 | CurFunction->CompoundScopes.pop_back(); |
| 1104 | } |
| 1105 | |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1106 | /// \brief Determine whether any errors occurred within this function/method/ |
| 1107 | /// block. |
John McCall | 31168b0 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1108 | bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { |
| 1109 | return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1110 | } |
| 1111 | |
| 1112 | BlockScopeInfo *Sema::getCurBlock() { |
| 1113 | if (FunctionScopes.empty()) |
| 1114 | return 0; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1115 | |
| 1116 | return dyn_cast<BlockScopeInfo>(FunctionScopes.back()); |
Douglas Gregor | 9a28e84 | 2010-03-01 23:15:13 +0000 | [diff] [blame] | 1117 | } |
John McCall | 75b960e | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1118 | |
Eli Friedman | 4817cf7 | 2012-01-06 03:05:34 +0000 | [diff] [blame] | 1119 | LambdaScopeInfo *Sema::getCurLambda() { |
| 1120 | if (FunctionScopes.empty()) |
| 1121 | return 0; |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1122 | |
| 1123 | return dyn_cast<LambdaScopeInfo>(FunctionScopes.back()); |
Eli Friedman | 4817cf7 | 2012-01-06 03:05:34 +0000 | [diff] [blame] | 1124 | } |
Faisal Vali | 2b391ab | 2013-09-26 19:54:12 +0000 | [diff] [blame] | 1125 | // We have a generic lambda if we parsed auto parameters, or we have |
| 1126 | // an associated template parameter list. |
| 1127 | LambdaScopeInfo *Sema::getCurGenericLambda() { |
| 1128 | if (LambdaScopeInfo *LSI = getCurLambda()) { |
| 1129 | return (LSI->AutoTemplateParams.size() || |
| 1130 | LSI->GLTemplateParameterList) ? LSI : 0; |
| 1131 | } |
| 1132 | return 0; |
| 1133 | } |
| 1134 | |
Eli Friedman | 4817cf7 | 2012-01-06 03:05:34 +0000 | [diff] [blame] | 1135 | |
Dmitri Gribenko | aab8383 | 2012-06-20 00:34:58 +0000 | [diff] [blame] | 1136 | void Sema::ActOnComment(SourceRange Comment) { |
Ted Kremenek | b47e6bc | 2012-09-13 06:41:18 +0000 | [diff] [blame] | 1137 | if (!LangOpts.RetainCommentsFromSystemHeaders && |
| 1138 | SourceMgr.isInSystemHeader(Comment.getBegin())) |
| 1139 | return; |
Dmitri Gribenko | a7d16ce | 2013-04-10 15:35:17 +0000 | [diff] [blame] | 1140 | RawComment RC(SourceMgr, Comment, false, |
| 1141 | LangOpts.CommentOpts.ParseAllComments); |
Dmitri Gribenko | 052f60d | 2012-06-22 16:02:55 +0000 | [diff] [blame] | 1142 | if (RC.isAlmostTrailingComment()) { |
| 1143 | SourceRange MagicMarkerRange(Comment.getBegin(), |
| 1144 | Comment.getBegin().getLocWithOffset(3)); |
| 1145 | StringRef MagicMarkerText; |
| 1146 | switch (RC.getKind()) { |
Abramo Bagnara | e06a888 | 2012-07-04 07:30:26 +0000 | [diff] [blame] | 1147 | case RawComment::RCK_OrdinaryBCPL: |
Dmitri Gribenko | 052f60d | 2012-06-22 16:02:55 +0000 | [diff] [blame] | 1148 | MagicMarkerText = "///<"; |
| 1149 | break; |
Abramo Bagnara | e06a888 | 2012-07-04 07:30:26 +0000 | [diff] [blame] | 1150 | case RawComment::RCK_OrdinaryC: |
Dmitri Gribenko | 052f60d | 2012-06-22 16:02:55 +0000 | [diff] [blame] | 1151 | MagicMarkerText = "/**<"; |
| 1152 | break; |
| 1153 | default: |
| 1154 | llvm_unreachable("if this is an almost Doxygen comment, " |
| 1155 | "it should be ordinary"); |
| 1156 | } |
| 1157 | Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << |
| 1158 | FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); |
| 1159 | } |
Dmitri Gribenko | aab8383 | 2012-06-20 00:34:58 +0000 | [diff] [blame] | 1160 | Context.addComment(RC); |
| 1161 | } |
| 1162 | |
John McCall | 75b960e | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1163 | // Pin this vtable to this file. |
| 1164 | ExternalSemaSource::~ExternalSemaSource() {} |
John McCall | faf5fb4 | 2010-08-26 23:41:50 +0000 | [diff] [blame] | 1165 | |
Douglas Gregor | e171601 | 2012-01-25 00:49:42 +0000 | [diff] [blame] | 1166 | void ExternalSemaSource::ReadMethodPool(Selector Sel) { } |
Sebastian Redl | c1ca90a | 2010-09-28 20:23:00 +0000 | [diff] [blame] | 1167 | |
Douglas Gregor | c2fa169 | 2011-06-28 16:20:02 +0000 | [diff] [blame] | 1168 | void ExternalSemaSource::ReadKnownNamespaces( |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1169 | SmallVectorImpl<NamespaceDecl *> &Namespaces) { |
Douglas Gregor | c2fa169 | 2011-06-28 16:20:02 +0000 | [diff] [blame] | 1170 | } |
| 1171 | |
Nick Lewycky | 9c7eb1d | 2013-02-01 08:13:20 +0000 | [diff] [blame] | 1172 | void ExternalSemaSource::ReadUndefinedButUsed( |
Nick Lewycky | f0f5616 | 2013-01-31 03:23:57 +0000 | [diff] [blame] | 1173 | llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) { |
Nick Lewycky | 8334af8 | 2013-01-26 00:35:08 +0000 | [diff] [blame] | 1174 | } |
| 1175 | |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 1176 | void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { |
John McCall | faf5fb4 | 2010-08-26 23:41:50 +0000 | [diff] [blame] | 1177 | SourceLocation Loc = this->Loc; |
| 1178 | if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); |
| 1179 | if (Loc.isValid()) { |
| 1180 | Loc.print(OS, S.getSourceManager()); |
| 1181 | OS << ": "; |
| 1182 | } |
| 1183 | OS << Message; |
| 1184 | |
| 1185 | if (TheDecl && isa<NamedDecl>(TheDecl)) { |
| 1186 | std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString(); |
| 1187 | if (!Name.empty()) |
| 1188 | OS << " '" << Name << '\''; |
| 1189 | } |
| 1190 | |
| 1191 | OS << '\n'; |
| 1192 | } |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1193 | |
| 1194 | /// \brief Figure out if an expression could be turned into a call. |
| 1195 | /// |
| 1196 | /// Use this when trying to recover from an error where the programmer may have |
| 1197 | /// written just the name of a function instead of actually calling it. |
| 1198 | /// |
| 1199 | /// \param E - The expression to examine. |
| 1200 | /// \param ZeroArgCallReturnTy - If the expression can be turned into a call |
| 1201 | /// with no arguments, this parameter is set to the type returned by such a |
| 1202 | /// call; otherwise, it is set to an empty QualType. |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1203 | /// \param OverloadSet - If the expression is an overloaded function |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1204 | /// name, this parameter is populated with the decls of the various overloads. |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1205 | bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, |
| 1206 | UnresolvedSetImpl &OverloadSet) { |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1207 | ZeroArgCallReturnTy = QualType(); |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1208 | OverloadSet.clear(); |
| 1209 | |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1210 | const OverloadExpr *Overloads = NULL; |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1211 | bool IsMemExpr = false; |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1212 | if (E.getType() == Context.OverloadTy) { |
| 1213 | OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E)); |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1214 | |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1215 | // Ignore overloads that are pointer-to-member constants. |
| 1216 | if (FR.HasFormOfMemberPointer) |
| 1217 | return false; |
| 1218 | |
| 1219 | Overloads = FR.Expression; |
| 1220 | } else if (E.getType() == Context.BoundMemberTy) { |
| 1221 | Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens()); |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1222 | IsMemExpr = true; |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1223 | } |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1224 | |
| 1225 | bool Ambiguous = false; |
| 1226 | |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1227 | if (Overloads) { |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1228 | for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), |
| 1229 | DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1230 | OverloadSet.addDecl(*it); |
| 1231 | |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1232 | // Check whether the function is a non-template, non-member which takes no |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1233 | // arguments. |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1234 | if (IsMemExpr) |
| 1235 | continue; |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1236 | if (const FunctionDecl *OverloadDecl |
| 1237 | = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) { |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1238 | if (OverloadDecl->getMinRequiredArguments() == 0) { |
| 1239 | if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) { |
| 1240 | ZeroArgCallReturnTy = QualType(); |
| 1241 | Ambiguous = true; |
| 1242 | } else |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 1243 | ZeroArgCallReturnTy = OverloadDecl->getReturnType(); |
David Blaikie | 6df859d8 | 2013-06-04 00:28:46 +0000 | [diff] [blame] | 1244 | } |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1245 | } |
| 1246 | } |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1247 | |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1248 | // If it's not a member, use better machinery to try to resolve the call |
| 1249 | if (!IsMemExpr) |
| 1250 | return !ZeroArgCallReturnTy.isNull(); |
| 1251 | } |
| 1252 | |
| 1253 | // Attempt to call the member with no arguments - this will correctly handle |
| 1254 | // member templates with defaults/deduction of template arguments, overloads |
| 1255 | // with default arguments, etc. |
Eli Friedman | 544c956 | 2013-07-08 23:35:04 +0000 | [diff] [blame] | 1256 | if (IsMemExpr && !E.isTypeDependent()) { |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1257 | bool Suppress = getDiagnostics().getSuppressAllDiagnostics(); |
| 1258 | getDiagnostics().setSuppressAllDiagnostics(true); |
| 1259 | ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None, |
| 1260 | SourceLocation()); |
| 1261 | getDiagnostics().setSuppressAllDiagnostics(Suppress); |
| 1262 | if (R.isUsable()) { |
| 1263 | ZeroArgCallReturnTy = R.get()->getType(); |
| 1264 | return true; |
| 1265 | } |
| 1266 | return false; |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1267 | } |
| 1268 | |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1269 | if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) { |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1270 | if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) { |
| 1271 | if (Fun->getMinRequiredArguments() == 0) |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 1272 | ZeroArgCallReturnTy = Fun->getReturnType(); |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1273 | return true; |
| 1274 | } |
| 1275 | } |
| 1276 | |
| 1277 | // We don't have an expression that's convenient to get a FunctionDecl from, |
| 1278 | // but we can at least check if the type is "function of 0 arguments". |
| 1279 | QualType ExprTy = E.getType(); |
| 1280 | const FunctionType *FunTy = NULL; |
Matt Beaumont-Gay | 330a5b4 | 2011-05-05 00:59:35 +0000 | [diff] [blame] | 1281 | QualType PointeeTy = ExprTy->getPointeeType(); |
| 1282 | if (!PointeeTy.isNull()) |
| 1283 | FunTy = PointeeTy->getAs<FunctionType>(); |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1284 | if (!FunTy) |
| 1285 | FunTy = ExprTy->getAs<FunctionType>(); |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1286 | |
| 1287 | if (const FunctionProtoType *FPT = |
| 1288 | dyn_cast_or_null<FunctionProtoType>(FunTy)) { |
Alp Toker | 9cacbab | 2014-01-20 20:26:09 +0000 | [diff] [blame] | 1289 | if (FPT->getNumParams() == 0) |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 1290 | ZeroArgCallReturnTy = FunTy->getReturnType(); |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1291 | return true; |
| 1292 | } |
| 1293 | return false; |
| 1294 | } |
| 1295 | |
| 1296 | /// \brief Give notes for a set of overloads. |
| 1297 | /// |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1298 | /// A companion to tryExprAsCall. In cases when the name that the programmer |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1299 | /// wrote was an overloaded function, we may be able to make some guesses about |
| 1300 | /// plausible overloads based on their return types; such guesses can be handed |
| 1301 | /// off to this method to be emitted as notes. |
| 1302 | /// |
| 1303 | /// \param Overloads - The overloads to note. |
| 1304 | /// \param FinalNoteLoc - If we've suppressed printing some overloads due to |
| 1305 | /// -fshow-overloads=best, this is the location to attach to the note about too |
| 1306 | /// many candidates. Typically this will be the location of the original |
| 1307 | /// ill-formed expression. |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1308 | static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, |
| 1309 | const SourceLocation FinalNoteLoc) { |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1310 | int ShownOverloads = 0; |
| 1311 | int SuppressedOverloads = 0; |
| 1312 | for (UnresolvedSetImpl::iterator It = Overloads.begin(), |
| 1313 | DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { |
| 1314 | // FIXME: Magic number for max shown overloads stolen from |
| 1315 | // OverloadCandidateSet::NoteCandidates. |
Douglas Gregor | 7959178 | 2012-10-23 23:11:23 +0000 | [diff] [blame] | 1316 | if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1317 | ++SuppressedOverloads; |
| 1318 | continue; |
| 1319 | } |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1320 | |
| 1321 | NamedDecl *Fn = (*It)->getUnderlyingDecl(); |
Abramo Bagnara | dc1646d | 2011-11-15 21:43:28 +0000 | [diff] [blame] | 1322 | S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1323 | ++ShownOverloads; |
| 1324 | } |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1325 | |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1326 | if (SuppressedOverloads) |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1327 | S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) |
| 1328 | << SuppressedOverloads; |
| 1329 | } |
| 1330 | |
| 1331 | static void notePlausibleOverloads(Sema &S, SourceLocation Loc, |
| 1332 | const UnresolvedSetImpl &Overloads, |
| 1333 | bool (*IsPlausibleResult)(QualType)) { |
| 1334 | if (!IsPlausibleResult) |
| 1335 | return noteOverloads(S, Overloads, Loc); |
| 1336 | |
| 1337 | UnresolvedSet<2> PlausibleOverloads; |
| 1338 | for (OverloadExpr::decls_iterator It = Overloads.begin(), |
| 1339 | DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { |
| 1340 | const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It); |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 1341 | QualType OverloadResultTy = OverloadDecl->getReturnType(); |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1342 | if (IsPlausibleResult(OverloadResultTy)) |
| 1343 | PlausibleOverloads.addDecl(It.getDecl()); |
| 1344 | } |
| 1345 | noteOverloads(S, PlausibleOverloads, Loc); |
| 1346 | } |
| 1347 | |
| 1348 | /// Determine whether the given expression can be called by just |
| 1349 | /// putting parentheses after it. Notably, expressions with unary |
| 1350 | /// operators can't be because the unary operator will start parsing |
| 1351 | /// outside the call. |
| 1352 | static bool IsCallableWithAppend(Expr *E) { |
| 1353 | E = E->IgnoreImplicit(); |
| 1354 | return (!isa<CStyleCastExpr>(E) && |
| 1355 | !isa<UnaryOperator>(E) && |
| 1356 | !isa<BinaryOperator>(E) && |
| 1357 | !isa<CXXOperatorCallExpr>(E)); |
| 1358 | } |
| 1359 | |
| 1360 | bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, |
| 1361 | bool ForceComplain, |
| 1362 | bool (*IsPlausibleResult)(QualType)) { |
| 1363 | SourceLocation Loc = E.get()->getExprLoc(); |
| 1364 | SourceRange Range = E.get()->getSourceRange(); |
| 1365 | |
| 1366 | QualType ZeroArgCallTy; |
| 1367 | UnresolvedSet<4> Overloads; |
David Blaikie | e5323aa | 2013-06-21 23:54:45 +0000 | [diff] [blame] | 1368 | if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1369 | !ZeroArgCallTy.isNull() && |
| 1370 | (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { |
| 1371 | // At this point, we know E is potentially callable with 0 |
| 1372 | // arguments and that it returns something of a reasonable type, |
| 1373 | // so we can emit a fixit and carry on pretending that E was |
| 1374 | // actually a CallExpr. |
Nick Lewycky | 1e43d95 | 2013-08-21 19:09:44 +0000 | [diff] [blame] | 1375 | SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd()); |
Michael Gottesman | bf0fd39 | 2013-01-20 01:04:14 +0000 | [diff] [blame] | 1376 | Diag(Loc, PD) |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1377 | << /*zero-arg*/ 1 << Range |
| 1378 | << (IsCallableWithAppend(E.get()) |
| 1379 | ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") |
| 1380 | : FixItHint()); |
| 1381 | notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); |
| 1382 | |
| 1383 | // FIXME: Try this before emitting the fixit, and suppress diagnostics |
| 1384 | // while doing so. |
Nick Lewycky | 1e43d95 | 2013-08-21 19:09:44 +0000 | [diff] [blame] | 1385 | E = ActOnCallExpr(0, E.take(), Range.getEnd(), None, |
| 1386 | Range.getEnd().getLocWithOffset(1)); |
John McCall | 50a2c2c | 2011-10-11 23:14:30 +0000 | [diff] [blame] | 1387 | return true; |
| 1388 | } |
| 1389 | |
| 1390 | if (!ForceComplain) return false; |
| 1391 | |
| 1392 | Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; |
| 1393 | notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); |
| 1394 | E = ExprError(); |
| 1395 | return true; |
Matt Beaumont-Gay | 3c27391 | 2011-05-04 22:10:40 +0000 | [diff] [blame] | 1396 | } |
Argyrios Kyrtzidis | 3e56dd4 | 2013-03-14 22:56:43 +0000 | [diff] [blame] | 1397 | |
| 1398 | IdentifierInfo *Sema::getSuperIdentifier() const { |
| 1399 | if (!Ident_super) |
| 1400 | Ident_super = &Context.Idents.get("super"); |
| 1401 | return Ident_super; |
| 1402 | } |
Tareq A. Siraj | 6dfa25a | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 1403 | |
Nico Weber | e1687c5 | 2013-06-20 21:44:55 +0000 | [diff] [blame] | 1404 | IdentifierInfo *Sema::getFloat128Identifier() const { |
| 1405 | if (!Ident___float128) |
| 1406 | Ident___float128 = &Context.Idents.get("__float128"); |
| 1407 | return Ident___float128; |
| 1408 | } |
| 1409 | |
Tareq A. Siraj | 6dfa25a | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 1410 | void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, |
Ben Langmuir | e7d7c4c | 2013-04-29 13:32:41 +0000 | [diff] [blame] | 1411 | CapturedRegionKind K) { |
Ben Langmuir | 37943a7 | 2013-05-03 19:00:33 +0000 | [diff] [blame] | 1412 | CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD, |
| 1413 | CD->getContextParam(), K); |
Tareq A. Siraj | 6dfa25a | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 1414 | CSI->ReturnType = Context.VoidTy; |
| 1415 | FunctionScopes.push_back(CSI); |
| 1416 | } |
| 1417 | |
| 1418 | CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { |
| 1419 | if (FunctionScopes.empty()) |
| 1420 | return 0; |
| 1421 | |
| 1422 | return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back()); |
| 1423 | } |