Bug Summary

File:tools/clang/include/clang/Sema/Sema.h
Warning:line 274, column 7
Excessive padding in 'class clang::Sema' (75 padding bytes, where 3 is optimal). Optimal fields order: ExternalSource, LangOpts, PP, Context, Consumer, Diags, SourceMgr, CodeCompleter, CurContext, OriginalLexicalContext, VAListTagName, CurInitSeg, VisContext, PragmaAttributeCurrentTargetDecl, PreallocatedFunctionScope, FieldCollector, PureVirtualClassDiagSet, LateTemplateParser, LateTemplateParserCleanup, OpaqueParser, DelayedDiagnostics, TUScope, StdNamespace, StdBadAlloc, StdAlignValT, StdExperimentalNamespaceCache, StdInitializerList, CXXTypeInfoDecl, MSVCGuidDecl, NSAPIObj, NSNumberDecl, NSValueDecl, NSNumberPointer, NSValuePointer, NSStringDecl, NSStringPointer, StringWithUTF8StringMethod, ValueWithBytesObjCTypeMethod, NSArrayDecl, ArrayWithObjectsMethod, NSDictionaryDecl, DictionaryWithObjectsMethod, QIDNSCopying, RespondsToSelectorSel, CXXThisTypeOverride, CurrentInstantiationScope, ThreadSafetyDeclCache, VarDataSharingAttributesStack, TypeTagForDatatypeMagicValues, CurScope, Ident_super, Ident___float128, Ident__Nonnull, Ident__Nullable, Ident__Null_unspecified, Ident_NSError, SemaPPCallbackHandler, CFError, IdResolver, SpecialMemberCache, TemplateInstCallbacks, OpenCLFeatures, ExtnameUndeclaredIdentifiers, FlagBitsCache, UnparsedDefaultArgInstantiations, UnparsedDefaultArgLocs, MethodPool, VisibleModules, ShadowingDecls, VTablesUsed, InstantiatingSpecializations, InstantiatedNonDependentTypes, LookupModulesCache, VisibleNamespaceCache, SuppressedDiagnostics, TypoCorrectionFailures, CurrOpenCLExtension, OpenCLTypeExtMap, OpenCLDeclExtMap, CUDADeferredDiags, LocsWithCUDACallDiags, CUDAKnownEmittedFns, CUDACallGraph, CurrentSEHFinally, PragmaClangBSSSection, PragmaClangDataSection, PragmaClangRodataSection, PragmaClangTextSection, WeakTopLevelDecl, NullabilityMap, LateParsedInstantiations, MaybeODRUseExprs, FunctionScopes, DeleteExprs, DelayedExceptionSpecChecks, DelayedDefaultedMemberExceptionSpecs, LateParsedTemplateMap, WeakUndeclaredIdentifiers, UndefinedButUsed, ReferencedSelectors, CurrentParameterCopyTypes, DelayedTypos, KnownNamespaces, DelayedDllExportClasses, ParsingInitForAutoVars, SpecialMembersBeingDeclared, TypoCorrectedFunctionDefinitions, ExtVectorDecls, TentativeDefinitions, UnusedFileScopedDecls, DelegatingCtorDecls, PendingInstantiations, PendingLocalImplicitInstantiations, ExprCleanupObjects, AnalysisWarnings, VtorDispStack, PackStack, UnusedLocalTypedefNameCandidates, DataSegStack, BSSSegStack, ConstSegStack, CodeSegStack, PackIncludeStack, NSNumberLiteralMethods, BumpAlloc, PragmaAttributeStack, CodeSynthesisContextLookupModules, MisalignedMembers, VTableUses, UnusedPrivateFields, ModuleScopes, CodeSynthesisContexts, ExprEvalContexts, FPFeatures, MSPointerToMemberRepresentationMethod, ImplicitMSInheritanceAttrLoc, CurInitSegLoc, OptimizeOffPragmaLocation, TUKind, NumSFINAEErrors, NonInstantiationEntries, LastEmittedCodeSynthesisContextDepth, ArgumentPackSubstitutionIndex, TyposCorrected, ForceCUDAHostDeviceDepth, isMultiplexExternalSource, CollectStats, MSStructPragmaOn, IsBuildingRecoveryCallExpr, GlobalNewDeleteDeclared, AllowAbstractFieldReference, LoadedExternalKnownNamespaces, AccessCheckingSFINAE, InNonInstantiationSFINAEContext, DisableTypoCorrection, IsInOpenMPDeclareTargetContext, Cleanup, consider reordering the fields or adding explicit padding members

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CodeGenABITypes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/CodeGen -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenABITypes.cpp
1//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_SEMA_SEMA_H
16#define LLVM_CLANG_SEMA_SEMA_H
17
18#include "clang/AST/Attr.h"
19#include "clang/AST/Availability.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprObjC.h"
24#include "clang/AST/ExternalASTSource.h"
25#include "clang/AST/LocInfoType.h"
26#include "clang/AST/MangleNumberingContext.h"
27#include "clang/AST/NSAPI.h"
28#include "clang/AST/PrettyPrinter.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/TypeLoc.h"
31#include "clang/AST/TypeOrdering.h"
32#include "clang/Basic/ExpressionTraits.h"
33#include "clang/Basic/Module.h"
34#include "clang/Basic/OpenMPKinds.h"
35#include "clang/Basic/PragmaKinds.h"
36#include "clang/Basic/Specifiers.h"
37#include "clang/Basic/TemplateKinds.h"
38#include "clang/Basic/TypeTraits.h"
39#include "clang/Sema/AnalysisBasedWarnings.h"
40#include "clang/Sema/CleanupInfo.h"
41#include "clang/Sema/DeclSpec.h"
42#include "clang/Sema/ExternalSemaSource.h"
43#include "clang/Sema/IdentifierResolver.h"
44#include "clang/Sema/ObjCMethodList.h"
45#include "clang/Sema/Ownership.h"
46#include "clang/Sema/Scope.h"
47#include "clang/Sema/TypoCorrection.h"
48#include "clang/Sema/Weak.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/Optional.h"
51#include "llvm/ADT/SetVector.h"
52#include "llvm/ADT/SmallPtrSet.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/ADT/TinyPtrVector.h"
55#include <deque>
56#include <memory>
57#include <string>
58#include <vector>
59
60namespace llvm {
61 class APSInt;
62 template <typename ValueT> struct DenseMapInfo;
63 template <typename ValueT, typename ValueInfoT> class DenseSet;
64 class SmallBitVector;
65 struct InlineAsmIdentifierInfo;
66}
67
68namespace clang {
69 class ADLResult;
70 class ASTConsumer;
71 class ASTContext;
72 class ASTMutationListener;
73 class ASTReader;
74 class ASTWriter;
75 class ArrayType;
76 class AttributeList;
77 class BindingDecl;
78 class BlockDecl;
79 class CapturedDecl;
80 class CXXBasePath;
81 class CXXBasePaths;
82 class CXXBindTemporaryExpr;
83 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
84 class CXXConstructorDecl;
85 class CXXConversionDecl;
86 class CXXDeleteExpr;
87 class CXXDestructorDecl;
88 class CXXFieldCollector;
89 class CXXMemberCallExpr;
90 class CXXMethodDecl;
91 class CXXScopeSpec;
92 class CXXTemporary;
93 class CXXTryStmt;
94 class CallExpr;
95 class ClassTemplateDecl;
96 class ClassTemplatePartialSpecializationDecl;
97 class ClassTemplateSpecializationDecl;
98 class VarTemplatePartialSpecializationDecl;
99 class CodeCompleteConsumer;
100 class CodeCompletionAllocator;
101 class CodeCompletionTUInfo;
102 class CodeCompletionResult;
103 class CoroutineBodyStmt;
104 class Decl;
105 class DeclAccessPair;
106 class DeclContext;
107 class DeclRefExpr;
108 class DeclaratorDecl;
109 class DeducedTemplateArgument;
110 class DependentDiagnostic;
111 class DesignatedInitExpr;
112 class Designation;
113 class EnableIfAttr;
114 class EnumConstantDecl;
115 class Expr;
116 class ExtVectorType;
117 class FormatAttr;
118 class FriendDecl;
119 class FunctionDecl;
120 class FunctionProtoType;
121 class FunctionTemplateDecl;
122 class ImplicitConversionSequence;
123 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
124 class InitListExpr;
125 class InitializationKind;
126 class InitializationSequence;
127 class InitializedEntity;
128 class IntegerLiteral;
129 class LabelStmt;
130 class LambdaExpr;
131 class LangOptions;
132 class LocalInstantiationScope;
133 class LookupResult;
134 class MacroInfo;
135 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
136 class ModuleLoader;
137 class MultiLevelTemplateArgumentList;
138 class NamedDecl;
139 class ObjCCategoryDecl;
140 class ObjCCategoryImplDecl;
141 class ObjCCompatibleAliasDecl;
142 class ObjCContainerDecl;
143 class ObjCImplDecl;
144 class ObjCImplementationDecl;
145 class ObjCInterfaceDecl;
146 class ObjCIvarDecl;
147 template <class T> class ObjCList;
148 class ObjCMessageExpr;
149 class ObjCMethodDecl;
150 class ObjCPropertyDecl;
151 class ObjCProtocolDecl;
152 class OMPThreadPrivateDecl;
153 class OMPDeclareReductionDecl;
154 class OMPDeclareSimdDecl;
155 class OMPClause;
156 struct OverloadCandidate;
157 class OverloadCandidateSet;
158 class OverloadExpr;
159 class ParenListExpr;
160 class ParmVarDecl;
161 class Preprocessor;
162 class PseudoDestructorTypeStorage;
163 class PseudoObjectExpr;
164 class QualType;
165 class StandardConversionSequence;
166 class Stmt;
167 class StringLiteral;
168 class SwitchStmt;
169 class TemplateArgument;
170 class TemplateArgumentList;
171 class TemplateArgumentLoc;
172 class TemplateDecl;
173 class TemplateInstantiationCallback;
174 class TemplateParameterList;
175 class TemplatePartialOrderingContext;
176 class TemplateTemplateParmDecl;
177 class Token;
178 class TypeAliasDecl;
179 class TypedefDecl;
180 class TypedefNameDecl;
181 class TypeLoc;
182 class TypoCorrectionConsumer;
183 class UnqualifiedId;
184 class UnresolvedLookupExpr;
185 class UnresolvedMemberExpr;
186 class UnresolvedSetImpl;
187 class UnresolvedSetIterator;
188 class UsingDecl;
189 class UsingShadowDecl;
190 class ValueDecl;
191 class VarDecl;
192 class VarTemplateSpecializationDecl;
193 class VisibilityAttr;
194 class VisibleDeclConsumer;
195 class IndirectFieldDecl;
196 struct DeductionFailureInfo;
197 class TemplateSpecCandidateSet;
198
199namespace sema {
200 class AccessedEntity;
201 class BlockScopeInfo;
202 class Capture;
203 class CapturedRegionScopeInfo;
204 class CapturingScopeInfo;
205 class CompoundScopeInfo;
206 class DelayedDiagnostic;
207 class DelayedDiagnosticPool;
208 class FunctionScopeInfo;
209 class LambdaScopeInfo;
210 class PossiblyUnreachableDiag;
211 class SemaPPCallbacks;
212 class TemplateDeductionInfo;
213}
214
215namespace threadSafety {
216 class BeforeSet;
217 void threadSafetyCleanup(BeforeSet* Cache);
218}
219
220// FIXME: No way to easily map from TemplateTypeParmTypes to
221// TemplateTypeParmDecls, so we have this horrible PointerUnion.
222typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
223 SourceLocation> UnexpandedParameterPack;
224
225/// Describes whether we've seen any nullability information for the given
226/// file.
227struct FileNullability {
228 /// The first pointer declarator (of any pointer kind) in the file that does
229 /// not have a corresponding nullability annotation.
230 SourceLocation PointerLoc;
231
232 /// The end location for the first pointer declarator in the file. Used for
233 /// placing fix-its.
234 SourceLocation PointerEndLoc;
235
236 /// Which kind of pointer declarator we saw.
237 uint8_t PointerKind;
238
239 /// Whether we saw any type nullability annotations in the given file.
240 bool SawTypeNullability = false;
241};
242
243/// A mapping from file IDs to a record of whether we've seen nullability
244/// information in that file.
245class FileNullabilityMap {
246 /// A mapping from file IDs to the nullability information for each file ID.
247 llvm::DenseMap<FileID, FileNullability> Map;
248
249 /// A single-element cache based on the file ID.
250 struct {
251 FileID File;
252 FileNullability Nullability;
253 } Cache;
254
255public:
256 FileNullability &operator[](FileID file) {
257 // Check the single-element cache.
258 if (file == Cache.File)
259 return Cache.Nullability;
260
261 // It's not in the single-element cache; flush the cache if we have one.
262 if (!Cache.File.isInvalid()) {
263 Map[Cache.File] = Cache.Nullability;
264 }
265
266 // Pull this entry into the cache.
267 Cache.File = file;
268 Cache.Nullability = Map[file];
269 return Cache.Nullability;
270 }
271};
272
273/// Sema - This implements semantic analysis and AST building for C.
274class Sema {
Excessive padding in 'class clang::Sema' (75 padding bytes, where 3 is optimal). Optimal fields order: ExternalSource, LangOpts, PP, Context, Consumer, Diags, SourceMgr, CodeCompleter, CurContext, OriginalLexicalContext, VAListTagName, CurInitSeg, VisContext, PragmaAttributeCurrentTargetDecl, PreallocatedFunctionScope, FieldCollector, PureVirtualClassDiagSet, LateTemplateParser, LateTemplateParserCleanup, OpaqueParser, DelayedDiagnostics, TUScope, StdNamespace, StdBadAlloc, StdAlignValT, StdExperimentalNamespaceCache, StdInitializerList, CXXTypeInfoDecl, MSVCGuidDecl, NSAPIObj, NSNumberDecl, NSValueDecl, NSNumberPointer, NSValuePointer, NSStringDecl, NSStringPointer, StringWithUTF8StringMethod, ValueWithBytesObjCTypeMethod, NSArrayDecl, ArrayWithObjectsMethod, NSDictionaryDecl, DictionaryWithObjectsMethod, QIDNSCopying, RespondsToSelectorSel, CXXThisTypeOverride, CurrentInstantiationScope, ThreadSafetyDeclCache, VarDataSharingAttributesStack, TypeTagForDatatypeMagicValues, CurScope, Ident_super, Ident___float128, Ident__Nonnull, Ident__Nullable, Ident__Null_unspecified, Ident_NSError, SemaPPCallbackHandler, CFError, IdResolver, SpecialMemberCache, TemplateInstCallbacks, OpenCLFeatures, ExtnameUndeclaredIdentifiers, FlagBitsCache, UnparsedDefaultArgInstantiations, UnparsedDefaultArgLocs, MethodPool, VisibleModules, ShadowingDecls, VTablesUsed, InstantiatingSpecializations, InstantiatedNonDependentTypes, LookupModulesCache, VisibleNamespaceCache, SuppressedDiagnostics, TypoCorrectionFailures, CurrOpenCLExtension, OpenCLTypeExtMap, OpenCLDeclExtMap, CUDADeferredDiags, LocsWithCUDACallDiags, CUDAKnownEmittedFns, CUDACallGraph, CurrentSEHFinally, PragmaClangBSSSection, PragmaClangDataSection, PragmaClangRodataSection, PragmaClangTextSection, WeakTopLevelDecl, NullabilityMap, LateParsedInstantiations, MaybeODRUseExprs, FunctionScopes, DeleteExprs, DelayedExceptionSpecChecks, DelayedDefaultedMemberExceptionSpecs, LateParsedTemplateMap, WeakUndeclaredIdentifiers, UndefinedButUsed, ReferencedSelectors, CurrentParameterCopyTypes, DelayedTypos, KnownNamespaces, DelayedDllExportClasses, ParsingInitForAutoVars, SpecialMembersBeingDeclared, TypoCorrectedFunctionDefinitions, ExtVectorDecls, TentativeDefinitions, UnusedFileScopedDecls, DelegatingCtorDecls, PendingInstantiations, PendingLocalImplicitInstantiations, ExprCleanupObjects, AnalysisWarnings, VtorDispStack, PackStack, UnusedLocalTypedefNameCandidates, DataSegStack, BSSSegStack, ConstSegStack, CodeSegStack, PackIncludeStack, NSNumberLiteralMethods, BumpAlloc, PragmaAttributeStack, CodeSynthesisContextLookupModules, MisalignedMembers, VTableUses, UnusedPrivateFields, ModuleScopes, CodeSynthesisContexts, ExprEvalContexts, FPFeatures, MSPointerToMemberRepresentationMethod, ImplicitMSInheritanceAttrLoc, CurInitSegLoc, OptimizeOffPragmaLocation, TUKind, NumSFINAEErrors, NonInstantiationEntries, LastEmittedCodeSynthesisContextDepth, ArgumentPackSubstitutionIndex, TyposCorrected, ForceCUDAHostDeviceDepth, isMultiplexExternalSource, CollectStats, MSStructPragmaOn, IsBuildingRecoveryCallExpr, GlobalNewDeleteDeclared, AllowAbstractFieldReference, LoadedExternalKnownNamespaces, AccessCheckingSFINAE, InNonInstantiationSFINAEContext, DisableTypoCorrection, IsInOpenMPDeclareTargetContext, Cleanup, consider reordering the fields or adding explicit padding members
275 Sema(const Sema &) = delete;
276 void operator=(const Sema &) = delete;
277
278 ///\brief Source of additional semantic information.
279 ExternalSemaSource *ExternalSource;
280
281 ///\brief Whether Sema has generated a multiplexer and has to delete it.
282 bool isMultiplexExternalSource;
283
284 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
285
286 bool isVisibleSlow(const NamedDecl *D);
287
288 /// Determine whether two declarations should be linked together, given that
289 /// the old declaration might not be visible and the new declaration might
290 /// not have external linkage.
291 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
292 const NamedDecl *New) {
293 if (isVisible(Old))
294 return true;
295 // See comment in below overload for why it's safe to compute the linkage
296 // of the new declaration here.
297 if (New->isExternallyDeclarable()) {
298 assert(Old->isExternallyDeclarable() &&(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
299 "should not have found a non-externally-declarable previous decl")(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300 return true;
301 }
302 return false;
303 }
304 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
305
306public:
307 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
308 typedef OpaquePtr<TemplateName> TemplateTy;
309 typedef OpaquePtr<QualType> TypeTy;
310
311 OpenCLOptions OpenCLFeatures;
312 FPOptions FPFeatures;
313
314 const LangOptions &LangOpts;
315 Preprocessor &PP;
316 ASTContext &Context;
317 ASTConsumer &Consumer;
318 DiagnosticsEngine &Diags;
319 SourceManager &SourceMgr;
320
321 /// \brief Flag indicating whether or not to collect detailed statistics.
322 bool CollectStats;
323
324 /// \brief Code-completion consumer.
325 CodeCompleteConsumer *CodeCompleter;
326
327 /// CurContext - This is the current declaration context of parsing.
328 DeclContext *CurContext;
329
330 /// \brief Generally null except when we temporarily switch decl contexts,
331 /// like in \see ActOnObjCTemporaryExitContainerContext.
332 DeclContext *OriginalLexicalContext;
333
334 /// VAListTagName - The declaration name corresponding to __va_list_tag.
335 /// This is used as part of a hack to omit that class from ADL results.
336 DeclarationName VAListTagName;
337
338 bool MSStructPragmaOn; // True when \#pragma ms_struct on
339
340 /// \brief Controls member pointer representation format under the MS ABI.
341 LangOptions::PragmaMSPointersToMembersKind
342 MSPointerToMemberRepresentationMethod;
343
344 /// Stack of active SEH __finally scopes. Can be empty.
345 SmallVector<Scope*, 2> CurrentSEHFinally;
346
347 /// \brief Source location for newly created implicit MSInheritanceAttrs
348 SourceLocation ImplicitMSInheritanceAttrLoc;
349
350 /// \brief pragma clang section kind
351 enum PragmaClangSectionKind {
352 PCSK_Invalid = 0,
353 PCSK_BSS = 1,
354 PCSK_Data = 2,
355 PCSK_Rodata = 3,
356 PCSK_Text = 4
357 };
358
359 enum PragmaClangSectionAction {
360 PCSA_Set = 0,
361 PCSA_Clear = 1
362 };
363
364 struct PragmaClangSection {
365 std::string SectionName;
366 bool Valid = false;
367 SourceLocation PragmaLocation;
368
369 void Act(SourceLocation PragmaLocation,
370 PragmaClangSectionAction Action,
371 StringLiteral* Name);
372 };
373
374 PragmaClangSection PragmaClangBSSSection;
375 PragmaClangSection PragmaClangDataSection;
376 PragmaClangSection PragmaClangRodataSection;
377 PragmaClangSection PragmaClangTextSection;
378
379 enum PragmaMsStackAction {
380 PSK_Reset = 0x0, // #pragma ()
381 PSK_Set = 0x1, // #pragma (value)
382 PSK_Push = 0x2, // #pragma (push[, id])
383 PSK_Pop = 0x4, // #pragma (pop[, id])
384 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
385 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
386 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
387 };
388
389 template<typename ValueType>
390 struct PragmaStack {
391 struct Slot {
392 llvm::StringRef StackSlotLabel;
393 ValueType Value;
394 SourceLocation PragmaLocation;
395 SourceLocation PragmaPushLocation;
396 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
397 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
398 : StackSlotLabel(StackSlotLabel), Value(Value),
399 PragmaLocation(PragmaLocation),
400 PragmaPushLocation(PragmaPushLocation) {}
401 };
402 void Act(SourceLocation PragmaLocation,
403 PragmaMsStackAction Action,
404 llvm::StringRef StackSlotLabel,
405 ValueType Value);
406
407 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
408 // method body to restore the stacks on exit, so it works like this:
409 //
410 // struct S {
411 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
412 // void Method {}
413 // #pragma <name>(pop, InternalPragmaSlot)
414 // };
415 //
416 // It works even with #pragma vtordisp, although MSVC doesn't support
417 // #pragma vtordisp(push [, id], n)
418 // syntax.
419 //
420 // Push / pop a named sentinel slot.
421 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
422 assert((Action == PSK_Push || Action == PSK_Pop) &&(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
423 "Can only push / pop #pragma stack sentinels!")(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
;
424 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
425 }
426
427 // Constructors.
428 explicit PragmaStack(const ValueType &Default)
429 : DefaultValue(Default), CurrentValue(Default) {}
430
431 bool hasValue() const { return CurrentValue != DefaultValue; }
432
433 SmallVector<Slot, 2> Stack;
434 ValueType DefaultValue; // Value used for PSK_Reset action.
435 ValueType CurrentValue;
436 SourceLocation CurrentPragmaLocation;
437 };
438 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
439 // we shouldn't do so if they're in a module).
440
441 /// \brief Whether to insert vtordisps prior to virtual bases in the Microsoft
442 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
443 ///
444 /// 0: Suppress all vtordisps
445 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
446 /// structors
447 /// 2: Always insert vtordisps to support RTTI on partially constructed
448 /// objects
449 PragmaStack<MSVtorDispAttr::Mode> VtorDispStack;
450 // #pragma pack.
451 // Sentinel to represent when the stack is set to mac68k alignment.
452 static const unsigned kMac68kAlignmentSentinel = ~0U;
453 PragmaStack<unsigned> PackStack;
454 // The current #pragma pack values and locations at each #include.
455 struct PackIncludeState {
456 unsigned CurrentValue;
457 SourceLocation CurrentPragmaLocation;
458 bool HasNonDefaultValue, ShouldWarnOnInclude;
459 };
460 SmallVector<PackIncludeState, 8> PackIncludeStack;
461 // Segment #pragmas.
462 PragmaStack<StringLiteral *> DataSegStack;
463 PragmaStack<StringLiteral *> BSSSegStack;
464 PragmaStack<StringLiteral *> ConstSegStack;
465 PragmaStack<StringLiteral *> CodeSegStack;
466
467 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
468 // Actions should be performed only if we enter / exit a C++ method body.
469 class PragmaStackSentinelRAII {
470 public:
471 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
472 ~PragmaStackSentinelRAII();
473
474 private:
475 Sema &S;
476 StringRef SlotLabel;
477 bool ShouldAct;
478 };
479
480 /// A mapping that describes the nullability we've seen in each header file.
481 FileNullabilityMap NullabilityMap;
482
483 /// Last section used with #pragma init_seg.
484 StringLiteral *CurInitSeg;
485 SourceLocation CurInitSegLoc;
486
487 /// VisContext - Manages the stack for \#pragma GCC visibility.
488 void *VisContext; // Really a "PragmaVisStack*"
489
490 /// \brief This represents the stack of attributes that were pushed by
491 /// \#pragma clang attribute.
492 struct PragmaAttributeEntry {
493 SourceLocation Loc;
494 AttributeList *Attribute;
495 SmallVector<attr::SubjectMatchRule, 4> MatchRules;
496 bool IsUsed;
497 };
498 SmallVector<PragmaAttributeEntry, 2> PragmaAttributeStack;
499
500 /// \brief The declaration that is currently receiving an attribute from the
501 /// #pragma attribute stack.
502 const Decl *PragmaAttributeCurrentTargetDecl;
503
504 /// \brief This represents the last location of a "#pragma clang optimize off"
505 /// directive if such a directive has not been closed by an "on" yet. If
506 /// optimizations are currently "on", this is set to an invalid location.
507 SourceLocation OptimizeOffPragmaLocation;
508
509 /// \brief Flag indicating if Sema is building a recovery call expression.
510 ///
511 /// This flag is used to avoid building recovery call expressions
512 /// if Sema is already doing so, which would cause infinite recursions.
513 bool IsBuildingRecoveryCallExpr;
514
515 /// Used to control the generation of ExprWithCleanups.
516 CleanupInfo Cleanup;
517
518 /// ExprCleanupObjects - This is the stack of objects requiring
519 /// cleanup that are created by the current full expression. The
520 /// element type here is ExprWithCleanups::Object.
521 SmallVector<BlockDecl*, 8> ExprCleanupObjects;
522
523 /// \brief Store a list of either DeclRefExprs or MemberExprs
524 /// that contain a reference to a variable (constant) that may or may not
525 /// be odr-used in this Expr, and we won't know until all lvalue-to-rvalue
526 /// and discarded value conversions have been applied to all subexpressions
527 /// of the enclosing full expression. This is cleared at the end of each
528 /// full expression.
529 llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs;
530
531 std::unique_ptr<sema::FunctionScopeInfo> PreallocatedFunctionScope;
532
533 /// \brief Stack containing information about each of the nested
534 /// function, block, and method scopes that are currently active.
535 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
536
537 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
538 &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
539 ExtVectorDeclsType;
540
541 /// ExtVectorDecls - This is a list all the extended vector types. This allows
542 /// us to associate a raw vector type with one of the ext_vector type names.
543 /// This is only necessary for issuing pretty diagnostics.
544 ExtVectorDeclsType ExtVectorDecls;
545
546 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
547 std::unique_ptr<CXXFieldCollector> FieldCollector;
548
549 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
550
551 /// \brief Set containing all declared private fields that are not used.
552 NamedDeclSetType UnusedPrivateFields;
553
554 /// \brief Set containing all typedefs that are likely unused.
555 llvm::SmallSetVector<const TypedefNameDecl *, 4>
556 UnusedLocalTypedefNameCandidates;
557
558 /// \brief Delete-expressions to be analyzed at the end of translation unit
559 ///
560 /// This list contains class members, and locations of delete-expressions
561 /// that could not be proven as to whether they mismatch with new-expression
562 /// used in initializer of the field.
563 typedef std::pair<SourceLocation, bool> DeleteExprLoc;
564 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
565 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
566
567 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
568
569 /// PureVirtualClassDiagSet - a set of class declarations which we have
570 /// emitted a list of pure virtual functions. Used to prevent emitting the
571 /// same list more than once.
572 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
573
574 /// ParsingInitForAutoVars - a set of declarations with auto types for which
575 /// we are currently parsing the initializer.
576 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
577
578 /// \brief Look for a locally scoped extern "C" declaration by the given name.
579 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
580
581 typedef LazyVector<VarDecl *, ExternalSemaSource,
582 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
583 TentativeDefinitionsType;
584
585 /// \brief All the tentative definitions encountered in the TU.
586 TentativeDefinitionsType TentativeDefinitions;
587
588 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
589 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
590 UnusedFileScopedDeclsType;
591
592 /// \brief The set of file scoped decls seen so far that have not been used
593 /// and must warn if not used. Only contains the first declaration.
594 UnusedFileScopedDeclsType UnusedFileScopedDecls;
595
596 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
597 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
598 DelegatingCtorDeclsType;
599
600 /// \brief All the delegating constructors seen so far in the file, used for
601 /// cycle detection at the end of the TU.
602 DelegatingCtorDeclsType DelegatingCtorDecls;
603
604 /// \brief All the overriding functions seen during a class definition
605 /// that had their exception spec checks delayed, plus the overridden
606 /// function.
607 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
608 DelayedExceptionSpecChecks;
609
610 /// \brief All the members seen during a class definition which were both
611 /// explicitly defaulted and had explicitly-specified exception
612 /// specifications, along with the function type containing their
613 /// user-specified exception specification. Those exception specifications
614 /// were overridden with the default specifications, but we still need to
615 /// check whether they are compatible with the default specification, and
616 /// we can't do that until the nesting set of class definitions is complete.
617 SmallVector<std::pair<CXXMethodDecl*, const FunctionProtoType*>, 2>
618 DelayedDefaultedMemberExceptionSpecs;
619
620 typedef llvm::MapVector<const FunctionDecl *,
621 std::unique_ptr<LateParsedTemplate>>
622 LateParsedTemplateMapT;
623 LateParsedTemplateMapT LateParsedTemplateMap;
624
625 /// \brief Callback to the parser to parse templated functions when needed.
626 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
627 typedef void LateTemplateParserCleanupCB(void *P);
628 LateTemplateParserCB *LateTemplateParser;
629 LateTemplateParserCleanupCB *LateTemplateParserCleanup;
630 void *OpaqueParser;
631
632 void SetLateTemplateParser(LateTemplateParserCB *LTP,
633 LateTemplateParserCleanupCB *LTPCleanup,
634 void *P) {
635 LateTemplateParser = LTP;
636 LateTemplateParserCleanup = LTPCleanup;
637 OpaqueParser = P;
638 }
639
640 class DelayedDiagnostics;
641
642 class DelayedDiagnosticsState {
643 sema::DelayedDiagnosticPool *SavedPool;
644 friend class Sema::DelayedDiagnostics;
645 };
646 typedef DelayedDiagnosticsState ParsingDeclState;
647 typedef DelayedDiagnosticsState ProcessingContextState;
648
649 /// A class which encapsulates the logic for delaying diagnostics
650 /// during parsing and other processing.
651 class DelayedDiagnostics {
652 /// \brief The current pool of diagnostics into which delayed
653 /// diagnostics should go.
654 sema::DelayedDiagnosticPool *CurPool;
655
656 public:
657 DelayedDiagnostics() : CurPool(nullptr) {}
658
659 /// Adds a delayed diagnostic.
660 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
661
662 /// Determines whether diagnostics should be delayed.
663 bool shouldDelayDiagnostics() { return CurPool != nullptr; }
664
665 /// Returns the current delayed-diagnostics pool.
666 sema::DelayedDiagnosticPool *getCurrentPool() const {
667 return CurPool;
668 }
669
670 /// Enter a new scope. Access and deprecation diagnostics will be
671 /// collected in this pool.
672 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
673 DelayedDiagnosticsState state;
674 state.SavedPool = CurPool;
675 CurPool = &pool;
676 return state;
677 }
678
679 /// Leave a delayed-diagnostic state that was previously pushed.
680 /// Do not emit any of the diagnostics. This is performed as part
681 /// of the bookkeeping of popping a pool "properly".
682 void popWithoutEmitting(DelayedDiagnosticsState state) {
683 CurPool = state.SavedPool;
684 }
685
686 /// Enter a new scope where access and deprecation diagnostics are
687 /// not delayed.
688 DelayedDiagnosticsState pushUndelayed() {
689 DelayedDiagnosticsState state;
690 state.SavedPool = CurPool;
691 CurPool = nullptr;
692 return state;
693 }
694
695 /// Undo a previous pushUndelayed().
696 void popUndelayed(DelayedDiagnosticsState state) {
697 assert(CurPool == nullptr)(static_cast <bool> (CurPool == nullptr) ? void (0) : __assert_fail
("CurPool == nullptr", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 697, __extension__ __PRETTY_FUNCTION__))
;
698 CurPool = state.SavedPool;
699 }
700 } DelayedDiagnostics;
701
702 /// A RAII object to temporarily push a declaration context.
703 class ContextRAII {
704 private:
705 Sema &S;
706 DeclContext *SavedContext;
707 ProcessingContextState SavedContextState;
708 QualType SavedCXXThisTypeOverride;
709
710 public:
711 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
712 : S(S), SavedContext(S.CurContext),
713 SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
714 SavedCXXThisTypeOverride(S.CXXThisTypeOverride)
715 {
716 assert(ContextToPush && "pushing null context")(static_cast <bool> (ContextToPush && "pushing null context"
) ? void (0) : __assert_fail ("ContextToPush && \"pushing null context\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 716, __extension__ __PRETTY_FUNCTION__))
;
717 S.CurContext = ContextToPush;
718 if (NewThisContext)
719 S.CXXThisTypeOverride = QualType();
720 }
721
722 void pop() {
723 if (!SavedContext) return;
724 S.CurContext = SavedContext;
725 S.DelayedDiagnostics.popUndelayed(SavedContextState);
726 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
727 SavedContext = nullptr;
728 }
729
730 ~ContextRAII() {
731 pop();
732 }
733 };
734
735 /// \brief RAII object to handle the state changes required to synthesize
736 /// a function body.
737 class SynthesizedFunctionScope {
738 Sema &S;
739 Sema::ContextRAII SavedContext;
740 bool PushedCodeSynthesisContext = false;
741
742 public:
743 SynthesizedFunctionScope(Sema &S, DeclContext *DC)
744 : S(S), SavedContext(S, DC) {
745 S.PushFunctionScope();
746 S.PushExpressionEvaluationContext(
747 Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
748 if (auto *FD = dyn_cast<FunctionDecl>(DC))
749 FD->setWillHaveBody(true);
750 else
751 assert(isa<ObjCMethodDecl>(DC))(static_cast <bool> (isa<ObjCMethodDecl>(DC)) ? void
(0) : __assert_fail ("isa<ObjCMethodDecl>(DC)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 751, __extension__ __PRETTY_FUNCTION__))
;
752 }
753
754 void addContextNote(SourceLocation UseLoc) {
755 assert(!PushedCodeSynthesisContext)(static_cast <bool> (!PushedCodeSynthesisContext) ? void
(0) : __assert_fail ("!PushedCodeSynthesisContext", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 755, __extension__ __PRETTY_FUNCTION__))
;
756
757 Sema::CodeSynthesisContext Ctx;
758 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
759 Ctx.PointOfInstantiation = UseLoc;
760 Ctx.Entity = cast<Decl>(S.CurContext);
761 S.pushCodeSynthesisContext(Ctx);
762
763 PushedCodeSynthesisContext = true;
764 }
765
766 ~SynthesizedFunctionScope() {
767 if (PushedCodeSynthesisContext)
768 S.popCodeSynthesisContext();
769 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
770 FD->setWillHaveBody(false);
771 S.PopExpressionEvaluationContext();
772 S.PopFunctionScopeInfo();
773 }
774 };
775
776 /// WeakUndeclaredIdentifiers - Identifiers contained in
777 /// \#pragma weak before declared. rare. may alias another
778 /// identifier, declared or undeclared
779 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
780
781 /// ExtnameUndeclaredIdentifiers - Identifiers contained in
782 /// \#pragma redefine_extname before declared. Used in Solaris system headers
783 /// to define functions that occur in multiple standards to call the version
784 /// in the currently selected standard.
785 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
786
787
788 /// \brief Load weak undeclared identifiers from the external source.
789 void LoadExternalWeakUndeclaredIdentifiers();
790
791 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
792 /// \#pragma weak during processing of other Decls.
793 /// I couldn't figure out a clean way to generate these in-line, so
794 /// we store them here and handle separately -- which is a hack.
795 /// It would be best to refactor this.
796 SmallVector<Decl*,2> WeakTopLevelDecl;
797
798 IdentifierResolver IdResolver;
799
800 /// Translation Unit Scope - useful to Objective-C actions that need
801 /// to lookup file scope declarations in the "ordinary" C decl namespace.
802 /// For example, user-defined classes, built-in "id" type, etc.
803 Scope *TUScope;
804
805 /// \brief The C++ "std" namespace, where the standard library resides.
806 LazyDeclPtr StdNamespace;
807
808 /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
809 /// standard library.
810 LazyDeclPtr StdBadAlloc;
811
812 /// \brief The C++ "std::align_val_t" enum class, which is defined by the C++
813 /// standard library.
814 LazyDeclPtr StdAlignValT;
815
816 /// \brief The C++ "std::experimental" namespace, where the experimental parts
817 /// of the standard library resides.
818 NamespaceDecl *StdExperimentalNamespaceCache;
819
820 /// \brief The C++ "std::initializer_list" template, which is defined in
821 /// \<initializer_list>.
822 ClassTemplateDecl *StdInitializerList;
823
824 /// \brief The C++ "type_info" declaration, which is defined in \<typeinfo>.
825 RecordDecl *CXXTypeInfoDecl;
826
827 /// \brief The MSVC "_GUID" struct, which is defined in MSVC header files.
828 RecordDecl *MSVCGuidDecl;
829
830 /// \brief Caches identifiers/selectors for NSFoundation APIs.
831 std::unique_ptr<NSAPI> NSAPIObj;
832
833 /// \brief The declaration of the Objective-C NSNumber class.
834 ObjCInterfaceDecl *NSNumberDecl;
835
836 /// \brief The declaration of the Objective-C NSValue class.
837 ObjCInterfaceDecl *NSValueDecl;
838
839 /// \brief Pointer to NSNumber type (NSNumber *).
840 QualType NSNumberPointer;
841
842 /// \brief Pointer to NSValue type (NSValue *).
843 QualType NSValuePointer;
844
845 /// \brief The Objective-C NSNumber methods used to create NSNumber literals.
846 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
847
848 /// \brief The declaration of the Objective-C NSString class.
849 ObjCInterfaceDecl *NSStringDecl;
850
851 /// \brief Pointer to NSString type (NSString *).
852 QualType NSStringPointer;
853
854 /// \brief The declaration of the stringWithUTF8String: method.
855 ObjCMethodDecl *StringWithUTF8StringMethod;
856
857 /// \brief The declaration of the valueWithBytes:objCType: method.
858 ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
859
860 /// \brief The declaration of the Objective-C NSArray class.
861 ObjCInterfaceDecl *NSArrayDecl;
862
863 /// \brief The declaration of the arrayWithObjects:count: method.
864 ObjCMethodDecl *ArrayWithObjectsMethod;
865
866 /// \brief The declaration of the Objective-C NSDictionary class.
867 ObjCInterfaceDecl *NSDictionaryDecl;
868
869 /// \brief The declaration of the dictionaryWithObjects:forKeys:count: method.
870 ObjCMethodDecl *DictionaryWithObjectsMethod;
871
872 /// \brief id<NSCopying> type.
873 QualType QIDNSCopying;
874
875 /// \brief will hold 'respondsToSelector:'
876 Selector RespondsToSelectorSel;
877
878 /// A flag to remember whether the implicit forms of operator new and delete
879 /// have been declared.
880 bool GlobalNewDeleteDeclared;
881
882 /// A flag to indicate that we're in a context that permits abstract
883 /// references to fields. This is really a
884 bool AllowAbstractFieldReference;
885
886 /// \brief Describes how the expressions currently being parsed are
887 /// evaluated at run-time, if at all.
888 enum class ExpressionEvaluationContext {
889 /// \brief The current expression and its subexpressions occur within an
890 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
891 /// \c sizeof, where the type of the expression may be significant but
892 /// no code will be generated to evaluate the value of the expression at
893 /// run time.
894 Unevaluated,
895
896 /// \brief The current expression occurs within a braced-init-list within
897 /// an unevaluated operand. This is mostly like a regular unevaluated
898 /// context, except that we still instantiate constexpr functions that are
899 /// referenced here so that we can perform narrowing checks correctly.
900 UnevaluatedList,
901
902 /// \brief The current expression occurs within a discarded statement.
903 /// This behaves largely similarly to an unevaluated operand in preventing
904 /// definitions from being required, but not in other ways.
905 DiscardedStatement,
906
907 /// \brief The current expression occurs within an unevaluated
908 /// operand that unconditionally permits abstract references to
909 /// fields, such as a SIZE operator in MS-style inline assembly.
910 UnevaluatedAbstract,
911
912 /// \brief The current context is "potentially evaluated" in C++11 terms,
913 /// but the expression is evaluated at compile-time (like the values of
914 /// cases in a switch statement).
915 ConstantEvaluated,
916
917 /// \brief The current expression is potentially evaluated at run time,
918 /// which means that code may be generated to evaluate the value of the
919 /// expression at run time.
920 PotentiallyEvaluated,
921
922 /// \brief The current expression is potentially evaluated, but any
923 /// declarations referenced inside that expression are only used if
924 /// in fact the current expression is used.
925 ///
926 /// This value is used when parsing default function arguments, for which
927 /// we would like to provide diagnostics (e.g., passing non-POD arguments
928 /// through varargs) but do not want to mark declarations as "referenced"
929 /// until the default argument is used.
930 PotentiallyEvaluatedIfUsed
931 };
932
933 /// \brief Data structure used to record current or nested
934 /// expression evaluation contexts.
935 struct ExpressionEvaluationContextRecord {
936 /// \brief The expression evaluation context.
937 ExpressionEvaluationContext Context;
938
939 /// \brief Whether the enclosing context needed a cleanup.
940 CleanupInfo ParentCleanup;
941
942 /// \brief Whether we are in a decltype expression.
943 bool IsDecltype;
944
945 /// \brief The number of active cleanup objects when we entered
946 /// this expression evaluation context.
947 unsigned NumCleanupObjects;
948
949 /// \brief The number of typos encountered during this expression evaluation
950 /// context (i.e. the number of TypoExprs created).
951 unsigned NumTypos;
952
953 llvm::SmallPtrSet<Expr*, 2> SavedMaybeODRUseExprs;
954
955 /// \brief The lambdas that are present within this context, if it
956 /// is indeed an unevaluated context.
957 SmallVector<LambdaExpr *, 2> Lambdas;
958
959 /// \brief The declaration that provides context for lambda expressions
960 /// and block literals if the normal declaration context does not
961 /// suffice, e.g., in a default function argument.
962 Decl *ManglingContextDecl;
963
964 /// \brief The context information used to mangle lambda expressions
965 /// and block literals within this context.
966 ///
967 /// This mangling information is allocated lazily, since most contexts
968 /// do not have lambda expressions or block literals.
969 std::unique_ptr<MangleNumberingContext> MangleNumbering;
970
971 /// \brief If we are processing a decltype type, a set of call expressions
972 /// for which we have deferred checking the completeness of the return type.
973 SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
974
975 /// \brief If we are processing a decltype type, a set of temporary binding
976 /// expressions for which we have deferred checking the destructor.
977 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
978
979 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
980 unsigned NumCleanupObjects,
981 CleanupInfo ParentCleanup,
982 Decl *ManglingContextDecl,
983 bool IsDecltype)
984 : Context(Context), ParentCleanup(ParentCleanup),
985 IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects),
986 NumTypos(0),
987 ManglingContextDecl(ManglingContextDecl), MangleNumbering() { }
988
989 /// \brief Retrieve the mangling numbering context, used to consistently
990 /// number constructs like lambdas for mangling.
991 MangleNumberingContext &getMangleNumberingContext(ASTContext &Ctx);
992
993 bool isUnevaluated() const {
994 return Context == ExpressionEvaluationContext::Unevaluated ||
995 Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
996 Context == ExpressionEvaluationContext::UnevaluatedList;
997 }
998 bool isConstantEvaluated() const {
999 return Context == ExpressionEvaluationContext::ConstantEvaluated;
1000 }
1001 };
1002
1003 /// A stack of expression evaluation contexts.
1004 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1005
1006 /// \brief Compute the mangling number context for a lambda expression or
1007 /// block literal.
1008 ///
1009 /// \param DC - The DeclContext containing the lambda expression or
1010 /// block literal.
1011 /// \param[out] ManglingContextDecl - Returns the ManglingContextDecl
1012 /// associated with the context, if relevant.
1013 MangleNumberingContext *getCurrentMangleNumberContext(
1014 const DeclContext *DC,
1015 Decl *&ManglingContextDecl);
1016
1017
1018 /// SpecialMemberOverloadResult - The overloading result for a special member
1019 /// function.
1020 ///
1021 /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1022 /// integer are used to determine whether overload resolution succeeded.
1023 class SpecialMemberOverloadResult {
1024 public:
1025 enum Kind {
1026 NoMemberOrDeleted,
1027 Ambiguous,
1028 Success
1029 };
1030
1031 private:
1032 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1033
1034 public:
1035 SpecialMemberOverloadResult() : Pair() {}
1036 SpecialMemberOverloadResult(CXXMethodDecl *MD)
1037 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1038
1039 CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1040 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1041
1042 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1043 void setKind(Kind K) { Pair.setInt(K); }
1044 };
1045
1046 class SpecialMemberOverloadResultEntry
1047 : public llvm::FastFoldingSetNode,
1048 public SpecialMemberOverloadResult {
1049 public:
1050 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1051 : FastFoldingSetNode(ID)
1052 {}
1053 };
1054
1055 /// \brief A cache of special member function overload resolution results
1056 /// for C++ records.
1057 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1058
1059 /// \brief A cache of the flags available in enumerations with the flag_bits
1060 /// attribute.
1061 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1062
1063 /// \brief The kind of translation unit we are processing.
1064 ///
1065 /// When we're processing a complete translation unit, Sema will perform
1066 /// end-of-translation-unit semantic tasks (such as creating
1067 /// initializers for tentative definitions in C) once parsing has
1068 /// completed. Modules and precompiled headers perform different kinds of
1069 /// checks.
1070 TranslationUnitKind TUKind;
1071
1072 llvm::BumpPtrAllocator BumpAlloc;
1073
1074 /// \brief The number of SFINAE diagnostics that have been trapped.
1075 unsigned NumSFINAEErrors;
1076
1077 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1078 UnparsedDefaultArgInstantiationsMap;
1079
1080 /// \brief A mapping from parameters with unparsed default arguments to the
1081 /// set of instantiations of each parameter.
1082 ///
1083 /// This mapping is a temporary data structure used when parsing
1084 /// nested class templates or nested classes of class templates,
1085 /// where we might end up instantiating an inner class before the
1086 /// default arguments of its methods have been parsed.
1087 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1088
1089 // Contains the locations of the beginning of unparsed default
1090 // argument locations.
1091 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1092
1093 /// UndefinedInternals - all the used, undefined objects which require a
1094 /// definition in this translation unit.
1095 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1096
1097 /// Determine if VD, which must be a variable or function, is an external
1098 /// symbol that nonetheless can't be referenced from outside this translation
1099 /// unit because its type has no linkage and it's not extern "C".
1100 bool isExternalWithNoLinkageType(ValueDecl *VD);
1101
1102 /// Obtain a sorted list of functions that are undefined but ODR-used.
1103 void getUndefinedButUsed(
1104 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1105
1106 /// Retrieves list of suspicious delete-expressions that will be checked at
1107 /// the end of translation unit.
1108 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1109 getMismatchingDeleteExpressions() const;
1110
1111 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1112 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1113
1114 /// Method Pool - allows efficient lookup when typechecking messages to "id".
1115 /// We need to maintain a list, since selectors can have differing signatures
1116 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1117 /// of selectors are "overloaded").
1118 /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1119 /// methods inside categories with a particular selector.
1120 GlobalMethodPool MethodPool;
1121
1122 /// Method selectors used in a \@selector expression. Used for implementation
1123 /// of -Wselector.
1124 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1125
1126 /// Kinds of C++ special members.
1127 enum CXXSpecialMember {
1128 CXXDefaultConstructor,
1129 CXXCopyConstructor,
1130 CXXMoveConstructor,
1131 CXXCopyAssignment,
1132 CXXMoveAssignment,
1133 CXXDestructor,
1134 CXXInvalid
1135 };
1136
1137 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1138 SpecialMemberDecl;
1139
1140 /// The C++ special members which we are currently in the process of
1141 /// declaring. If this process recursively triggers the declaration of the
1142 /// same special member, we should act as if it is not yet declared.
1143 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1144
1145 /// The function definitions which were renamed as part of typo-correction
1146 /// to match their respective declarations. We want to keep track of them
1147 /// to ensure that we don't emit a "redefinition" error if we encounter a
1148 /// correctly named definition after the renamed definition.
1149 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1150
1151 /// Stack of types that correspond to the parameter entities that are
1152 /// currently being copy-initialized. Can be empty.
1153 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1154
1155 void ReadMethodPool(Selector Sel);
1156 void updateOutOfDateSelector(Selector Sel);
1157
1158 /// Private Helper predicate to check for 'self'.
1159 bool isSelfExpr(Expr *RExpr);
1160 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1161
1162 /// \brief Cause the active diagnostic on the DiagosticsEngine to be
1163 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1164 /// should not be used elsewhere.
1165 void EmitCurrentDiagnostic(unsigned DiagID);
1166
1167 /// Records and restores the FP_CONTRACT state on entry/exit of compound
1168 /// statements.
1169 class FPContractStateRAII {
1170 public:
1171 FPContractStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.FPFeatures) {}
1172 ~FPContractStateRAII() { S.FPFeatures = OldFPFeaturesState; }
1173
1174 private:
1175 Sema& S;
1176 FPOptions OldFPFeaturesState;
1177 };
1178
1179 void addImplicitTypedef(StringRef Name, QualType T);
1180
1181public:
1182 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1183 TranslationUnitKind TUKind = TU_Complete,
1184 CodeCompleteConsumer *CompletionConsumer = nullptr);
1185 ~Sema();
1186
1187 /// \brief Perform initialization that occurs after the parser has been
1188 /// initialized but before it parses anything.
1189 void Initialize();
1190
1191 const LangOptions &getLangOpts() const { return LangOpts; }
1192 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1193 FPOptions &getFPOptions() { return FPFeatures; }
1194
1195 DiagnosticsEngine &getDiagnostics() const { return Diags; }
1196 SourceManager &getSourceManager() const { return SourceMgr; }
1197 Preprocessor &getPreprocessor() const { return PP; }
1198 ASTContext &getASTContext() const { return Context; }
1199 ASTConsumer &getASTConsumer() const { return Consumer; }
1200 ASTMutationListener *getASTMutationListener() const;
1201 ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1202
1203 ///\brief Registers an external source. If an external source already exists,
1204 /// creates a multiplex external source and appends to it.
1205 ///
1206 ///\param[in] E - A non-null external sema source.
1207 ///
1208 void addExternalSource(ExternalSemaSource *E);
1209
1210 void PrintStats() const;
1211
1212 /// \brief Helper class that creates diagnostics with optional
1213 /// template instantiation stacks.
1214 ///
1215 /// This class provides a wrapper around the basic DiagnosticBuilder
1216 /// class that emits diagnostics. SemaDiagnosticBuilder is
1217 /// responsible for emitting the diagnostic (as DiagnosticBuilder
1218 /// does) and, if the diagnostic comes from inside a template
1219 /// instantiation, printing the template instantiation stack as
1220 /// well.
1221 class SemaDiagnosticBuilder : public DiagnosticBuilder {
1222 Sema &SemaRef;
1223 unsigned DiagID;
1224
1225 public:
1226 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1227 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
1228
1229 // This is a cunning lie. DiagnosticBuilder actually performs move
1230 // construction in its copy constructor (but due to varied uses, it's not
1231 // possible to conveniently express this as actual move construction). So
1232 // the default copy ctor here is fine, because the base class disables the
1233 // source anyway, so the user-defined ~SemaDiagnosticBuilder is a safe no-op
1234 // in that case anwyay.
1235 SemaDiagnosticBuilder(const SemaDiagnosticBuilder&) = default;
1236
1237 ~SemaDiagnosticBuilder() {
1238 // If we aren't active, there is nothing to do.
1239 if (!isActive()) return;
1240
1241 // Otherwise, we need to emit the diagnostic. First flush the underlying
1242 // DiagnosticBuilder data, and clear the diagnostic builder itself so it
1243 // won't emit the diagnostic in its own destructor.
1244 //
1245 // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1246 // do its own needless checks to see if the diagnostic needs to be
1247 // emitted. However, because we take care to ensure that the builder
1248 // objects never escape, a sufficiently smart compiler will be able to
1249 // eliminate that code.
1250 FlushCounts();
1251 Clear();
1252
1253 // Dispatch to Sema to emit the diagnostic.
1254 SemaRef.EmitCurrentDiagnostic(DiagID);
1255 }
1256
1257 /// Teach operator<< to produce an object of the correct type.
1258 template<typename T>
1259 friend const SemaDiagnosticBuilder &operator<<(
1260 const SemaDiagnosticBuilder &Diag, const T &Value) {
1261 const DiagnosticBuilder &BaseDiag = Diag;
1262 BaseDiag << Value;
1263 return Diag;
1264 }
1265 };
1266
1267 /// \brief Emit a diagnostic.
1268 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
1269 DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
1270 return SemaDiagnosticBuilder(DB, *this, DiagID);
1271 }
1272
1273 /// \brief Emit a partial diagnostic.
1274 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
1275
1276 /// \brief Build a partial diagnostic.
1277 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1278
1279 bool findMacroSpelling(SourceLocation &loc, StringRef name);
1280
1281 /// \brief Get a string to suggest for zero-initialization of a type.
1282 std::string
1283 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1284 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1285
1286 /// \brief Calls \c Lexer::getLocForEndOfToken()
1287 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1288
1289 /// \brief Retrieve the module loader associated with the preprocessor.
1290 ModuleLoader &getModuleLoader() const;
1291
1292 void emitAndClearUnusedLocalTypedefWarnings();
1293
1294 void ActOnStartOfTranslationUnit();
1295 void ActOnEndOfTranslationUnit();
1296
1297 void CheckDelegatingCtorCycles();
1298
1299 Scope *getScopeForContext(DeclContext *Ctx);
1300
1301 void PushFunctionScope();
1302 void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1303 sema::LambdaScopeInfo *PushLambdaScope();
1304
1305 /// \brief This is used to inform Sema what the current TemplateParameterDepth
1306 /// is during Parsing. Currently it is used to pass on the depth
1307 /// when parsing generic lambda 'auto' parameters.
1308 void RecordParsingTemplateParameterDepth(unsigned Depth);
1309
1310 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1311 RecordDecl *RD,
1312 CapturedRegionKind K);
1313 void
1314 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1315 const Decl *D = nullptr,
1316 const BlockExpr *blkExpr = nullptr);
1317
1318 sema::FunctionScopeInfo *getCurFunction() const {
1319 return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1320 }
1321
1322 sema::FunctionScopeInfo *getEnclosingFunction() const;
1323
1324 void setFunctionHasBranchIntoScope();
1325 void setFunctionHasBranchProtectedScope();
1326 void setFunctionHasIndirectGoto();
1327
1328 void PushCompoundScope(bool IsStmtExpr);
1329 void PopCompoundScope();
1330
1331 sema::CompoundScopeInfo &getCurCompoundScope() const;
1332
1333 bool hasAnyUnrecoverableErrorsInThisFunction() const;
1334
1335 /// \brief Retrieve the current block, if any.
1336 sema::BlockScopeInfo *getCurBlock();
1337
1338 /// Retrieve the current lambda scope info, if any.
1339 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1340 /// lambda scope info ignoring all inner capturing scopes that are not
1341 /// lambda scopes.
1342 sema::LambdaScopeInfo *
1343 getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1344
1345 /// \brief Retrieve the current generic lambda info, if any.
1346 sema::LambdaScopeInfo *getCurGenericLambda();
1347
1348 /// \brief Retrieve the current captured region, if any.
1349 sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1350
1351 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1352 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1353
1354 void ActOnComment(SourceRange Comment);
1355
1356 //===--------------------------------------------------------------------===//
1357 // Type Analysis / Processing: SemaType.cpp.
1358 //
1359
1360 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1361 const DeclSpec *DS = nullptr);
1362 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1363 const DeclSpec *DS = nullptr);
1364 QualType BuildPointerType(QualType T,
1365 SourceLocation Loc, DeclarationName Entity);
1366 QualType BuildReferenceType(QualType T, bool LValueRef,
1367 SourceLocation Loc, DeclarationName Entity);
1368 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1369 Expr *ArraySize, unsigned Quals,
1370 SourceRange Brackets, DeclarationName Entity);
1371 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1372 SourceLocation AttrLoc);
1373 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1374 SourceLocation AttrLoc);
1375
1376 bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1377
1378 /// \brief Build a function type.
1379 ///
1380 /// This routine checks the function type according to C++ rules and
1381 /// under the assumption that the result type and parameter types have
1382 /// just been instantiated from a template. It therefore duplicates
1383 /// some of the behavior of GetTypeForDeclarator, but in a much
1384 /// simpler form that is only suitable for this narrow use case.
1385 ///
1386 /// \param T The return type of the function.
1387 ///
1388 /// \param ParamTypes The parameter types of the function. This array
1389 /// will be modified to account for adjustments to the types of the
1390 /// function parameters.
1391 ///
1392 /// \param Loc The location of the entity whose type involves this
1393 /// function type or, if there is no such entity, the location of the
1394 /// type that will have function type.
1395 ///
1396 /// \param Entity The name of the entity that involves the function
1397 /// type, if known.
1398 ///
1399 /// \param EPI Extra information about the function type. Usually this will
1400 /// be taken from an existing function with the same prototype.
1401 ///
1402 /// \returns A suitable function type, if there are no errors. The
1403 /// unqualified type will always be a FunctionProtoType.
1404 /// Otherwise, returns a NULL type.
1405 QualType BuildFunctionType(QualType T,
1406 MutableArrayRef<QualType> ParamTypes,
1407 SourceLocation Loc, DeclarationName Entity,
1408 const FunctionProtoType::ExtProtoInfo &EPI);
1409
1410 QualType BuildMemberPointerType(QualType T, QualType Class,
1411 SourceLocation Loc,
1412 DeclarationName Entity);
1413 QualType BuildBlockPointerType(QualType T,
1414 SourceLocation Loc, DeclarationName Entity);
1415 QualType BuildParenType(QualType T);
1416 QualType BuildAtomicType(QualType T, SourceLocation Loc);
1417 QualType BuildReadPipeType(QualType T,
1418 SourceLocation Loc);
1419 QualType BuildWritePipeType(QualType T,
1420 SourceLocation Loc);
1421
1422 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
1423 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1424 TypeSourceInfo *GetTypeSourceInfoForDeclarator(Declarator &D, QualType T,
1425 TypeSourceInfo *ReturnTypeInfo);
1426
1427 /// \brief Package the given type and TSI into a ParsedType.
1428 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1429 DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1430 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1431 static QualType GetTypeFromParser(ParsedType Ty,
1432 TypeSourceInfo **TInfo = nullptr);
1433 CanThrowResult canThrow(const Expr *E);
1434 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1435 const FunctionProtoType *FPT);
1436 void UpdateExceptionSpec(FunctionDecl *FD,
1437 const FunctionProtoType::ExceptionSpecInfo &ESI);
1438 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
1439 bool CheckDistantExceptionSpec(QualType T);
1440 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
1441 bool CheckEquivalentExceptionSpec(
1442 const FunctionProtoType *Old, SourceLocation OldLoc,
1443 const FunctionProtoType *New, SourceLocation NewLoc);
1444 bool CheckEquivalentExceptionSpec(
1445 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
1446 const FunctionProtoType *Old, SourceLocation OldLoc,
1447 const FunctionProtoType *New, SourceLocation NewLoc);
1448 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
1449 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
1450 const PartialDiagnostic &NestedDiagID,
1451 const PartialDiagnostic &NoteID,
1452 const FunctionProtoType *Superset,
1453 SourceLocation SuperLoc,
1454 const FunctionProtoType *Subset,
1455 SourceLocation SubLoc);
1456 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
1457 const PartialDiagnostic &NoteID,
1458 const FunctionProtoType *Target,
1459 SourceLocation TargetLoc,
1460 const FunctionProtoType *Source,
1461 SourceLocation SourceLoc);
1462
1463 TypeResult ActOnTypeName(Scope *S, Declarator &D);
1464
1465 /// \brief The parser has parsed the context-sensitive type 'instancetype'
1466 /// in an Objective-C message declaration. Return the appropriate type.
1467 ParsedType ActOnObjCInstanceType(SourceLocation Loc);
1468
1469 /// \brief Abstract class used to diagnose incomplete types.
1470 struct TypeDiagnoser {
1471 TypeDiagnoser() {}
1472
1473 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
1474 virtual ~TypeDiagnoser() {}
1475 };
1476
1477 static int getPrintable(int I) { return I; }
1478 static unsigned getPrintable(unsigned I) { return I; }
1479 static bool getPrintable(bool B) { return B; }
1480 static const char * getPrintable(const char *S) { return S; }
1481 static StringRef getPrintable(StringRef S) { return S; }
1482 static const std::string &getPrintable(const std::string &S) { return S; }
1483 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
1484 return II;
1485 }
1486 static DeclarationName getPrintable(DeclarationName N) { return N; }
1487 static QualType getPrintable(QualType T) { return T; }
1488 static SourceRange getPrintable(SourceRange R) { return R; }
1489 static SourceRange getPrintable(SourceLocation L) { return L; }
1490 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
1491 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
1492
1493 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
1494 unsigned DiagID;
1495 std::tuple<const Ts &...> Args;
1496
1497 template <std::size_t... Is>
1498 void emit(const SemaDiagnosticBuilder &DB,
1499 llvm::index_sequence<Is...>) const {
1500 // Apply all tuple elements to the builder in order.
1501 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
1502 (void)Dummy;
1503 }
1504
1505 public:
1506 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
1507 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
1508 assert(DiagID != 0 && "no diagnostic for type diagnoser")(static_cast <bool> (DiagID != 0 && "no diagnostic for type diagnoser"
) ? void (0) : __assert_fail ("DiagID != 0 && \"no diagnostic for type diagnoser\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1508, __extension__ __PRETTY_FUNCTION__))
;
1509 }
1510
1511 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
1512 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
1513 emit(DB, llvm::index_sequence_for<Ts...>());
1514 DB << T;
1515 }
1516 };
1517
1518private:
1519 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
1520 TypeDiagnoser *Diagnoser);
1521
1522 struct ModuleScope {
1523 clang::Module *Module = nullptr;
1524 bool ModuleInterface = false;
1525 VisibleModuleSet OuterVisibleModules;
1526 };
1527 /// The modules we're currently parsing.
1528 llvm::SmallVector<ModuleScope, 16> ModuleScopes;
1529
1530 /// Get the module whose scope we are currently within.
1531 Module *getCurrentModule() const {
1532 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
1533 }
1534
1535 VisibleModuleSet VisibleModules;
1536
1537public:
1538 /// \brief Get the module owning an entity.
1539 Module *getOwningModule(Decl *Entity) { return Entity->getOwningModule(); }
1540
1541 /// \brief Make a merged definition of an existing hidden definition \p ND
1542 /// visible at the specified location.
1543 void makeMergedDefinitionVisible(NamedDecl *ND);
1544
1545 bool isModuleVisible(const Module *M) { return VisibleModules.isVisible(M); }
1546
1547 /// Determine whether a declaration is visible to name lookup.
1548 bool isVisible(const NamedDecl *D) {
1549 return !D->isHidden() || isVisibleSlow(D);
1550 }
1551
1552 /// Determine whether any declaration of an entity is visible.
1553 bool
1554 hasVisibleDeclaration(const NamedDecl *D,
1555 llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
1556 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
1557 }
1558 bool hasVisibleDeclarationSlow(const NamedDecl *D,
1559 llvm::SmallVectorImpl<Module *> *Modules);
1560
1561 bool hasVisibleMergedDefinition(NamedDecl *Def);
1562 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
1563
1564 /// Determine if \p D and \p Suggested have a structurally compatible
1565 /// layout as described in C11 6.2.7/1.
1566 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
1567
1568 /// Determine if \p D has a visible definition. If not, suggest a declaration
1569 /// that should be made visible to expose the definition.
1570 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
1571 bool OnlyNeedComplete = false);
1572 bool hasVisibleDefinition(const NamedDecl *D) {
1573 NamedDecl *Hidden;
1574 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
1575 }
1576
1577 /// Determine if the template parameter \p D has a visible default argument.
1578 bool
1579 hasVisibleDefaultArgument(const NamedDecl *D,
1580 llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1581
1582 /// Determine if there is a visible declaration of \p D that is an explicit
1583 /// specialization declaration for a specialization of a template. (For a
1584 /// member specialization, use hasVisibleMemberSpecialization.)
1585 bool hasVisibleExplicitSpecialization(
1586 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1587
1588 /// Determine if there is a visible declaration of \p D that is a member
1589 /// specialization declaration (as opposed to an instantiated declaration).
1590 bool hasVisibleMemberSpecialization(
1591 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1592
1593 /// Determine if \p A and \p B are equivalent internal linkage declarations
1594 /// from different modules, and thus an ambiguity error can be downgraded to
1595 /// an extension warning.
1596 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
1597 const NamedDecl *B);
1598 void diagnoseEquivalentInternalLinkageDeclarations(
1599 SourceLocation Loc, const NamedDecl *D,
1600 ArrayRef<const NamedDecl *> Equiv);
1601
1602 bool isCompleteType(SourceLocation Loc, QualType T) {
1603 return !RequireCompleteTypeImpl(Loc, T, nullptr);
1604 }
1605 bool RequireCompleteType(SourceLocation Loc, QualType T,
1606 TypeDiagnoser &Diagnoser);
1607 bool RequireCompleteType(SourceLocation Loc, QualType T,
1608 unsigned DiagID);
1609
1610 template <typename... Ts>
1611 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
1612 const Ts &...Args) {
1613 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1614 return RequireCompleteType(Loc, T, Diagnoser);
1615 }
1616
1617 void completeExprArrayBound(Expr *E);
1618 bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser);
1619 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1620
1621 template <typename... Ts>
1622 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
1623 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1624 return RequireCompleteExprType(E, Diagnoser);
1625 }
1626
1627 bool RequireLiteralType(SourceLocation Loc, QualType T,
1628 TypeDiagnoser &Diagnoser);
1629 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
1630
1631 template <typename... Ts>
1632 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
1633 const Ts &...Args) {
1634 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1635 return RequireLiteralType(Loc, T, Diagnoser);
1636 }
1637
1638 QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
1639 const CXXScopeSpec &SS, QualType T);
1640
1641 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1642 /// If AsUnevaluated is false, E is treated as though it were an evaluated
1643 /// context, such as when building a type for decltype(auto).
1644 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
1645 bool AsUnevaluated = true);
1646 QualType BuildUnaryTransformType(QualType BaseType,
1647 UnaryTransformType::UTTKind UKind,
1648 SourceLocation Loc);
1649
1650 //===--------------------------------------------------------------------===//
1651 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
1652 //
1653
1654 struct SkipBodyInfo {
1655 SkipBodyInfo()
1656 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
1657 New(nullptr) {}
1658 bool ShouldSkip;
1659 bool CheckSameAsPrevious;
1660 NamedDecl *Previous;
1661 NamedDecl *New;
1662 };
1663
1664 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
1665
1666 void DiagnoseUseOfUnimplementedSelectors();
1667
1668 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
1669
1670 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
1671 Scope *S, CXXScopeSpec *SS = nullptr,
1672 bool isClassName = false, bool HasTrailingDot = false,
1673 ParsedType ObjectType = nullptr,
1674 bool IsCtorOrDtorName = false,
1675 bool WantNontrivialTypeSourceInfo = false,
1676 bool IsClassTemplateDeductionContext = true,
1677 IdentifierInfo **CorrectedII = nullptr);
1678 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
1679 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
1680 void DiagnoseUnknownTypeName(IdentifierInfo *&II,
1681 SourceLocation IILoc,
1682 Scope *S,
1683 CXXScopeSpec *SS,
1684 ParsedType &SuggestedType,
1685 bool IsTemplateName = false);
1686
1687 /// Attempt to behave like MSVC in situations where lookup of an unqualified
1688 /// type name has failed in a dependent context. In these situations, we
1689 /// automatically form a DependentTypeName that will retry lookup in a related
1690 /// scope during instantiation.
1691 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
1692 SourceLocation NameLoc,
1693 bool IsTemplateTypeArg);
1694
1695 /// \brief Describes the result of the name lookup and resolution performed
1696 /// by \c ClassifyName().
1697 enum NameClassificationKind {
1698 NC_Unknown,
1699 NC_Error,
1700 NC_Keyword,
1701 NC_Type,
1702 NC_Expression,
1703 NC_NestedNameSpecifier,
1704 NC_TypeTemplate,
1705 NC_VarTemplate,
1706 NC_FunctionTemplate
1707 };
1708
1709 class NameClassification {
1710 NameClassificationKind Kind;
1711 ExprResult Expr;
1712 TemplateName Template;
1713 ParsedType Type;
1714
1715 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
1716
1717 public:
1718 NameClassification(ExprResult Expr) : Kind(NC_Expression), Expr(Expr) {}
1719
1720 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
1721
1722 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
1723
1724 static NameClassification Error() {
1725 return NameClassification(NC_Error);
1726 }
1727
1728 static NameClassification Unknown() {
1729 return NameClassification(NC_Unknown);
1730 }
1731
1732 static NameClassification NestedNameSpecifier() {
1733 return NameClassification(NC_NestedNameSpecifier);
1734 }
1735
1736 static NameClassification TypeTemplate(TemplateName Name) {
1737 NameClassification Result(NC_TypeTemplate);
1738 Result.Template = Name;
1739 return Result;
1740 }
1741
1742 static NameClassification VarTemplate(TemplateName Name) {
1743 NameClassification Result(NC_VarTemplate);
1744 Result.Template = Name;
1745 return Result;
1746 }
1747
1748 static NameClassification FunctionTemplate(TemplateName Name) {
1749 NameClassification Result(NC_FunctionTemplate);
1750 Result.Template = Name;
1751 return Result;
1752 }
1753
1754 NameClassificationKind getKind() const { return Kind; }
1755
1756 ParsedType getType() const {
1757 assert(Kind == NC_Type)(static_cast <bool> (Kind == NC_Type) ? void (0) : __assert_fail
("Kind == NC_Type", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1757, __extension__ __PRETTY_FUNCTION__))
;
1758 return Type;
1759 }
1760
1761 ExprResult getExpression() const {
1762 assert(Kind == NC_Expression)(static_cast <bool> (Kind == NC_Expression) ? void (0) :
__assert_fail ("Kind == NC_Expression", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1762, __extension__ __PRETTY_FUNCTION__))
;
1763 return Expr;
1764 }
1765
1766 TemplateName getTemplateName() const {
1767 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1768, __extension__ __PRETTY_FUNCTION__))
1768 Kind == NC_VarTemplate)(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1768, __extension__ __PRETTY_FUNCTION__))
;
1769 return Template;
1770 }
1771
1772 TemplateNameKind getTemplateNameKind() const {
1773 switch (Kind) {
1774 case NC_TypeTemplate:
1775 return TNK_Type_template;
1776 case NC_FunctionTemplate:
1777 return TNK_Function_template;
1778 case NC_VarTemplate:
1779 return TNK_Var_template;
1780 default:
1781 llvm_unreachable("unsupported name classification.")::llvm::llvm_unreachable_internal("unsupported name classification."
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 1781)
;
1782 }
1783 }
1784 };
1785
1786 /// \brief Perform name lookup on the given name, classifying it based on
1787 /// the results of name lookup and the following token.
1788 ///
1789 /// This routine is used by the parser to resolve identifiers and help direct
1790 /// parsing. When the identifier cannot be found, this routine will attempt
1791 /// to correct the typo and classify based on the resulting name.
1792 ///
1793 /// \param S The scope in which we're performing name lookup.
1794 ///
1795 /// \param SS The nested-name-specifier that precedes the name.
1796 ///
1797 /// \param Name The identifier. If typo correction finds an alternative name,
1798 /// this pointer parameter will be updated accordingly.
1799 ///
1800 /// \param NameLoc The location of the identifier.
1801 ///
1802 /// \param NextToken The token following the identifier. Used to help
1803 /// disambiguate the name.
1804 ///
1805 /// \param IsAddressOfOperand True if this name is the operand of a unary
1806 /// address of ('&') expression, assuming it is classified as an
1807 /// expression.
1808 ///
1809 /// \param CCC The correction callback, if typo correction is desired.
1810 NameClassification
1811 ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
1812 SourceLocation NameLoc, const Token &NextToken,
1813 bool IsAddressOfOperand,
1814 std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
1815
1816 /// Describes the detailed kind of a template name. Used in diagnostics.
1817 enum class TemplateNameKindForDiagnostics {
1818 ClassTemplate,
1819 FunctionTemplate,
1820 VarTemplate,
1821 AliasTemplate,
1822 TemplateTemplateParam,
1823 DependentTemplate
1824 };
1825 TemplateNameKindForDiagnostics
1826 getTemplateNameKindForDiagnostics(TemplateName Name);
1827
1828 /// Determine whether it's plausible that E was intended to be a
1829 /// template-name.
1830 bool mightBeIntendedToBeTemplateName(ExprResult E) {
1831 if (!getLangOpts().CPlusPlus || E.isInvalid())
1832 return false;
1833 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
1834 return !DRE->hasExplicitTemplateArgs();
1835 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
1836 return !ME->hasExplicitTemplateArgs();
1837 // Any additional cases recognized here should also be handled by
1838 // diagnoseExprIntendedAsTemplateName.
1839 return false;
1840 }
1841 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
1842 SourceLocation Less,
1843 SourceLocation Greater);
1844
1845 Decl *ActOnDeclarator(Scope *S, Declarator &D);
1846
1847 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
1848 MultiTemplateParamsArg TemplateParameterLists);
1849 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
1850 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
1851 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
1852 DeclarationName Name, SourceLocation Loc,
1853 bool IsTemplateId);
1854 void
1855 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
1856 SourceLocation FallbackLoc,
1857 SourceLocation ConstQualLoc = SourceLocation(),
1858 SourceLocation VolatileQualLoc = SourceLocation(),
1859 SourceLocation RestrictQualLoc = SourceLocation(),
1860 SourceLocation AtomicQualLoc = SourceLocation(),
1861 SourceLocation UnalignedQualLoc = SourceLocation());
1862
1863 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
1864 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
1865 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
1866 const LookupResult &R);
1867 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
1868 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
1869 const LookupResult &R);
1870 void CheckShadow(Scope *S, VarDecl *D);
1871
1872 /// Warn if 'E', which is an expression that is about to be modified, refers
1873 /// to a shadowing declaration.
1874 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
1875
1876 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
1877
1878private:
1879 /// Map of current shadowing declarations to shadowed declarations. Warn if
1880 /// it looks like the user is trying to modify the shadowing declaration.
1881 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
1882
1883public:
1884 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
1885 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
1886 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
1887 TypedefNameDecl *NewTD);
1888 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
1889 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1890 TypeSourceInfo *TInfo,
1891 LookupResult &Previous);
1892 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
1893 LookupResult &Previous, bool &Redeclaration);
1894 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
1895 TypeSourceInfo *TInfo,
1896 LookupResult &Previous,
1897 MultiTemplateParamsArg TemplateParamLists,
1898 bool &AddToScope,
1899 ArrayRef<BindingDecl *> Bindings = None);
1900 NamedDecl *
1901 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
1902 MultiTemplateParamsArg TemplateParamLists);
1903 // Returns true if the variable declaration is a redeclaration
1904 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
1905 void CheckVariableDeclarationType(VarDecl *NewVD);
1906 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
1907 Expr *Init);
1908 void CheckCompleteVariableDeclaration(VarDecl *VD);
1909 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
1910 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
1911
1912 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1913 TypeSourceInfo *TInfo,
1914 LookupResult &Previous,
1915 MultiTemplateParamsArg TemplateParamLists,
1916 bool &AddToScope);
1917 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1918
1919 bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
1920 bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
1921
1922 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
1923 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
1924 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1925 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
1926 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1927 // Returns true if the function declaration is a redeclaration
1928 bool CheckFunctionDeclaration(Scope *S,
1929 FunctionDecl *NewFD, LookupResult &Previous,
1930 bool IsMemberSpecialization);
1931 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
1932 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
1933 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
1934 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
1935 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
1936 SourceLocation Loc,
1937 QualType T);
1938 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
1939 SourceLocation NameLoc, IdentifierInfo *Name,
1940 QualType T, TypeSourceInfo *TSInfo,
1941 StorageClass SC);
1942 void ActOnParamDefaultArgument(Decl *param,
1943 SourceLocation EqualLoc,
1944 Expr *defarg);
1945 void ActOnParamUnparsedDefaultArgument(Decl *param,
1946 SourceLocation EqualLoc,
1947 SourceLocation ArgLoc);
1948 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
1949 bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
1950 SourceLocation EqualLoc);
1951
1952 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
1953 void ActOnUninitializedDecl(Decl *dcl);
1954 void ActOnInitializerError(Decl *Dcl);
1955
1956 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
1957 void ActOnCXXForRangeDecl(Decl *D);
1958 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
1959 IdentifierInfo *Ident,
1960 ParsedAttributes &Attrs,
1961 SourceLocation AttrEnd);
1962 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
1963 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
1964 void FinalizeDeclaration(Decl *D);
1965 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
1966 ArrayRef<Decl *> Group);
1967 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
1968
1969 /// Should be called on all declarations that might have attached
1970 /// documentation comments.
1971 void ActOnDocumentableDecl(Decl *D);
1972 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
1973
1974 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
1975 SourceLocation LocAfterDecls);
1976 void CheckForFunctionRedefinition(
1977 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
1978 SkipBodyInfo *SkipBody = nullptr);
1979 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
1980 MultiTemplateParamsArg TemplateParamLists,
1981 SkipBodyInfo *SkipBody = nullptr);
1982 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
1983 SkipBodyInfo *SkipBody = nullptr);
1984 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
1985 bool isObjCMethodDecl(Decl *D) {
1986 return D && isa<ObjCMethodDecl>(D);
1987 }
1988
1989 /// \brief Determine whether we can delay parsing the body of a function or
1990 /// function template until it is used, assuming we don't care about emitting
1991 /// code for that function.
1992 ///
1993 /// This will be \c false if we may need the body of the function in the
1994 /// middle of parsing an expression (where it's impractical to switch to
1995 /// parsing a different function), for instance, if it's constexpr in C++11
1996 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
1997 bool canDelayFunctionBody(const Declarator &D);
1998
1999 /// \brief Determine whether we can skip parsing the body of a function
2000 /// definition, assuming we don't care about analyzing its body or emitting
2001 /// code for that function.
2002 ///
2003 /// This will be \c false only if we may need the body of the function in
2004 /// order to parse the rest of the program (for instance, if it is
2005 /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2006 bool canSkipFunctionBody(Decl *D);
2007
2008 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2009 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2010 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2011 Decl *ActOnSkippedFunctionBody(Decl *Decl);
2012 void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2013
2014 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2015 /// attribute for which parsing is delayed.
2016 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2017
2018 /// \brief Diagnose any unused parameters in the given sequence of
2019 /// ParmVarDecl pointers.
2020 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2021
2022 /// \brief Diagnose whether the size of parameters or return value of a
2023 /// function or obj-c method definition is pass-by-value and larger than a
2024 /// specified threshold.
2025 void
2026 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2027 QualType ReturnTy, NamedDecl *D);
2028
2029 void DiagnoseInvalidJumps(Stmt *Body);
2030 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2031 SourceLocation AsmLoc,
2032 SourceLocation RParenLoc);
2033
2034 /// \brief Handle a C++11 empty-declaration and attribute-declaration.
2035 Decl *ActOnEmptyDeclaration(Scope *S,
2036 AttributeList *AttrList,
2037 SourceLocation SemiLoc);
2038
2039 enum class ModuleDeclKind {
2040 Interface, ///< 'export module X;'
2041 Implementation, ///< 'module X;'
2042 Partition, ///< 'module partition X;'
2043 };
2044
2045 /// The parser has processed a module-declaration that begins the definition
2046 /// of a module interface or implementation.
2047 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2048 SourceLocation ModuleLoc, ModuleDeclKind MDK,
2049 ModuleIdPath Path);
2050
2051 /// \brief The parser has processed a module import declaration.
2052 ///
2053 /// \param AtLoc The location of the '@' symbol, if any.
2054 ///
2055 /// \param ImportLoc The location of the 'import' keyword.
2056 ///
2057 /// \param Path The module access path.
2058 DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc,
2059 ModuleIdPath Path);
2060
2061 /// \brief The parser has processed a module import translated from a
2062 /// #include or similar preprocessing directive.
2063 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2064 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2065
2066 /// \brief The parsed has entered a submodule.
2067 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2068 /// \brief The parser has left a submodule.
2069 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2070
2071 /// \brief Create an implicit import of the given module at the given
2072 /// source location, for error recovery, if possible.
2073 ///
2074 /// This routine is typically used when an entity found by name lookup
2075 /// is actually hidden within a module that we know about but the user
2076 /// has forgotten to import.
2077 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2078 Module *Mod);
2079
2080 /// Kinds of missing import. Note, the values of these enumerators correspond
2081 /// to %select values in diagnostics.
2082 enum class MissingImportKind {
2083 Declaration,
2084 Definition,
2085 DefaultArgument,
2086 ExplicitSpecialization,
2087 PartialSpecialization
2088 };
2089
2090 /// \brief Diagnose that the specified declaration needs to be visible but
2091 /// isn't, and suggest a module import that would resolve the problem.
2092 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2093 MissingImportKind MIK, bool Recover = true);
2094 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2095 SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2096 MissingImportKind MIK, bool Recover);
2097
2098 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2099 SourceLocation LBraceLoc);
2100 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2101 SourceLocation RBraceLoc);
2102
2103 /// \brief We've found a use of a templated declaration that would trigger an
2104 /// implicit instantiation. Check that any relevant explicit specializations
2105 /// and partial specializations are visible, and diagnose if not.
2106 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2107
2108 /// \brief We've found a use of a template specialization that would select a
2109 /// partial specialization. Check that the partial specialization is visible,
2110 /// and diagnose if not.
2111 void checkPartialSpecializationVisibility(SourceLocation Loc,
2112 NamedDecl *Spec);
2113
2114 /// \brief Retrieve a suitable printing policy.
2115 PrintingPolicy getPrintingPolicy() const {
2116 return getPrintingPolicy(Context, PP);
2117 }
2118
2119 /// \brief Retrieve a suitable printing policy.
2120 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2121 const Preprocessor &PP);
2122
2123 /// Scope actions.
2124 void ActOnPopScope(SourceLocation Loc, Scope *S);
2125 void ActOnTranslationUnitScope(Scope *S);
2126
2127 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2128 RecordDecl *&AnonRecord);
2129 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2130 MultiTemplateParamsArg TemplateParams,
2131 bool IsExplicitInstantiation,
2132 RecordDecl *&AnonRecord);
2133
2134 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2135 AccessSpecifier AS,
2136 RecordDecl *Record,
2137 const PrintingPolicy &Policy);
2138
2139 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2140 RecordDecl *Record);
2141
2142 /// Common ways to introduce type names without a tag for use in diagnostics.
2143 /// Keep in sync with err_tag_reference_non_tag.
2144 enum NonTagKind {
2145 NTK_NonStruct,
2146 NTK_NonClass,
2147 NTK_NonUnion,
2148 NTK_NonEnum,
2149 NTK_Typedef,
2150 NTK_TypeAlias,
2151 NTK_Template,
2152 NTK_TypeAliasTemplate,
2153 NTK_TemplateTemplateArgument,
2154 };
2155
2156 /// Given a non-tag type declaration, returns an enum useful for indicating
2157 /// what kind of non-tag type this is.
2158 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
2159
2160 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
2161 TagTypeKind NewTag, bool isDefinition,
2162 SourceLocation NewTagLoc,
2163 const IdentifierInfo *Name);
2164
2165 enum TagUseKind {
2166 TUK_Reference, // Reference to a tag: 'struct foo *X;'
2167 TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
2168 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
2169 TUK_Friend // Friend declaration: 'friend struct foo;'
2170 };
2171
2172 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
2173 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
2174 SourceLocation NameLoc, AttributeList *Attr,
2175 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
2176 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
2177 bool &IsDependent, SourceLocation ScopedEnumKWLoc,
2178 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
2179 bool IsTypeSpecifier, bool IsTemplateParamOrArg,
2180 SkipBodyInfo *SkipBody = nullptr);
2181
2182 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
2183 unsigned TagSpec, SourceLocation TagLoc,
2184 CXXScopeSpec &SS,
2185 IdentifierInfo *Name, SourceLocation NameLoc,
2186 AttributeList *Attr,
2187 MultiTemplateParamsArg TempParamLists);
2188
2189 TypeResult ActOnDependentTag(Scope *S,
2190 unsigned TagSpec,
2191 TagUseKind TUK,
2192 const CXXScopeSpec &SS,
2193 IdentifierInfo *Name,
2194 SourceLocation TagLoc,
2195 SourceLocation NameLoc);
2196
2197 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
2198 IdentifierInfo *ClassName,
2199 SmallVectorImpl<Decl *> &Decls);
2200 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
2201 Declarator &D, Expr *BitfieldWidth);
2202
2203 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
2204 Declarator &D, Expr *BitfieldWidth,
2205 InClassInitStyle InitStyle,
2206 AccessSpecifier AS);
2207 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
2208 SourceLocation DeclStart,
2209 Declarator &D, Expr *BitfieldWidth,
2210 InClassInitStyle InitStyle,
2211 AccessSpecifier AS,
2212 AttributeList *MSPropertyAttr);
2213
2214 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
2215 TypeSourceInfo *TInfo,
2216 RecordDecl *Record, SourceLocation Loc,
2217 bool Mutable, Expr *BitfieldWidth,
2218 InClassInitStyle InitStyle,
2219 SourceLocation TSSL,
2220 AccessSpecifier AS, NamedDecl *PrevDecl,
2221 Declarator *D = nullptr);
2222
2223 bool CheckNontrivialField(FieldDecl *FD);
2224 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
2225
2226 enum TrivialABIHandling {
2227 /// The triviality of a method unaffected by "trivial_abi".
2228 TAH_IgnoreTrivialABI,
2229
2230 /// The triviality of a method affected by "trivial_abi".
2231 TAH_ConsiderTrivialABI
2232 };
2233
2234 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
2235 TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
2236 bool Diagnose = false);
2237 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD);
2238 void ActOnLastBitfield(SourceLocation DeclStart,
2239 SmallVectorImpl<Decl *> &AllIvarDecls);
2240 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
2241 Declarator &D, Expr *BitfieldWidth,
2242 tok::ObjCKeywordKind visibility);
2243
2244 // This is used for both record definitions and ObjC interface declarations.
2245 void ActOnFields(Scope* S, SourceLocation RecLoc, Decl *TagDecl,
2246 ArrayRef<Decl *> Fields,
2247 SourceLocation LBrac, SourceLocation RBrac,
2248 AttributeList *AttrList);
2249
2250 /// ActOnTagStartDefinition - Invoked when we have entered the
2251 /// scope of a tag's definition (e.g., for an enumeration, class,
2252 /// struct, or union).
2253 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
2254
2255 /// Perform ODR-like check for C/ObjC when merging tag types from modules.
2256 /// Differently from C++, actually parse the body and reject / error out
2257 /// in case of a structural mismatch.
2258 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
2259 SkipBodyInfo &SkipBody);
2260
2261 typedef void *SkippedDefinitionContext;
2262
2263 /// \brief Invoked when we enter a tag definition that we're skipping.
2264 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
2265
2266 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
2267
2268 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
2269 /// C++ record definition's base-specifiers clause and are starting its
2270 /// member declarations.
2271 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
2272 SourceLocation FinalLoc,
2273 bool IsFinalSpelledSealed,
2274 SourceLocation LBraceLoc);
2275
2276 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
2277 /// the definition of a tag (enumeration, class, struct, or union).
2278 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
2279 SourceRange BraceRange);
2280
2281 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
2282
2283 void ActOnObjCContainerFinishDefinition();
2284
2285 /// \brief Invoked when we must temporarily exit the objective-c container
2286 /// scope for parsing/looking-up C constructs.
2287 ///
2288 /// Must be followed by a call to \see ActOnObjCReenterContainerContext
2289 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
2290 void ActOnObjCReenterContainerContext(DeclContext *DC);
2291
2292 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
2293 /// error parsing the definition of a tag.
2294 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
2295
2296 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
2297 EnumConstantDecl *LastEnumConst,
2298 SourceLocation IdLoc,
2299 IdentifierInfo *Id,
2300 Expr *val);
2301 bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
2302 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
2303 QualType EnumUnderlyingTy, bool IsFixed,
2304 const EnumDecl *Prev);
2305
2306 /// Determine whether the body of an anonymous enumeration should be skipped.
2307 /// \param II The name of the first enumerator.
2308 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
2309 SourceLocation IILoc);
2310
2311 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
2312 SourceLocation IdLoc, IdentifierInfo *Id,
2313 AttributeList *Attrs, SourceLocation EqualLoc,
2314 Expr *Val);
2315 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
2316 Decl *EnumDecl,
2317 ArrayRef<Decl *> Elements,
2318 Scope *S, AttributeList *Attr);
2319
2320 DeclContext *getContainingDC(DeclContext *DC);
2321
2322 /// Set the current declaration context until it gets popped.
2323 void PushDeclContext(Scope *S, DeclContext *DC);
2324 void PopDeclContext();
2325
2326 /// EnterDeclaratorContext - Used when we must lookup names in the context
2327 /// of a declarator's nested name specifier.
2328 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
2329 void ExitDeclaratorContext(Scope *S);
2330
2331 /// Push the parameters of D, which must be a function, into scope.
2332 void ActOnReenterFunctionContext(Scope* S, Decl* D);
2333 void ActOnExitFunctionContext();
2334
2335 DeclContext *getFunctionLevelDeclContext();
2336
2337 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
2338 /// to the function decl for the function being parsed. If we're currently
2339 /// in a 'block', this returns the containing context.
2340 FunctionDecl *getCurFunctionDecl();
2341
2342 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
2343 /// the method decl for the method being parsed. If we're currently
2344 /// in a 'block', this returns the containing context.
2345 ObjCMethodDecl *getCurMethodDecl();
2346
2347 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
2348 /// or C function we're in, otherwise return null. If we're currently
2349 /// in a 'block', this returns the containing context.
2350 NamedDecl *getCurFunctionOrMethodDecl();
2351
2352 /// Add this decl to the scope shadowed decl chains.
2353 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
2354
2355 /// \brief Make the given externally-produced declaration visible at the
2356 /// top level scope.
2357 ///
2358 /// \param D The externally-produced declaration to push.
2359 ///
2360 /// \param Name The name of the externally-produced declaration.
2361 void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name);
2362
2363 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
2364 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
2365 /// true if 'D' belongs to the given declaration context.
2366 ///
2367 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
2368 /// enclosing namespace set of the context, rather than contained
2369 /// directly within it.
2370 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
2371 bool AllowInlineNamespace = false);
2372
2373 /// Finds the scope corresponding to the given decl context, if it
2374 /// happens to be an enclosing scope. Otherwise return NULL.
2375 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
2376
2377 /// Subroutines of ActOnDeclarator().
2378 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
2379 TypeSourceInfo *TInfo);
2380 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
2381
2382 /// \brief Describes the kind of merge to perform for availability
2383 /// attributes (including "deprecated", "unavailable", and "availability").
2384 enum AvailabilityMergeKind {
2385 /// \brief Don't merge availability attributes at all.
2386 AMK_None,
2387 /// \brief Merge availability attributes for a redeclaration, which requires
2388 /// an exact match.
2389 AMK_Redeclaration,
2390 /// \brief Merge availability attributes for an override, which requires
2391 /// an exact match or a weakening of constraints.
2392 AMK_Override,
2393 /// \brief Merge availability attributes for an implementation of
2394 /// a protocol requirement.
2395 AMK_ProtocolImplementation,
2396 };
2397
2398 /// Attribute merging methods. Return true if a new attribute was added.
2399 AvailabilityAttr *mergeAvailabilityAttr(NamedDecl *D, SourceRange Range,
2400 IdentifierInfo *Platform,
2401 bool Implicit,
2402 VersionTuple Introduced,
2403 VersionTuple Deprecated,
2404 VersionTuple Obsoleted,
2405 bool IsUnavailable,
2406 StringRef Message,
2407 bool IsStrict, StringRef Replacement,
2408 AvailabilityMergeKind AMK,
2409 unsigned AttrSpellingListIndex);
2410 TypeVisibilityAttr *mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2411 TypeVisibilityAttr::VisibilityType Vis,
2412 unsigned AttrSpellingListIndex);
2413 VisibilityAttr *mergeVisibilityAttr(Decl *D, SourceRange Range,
2414 VisibilityAttr::VisibilityType Vis,
2415 unsigned AttrSpellingListIndex);
2416 UuidAttr *mergeUuidAttr(Decl *D, SourceRange Range,
2417 unsigned AttrSpellingListIndex, StringRef Uuid);
2418 DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range,
2419 unsigned AttrSpellingListIndex);
2420 DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range,
2421 unsigned AttrSpellingListIndex);
2422 MSInheritanceAttr *
2423 mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
2424 unsigned AttrSpellingListIndex,
2425 MSInheritanceAttr::Spelling SemanticSpelling);
2426 FormatAttr *mergeFormatAttr(Decl *D, SourceRange Range,
2427 IdentifierInfo *Format, int FormatIdx,
2428 int FirstArg, unsigned AttrSpellingListIndex);
2429 SectionAttr *mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name,
2430 unsigned AttrSpellingListIndex);
2431 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
2432 IdentifierInfo *Ident,
2433 unsigned AttrSpellingListIndex);
2434 MinSizeAttr *mergeMinSizeAttr(Decl *D, SourceRange Range,
2435 unsigned AttrSpellingListIndex);
2436 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
2437 unsigned AttrSpellingListIndex);
2438 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, SourceRange Range,
2439 IdentifierInfo *Ident,
2440 unsigned AttrSpellingListIndex);
2441 CommonAttr *mergeCommonAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident,
2442 unsigned AttrSpellingListIndex);
2443
2444 void mergeDeclAttributes(NamedDecl *New, Decl *Old,
2445 AvailabilityMergeKind AMK = AMK_Redeclaration);
2446 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
2447 LookupResult &OldDecls);
2448 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
2449 bool MergeTypeWithOld);
2450 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
2451 Scope *S, bool MergeTypeWithOld);
2452 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
2453 void MergeVarDecl(VarDecl *New, LookupResult &Previous);
2454 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
2455 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
2456 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
2457 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
2458 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
2459
2460 // AssignmentAction - This is used by all the assignment diagnostic functions
2461 // to represent what is actually causing the operation
2462 enum AssignmentAction {
2463 AA_Assigning,
2464 AA_Passing,
2465 AA_Returning,
2466 AA_Converting,
2467 AA_Initializing,
2468 AA_Sending,
2469 AA_Casting,
2470 AA_Passing_CFAudited
2471 };
2472
2473 /// C++ Overloading.
2474 enum OverloadKind {
2475 /// This is a legitimate overload: the existing declarations are
2476 /// functions or function templates with different signatures.
2477 Ovl_Overload,
2478
2479 /// This is not an overload because the signature exactly matches
2480 /// an existing declaration.
2481 Ovl_Match,
2482
2483 /// This is not an overload because the lookup results contain a
2484 /// non-function.
2485 Ovl_NonFunction
2486 };
2487 OverloadKind CheckOverload(Scope *S,
2488 FunctionDecl *New,
2489 const LookupResult &OldDecls,
2490 NamedDecl *&OldDecl,
2491 bool IsForUsingDecl);
2492 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
2493 bool ConsiderCudaAttrs = true);
2494
2495 /// \brief Checks availability of the function depending on the current
2496 /// function context.Inside an unavailable function,unavailability is ignored.
2497 ///
2498 /// \returns true if \p FD is unavailable and current context is inside
2499 /// an available function, false otherwise.
2500 bool isFunctionConsideredUnavailable(FunctionDecl *FD);
2501
2502 ImplicitConversionSequence
2503 TryImplicitConversion(Expr *From, QualType ToType,
2504 bool SuppressUserConversions,
2505 bool AllowExplicit,
2506 bool InOverloadResolution,
2507 bool CStyle,
2508 bool AllowObjCWritebackConversion);
2509
2510 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
2511 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
2512 bool IsComplexPromotion(QualType FromType, QualType ToType);
2513 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2514 bool InOverloadResolution,
2515 QualType& ConvertedType, bool &IncompatibleObjC);
2516 bool isObjCPointerConversion(QualType FromType, QualType ToType,
2517 QualType& ConvertedType, bool &IncompatibleObjC);
2518 bool isObjCWritebackConversion(QualType FromType, QualType ToType,
2519 QualType &ConvertedType);
2520 bool IsBlockPointerConversion(QualType FromType, QualType ToType,
2521 QualType& ConvertedType);
2522 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
2523 const FunctionProtoType *NewType,
2524 unsigned *ArgPos = nullptr);
2525 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2526 QualType FromType, QualType ToType);
2527
2528 void maybeExtendBlockObject(ExprResult &E);
2529 CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
2530 bool CheckPointerConversion(Expr *From, QualType ToType,
2531 CastKind &Kind,
2532 CXXCastPath& BasePath,
2533 bool IgnoreBaseAccess,
2534 bool Diagnose = true);
2535 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
2536 bool InOverloadResolution,
2537 QualType &ConvertedType);
2538 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
2539 CastKind &Kind,
2540 CXXCastPath &BasePath,
2541 bool IgnoreBaseAccess);
2542 bool IsQualificationConversion(QualType FromType, QualType ToType,
2543 bool CStyle, bool &ObjCLifetimeConversion);
2544 bool IsFunctionConversion(QualType FromType, QualType ToType,
2545 QualType &ResultTy);
2546 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
2547 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
2548
2549 ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
2550 const VarDecl *NRVOCandidate,
2551 QualType ResultType,
2552 Expr *Value,
2553 bool AllowNRVO = true);
2554
2555 bool CanPerformCopyInitialization(const InitializedEntity &Entity,
2556 ExprResult Init);
2557 ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
2558 SourceLocation EqualLoc,
2559 ExprResult Init,
2560 bool TopLevelOfInitList = false,
2561 bool AllowExplicit = false);
2562 ExprResult PerformObjectArgumentInitialization(Expr *From,
2563 NestedNameSpecifier *Qualifier,
2564 NamedDecl *FoundDecl,
2565 CXXMethodDecl *Method);
2566
2567 ExprResult PerformContextuallyConvertToBool(Expr *From);
2568 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
2569
2570 /// Contexts in which a converted constant expression is required.
2571 enum CCEKind {
2572 CCEK_CaseValue, ///< Expression in a case label.
2573 CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
2574 CCEK_TemplateArg, ///< Value of a non-type template parameter.
2575 CCEK_NewExpr, ///< Constant expression in a noptr-new-declarator.
2576 CCEK_ConstexprIf ///< Condition in a constexpr if statement.
2577 };
2578 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
2579 llvm::APSInt &Value, CCEKind CCE);
2580 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
2581 APValue &Value, CCEKind CCE);
2582
2583 /// \brief Abstract base class used to perform a contextual implicit
2584 /// conversion from an expression to any type passing a filter.
2585 class ContextualImplicitConverter {
2586 public:
2587 bool Suppress;
2588 bool SuppressConversion;
2589
2590 ContextualImplicitConverter(bool Suppress = false,
2591 bool SuppressConversion = false)
2592 : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
2593
2594 /// \brief Determine whether the specified type is a valid destination type
2595 /// for this conversion.
2596 virtual bool match(QualType T) = 0;
2597
2598 /// \brief Emits a diagnostic complaining that the expression does not have
2599 /// integral or enumeration type.
2600 virtual SemaDiagnosticBuilder
2601 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
2602
2603 /// \brief Emits a diagnostic when the expression has incomplete class type.
2604 virtual SemaDiagnosticBuilder
2605 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
2606
2607 /// \brief Emits a diagnostic when the only matching conversion function
2608 /// is explicit.
2609 virtual SemaDiagnosticBuilder diagnoseExplicitConv(
2610 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
2611
2612 /// \brief Emits a note for the explicit conversion function.
2613 virtual SemaDiagnosticBuilder
2614 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
2615
2616 /// \brief Emits a diagnostic when there are multiple possible conversion
2617 /// functions.
2618 virtual SemaDiagnosticBuilder
2619 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
2620
2621 /// \brief Emits a note for one of the candidate conversions.
2622 virtual SemaDiagnosticBuilder
2623 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
2624
2625 /// \brief Emits a diagnostic when we picked a conversion function
2626 /// (for cases when we are not allowed to pick a conversion function).
2627 virtual SemaDiagnosticBuilder diagnoseConversion(
2628 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
2629
2630 virtual ~ContextualImplicitConverter() {}
2631 };
2632
2633 class ICEConvertDiagnoser : public ContextualImplicitConverter {
2634 bool AllowScopedEnumerations;
2635
2636 public:
2637 ICEConvertDiagnoser(bool AllowScopedEnumerations,
2638 bool Suppress, bool SuppressConversion)
2639 : ContextualImplicitConverter(Suppress, SuppressConversion),
2640 AllowScopedEnumerations(AllowScopedEnumerations) {}
2641
2642 /// Match an integral or (possibly scoped) enumeration type.
2643 bool match(QualType T) override;
2644
2645 SemaDiagnosticBuilder
2646 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
2647 return diagnoseNotInt(S, Loc, T);
2648 }
2649
2650 /// \brief Emits a diagnostic complaining that the expression does not have
2651 /// integral or enumeration type.
2652 virtual SemaDiagnosticBuilder
2653 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
2654 };
2655
2656 /// Perform a contextual implicit conversion.
2657 ExprResult PerformContextualImplicitConversion(
2658 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
2659
2660
2661 enum ObjCSubscriptKind {
2662 OS_Array,
2663 OS_Dictionary,
2664 OS_Error
2665 };
2666 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
2667
2668 // Note that LK_String is intentionally after the other literals, as
2669 // this is used for diagnostics logic.
2670 enum ObjCLiteralKind {
2671 LK_Array,
2672 LK_Dictionary,
2673 LK_Numeric,
2674 LK_Boxed,
2675 LK_String,
2676 LK_Block,
2677 LK_None
2678 };
2679 ObjCLiteralKind CheckLiteralKind(Expr *FromE);
2680
2681 ExprResult PerformObjectMemberConversion(Expr *From,
2682 NestedNameSpecifier *Qualifier,
2683 NamedDecl *FoundDecl,
2684 NamedDecl *Member);
2685
2686 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
2687 // TODO: make this is a typesafe union.
2688 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet;
2689 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
2690
2691 void AddOverloadCandidate(FunctionDecl *Function,
2692 DeclAccessPair FoundDecl,
2693 ArrayRef<Expr *> Args,
2694 OverloadCandidateSet &CandidateSet,
2695 bool SuppressUserConversions = false,
2696 bool PartialOverloading = false,
2697 bool AllowExplicit = false,
2698 ConversionSequenceList EarlyConversions = None);
2699 void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
2700 ArrayRef<Expr *> Args,
2701 OverloadCandidateSet &CandidateSet,
2702 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
2703 bool SuppressUserConversions = false,
2704 bool PartialOverloading = false,
2705 bool FirstArgumentIsBase = false);
2706 void AddMethodCandidate(DeclAccessPair FoundDecl,
2707 QualType ObjectType,
2708 Expr::Classification ObjectClassification,
2709 ArrayRef<Expr *> Args,
2710 OverloadCandidateSet& CandidateSet,
2711 bool SuppressUserConversion = false);
2712 void AddMethodCandidate(CXXMethodDecl *Method,
2713 DeclAccessPair FoundDecl,
2714 CXXRecordDecl *ActingContext, QualType ObjectType,
2715 Expr::Classification ObjectClassification,
2716 ArrayRef<Expr *> Args,
2717 OverloadCandidateSet& CandidateSet,
2718 bool SuppressUserConversions = false,
2719 bool PartialOverloading = false,
2720 ConversionSequenceList EarlyConversions = None);
2721 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
2722 DeclAccessPair FoundDecl,
2723 CXXRecordDecl *ActingContext,
2724 TemplateArgumentListInfo *ExplicitTemplateArgs,
2725 QualType ObjectType,
2726 Expr::Classification ObjectClassification,
2727 ArrayRef<Expr *> Args,
2728 OverloadCandidateSet& CandidateSet,
2729 bool SuppressUserConversions = false,
2730 bool PartialOverloading = false);
2731 void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
2732 DeclAccessPair FoundDecl,
2733 TemplateArgumentListInfo *ExplicitTemplateArgs,
2734 ArrayRef<Expr *> Args,
2735 OverloadCandidateSet& CandidateSet,
2736 bool SuppressUserConversions = false,
2737 bool PartialOverloading = false);
2738 bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate,
2739 ArrayRef<QualType> ParamTypes,
2740 ArrayRef<Expr *> Args,
2741 OverloadCandidateSet &CandidateSet,
2742 ConversionSequenceList &Conversions,
2743 bool SuppressUserConversions,
2744 CXXRecordDecl *ActingContext = nullptr,
2745 QualType ObjectType = QualType(),
2746 Expr::Classification
2747 ObjectClassification = {});
2748 void AddConversionCandidate(CXXConversionDecl *Conversion,
2749 DeclAccessPair FoundDecl,
2750 CXXRecordDecl *ActingContext,
2751 Expr *From, QualType ToType,
2752 OverloadCandidateSet& CandidateSet,
2753 bool AllowObjCConversionOnExplicit,
2754 bool AllowResultConversion = true);
2755 void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
2756 DeclAccessPair FoundDecl,
2757 CXXRecordDecl *ActingContext,
2758 Expr *From, QualType ToType,
2759 OverloadCandidateSet &CandidateSet,
2760 bool AllowObjCConversionOnExplicit,
2761 bool AllowResultConversion = true);
2762 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
2763 DeclAccessPair FoundDecl,
2764 CXXRecordDecl *ActingContext,
2765 const FunctionProtoType *Proto,
2766 Expr *Object, ArrayRef<Expr *> Args,
2767 OverloadCandidateSet& CandidateSet);
2768 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
2769 SourceLocation OpLoc, ArrayRef<Expr *> Args,
2770 OverloadCandidateSet& CandidateSet,
2771 SourceRange OpRange = SourceRange());
2772 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
2773 OverloadCandidateSet& CandidateSet,
2774 bool IsAssignmentOperator = false,
2775 unsigned NumContextualBoolArguments = 0);
2776 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
2777 SourceLocation OpLoc, ArrayRef<Expr *> Args,
2778 OverloadCandidateSet& CandidateSet);
2779 void AddArgumentDependentLookupCandidates(DeclarationName Name,
2780 SourceLocation Loc,
2781 ArrayRef<Expr *> Args,
2782 TemplateArgumentListInfo *ExplicitTemplateArgs,
2783 OverloadCandidateSet& CandidateSet,
2784 bool PartialOverloading = false);
2785
2786 // Emit as a 'note' the specific overload candidate
2787 void NoteOverloadCandidate(NamedDecl *Found, FunctionDecl *Fn,
2788 QualType DestType = QualType(),
2789 bool TakingAddress = false);
2790
2791 // Emit as a series of 'note's all template and non-templates identified by
2792 // the expression Expr
2793 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
2794 bool TakingAddress = false);
2795
2796 /// Check the enable_if expressions on the given function. Returns the first
2797 /// failing attribute, or NULL if they were all successful.
2798 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
2799 bool MissingImplicitThis = false);
2800
2801 /// Find the failed Boolean condition within a given Boolean
2802 /// constant expression, and describe it with a string.
2803 ///
2804 /// \param AllowTopLevelCond Whether to allow the result to be the
2805 /// complete top-level condition.
2806 std::pair<Expr *, std::string>
2807 findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond);
2808
2809 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
2810 /// non-ArgDependent DiagnoseIfAttrs.
2811 ///
2812 /// Argument-dependent diagnose_if attributes should be checked each time a
2813 /// function is used as a direct callee of a function call.
2814 ///
2815 /// Returns true if any errors were emitted.
2816 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
2817 const Expr *ThisArg,
2818 ArrayRef<const Expr *> Args,
2819 SourceLocation Loc);
2820
2821 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
2822 /// ArgDependent DiagnoseIfAttrs.
2823 ///
2824 /// Argument-independent diagnose_if attributes should be checked on every use
2825 /// of a function.
2826 ///
2827 /// Returns true if any errors were emitted.
2828 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
2829 SourceLocation Loc);
2830
2831 /// Returns whether the given function's address can be taken or not,
2832 /// optionally emitting a diagnostic if the address can't be taken.
2833 ///
2834 /// Returns false if taking the address of the function is illegal.
2835 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
2836 bool Complain = false,
2837 SourceLocation Loc = SourceLocation());
2838
2839 // [PossiblyAFunctionType] --> [Return]
2840 // NonFunctionType --> NonFunctionType
2841 // R (A) --> R(A)
2842 // R (*)(A) --> R (A)
2843 // R (&)(A) --> R (A)
2844 // R (S::*)(A) --> R (A)
2845 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
2846
2847 FunctionDecl *
2848 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
2849 QualType TargetType,
2850 bool Complain,
2851 DeclAccessPair &Found,
2852 bool *pHadMultipleCandidates = nullptr);
2853
2854 FunctionDecl *
2855 resolveAddressOfOnlyViableOverloadCandidate(Expr *E,
2856 DeclAccessPair &FoundResult);
2857
2858 bool resolveAndFixAddressOfOnlyViableOverloadCandidate(
2859 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
2860
2861 FunctionDecl *
2862 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
2863 bool Complain = false,
2864 DeclAccessPair *Found = nullptr);
2865
2866 bool ResolveAndFixSingleFunctionTemplateSpecialization(
2867 ExprResult &SrcExpr,
2868 bool DoFunctionPointerConverion = false,
2869 bool Complain = false,
2870 SourceRange OpRangeForComplaining = SourceRange(),
2871 QualType DestTypeForComplaining = QualType(),
2872 unsigned DiagIDForComplaining = 0);
2873
2874
2875 Expr *FixOverloadedFunctionReference(Expr *E,
2876 DeclAccessPair FoundDecl,
2877 FunctionDecl *Fn);
2878 ExprResult FixOverloadedFunctionReference(ExprResult,
2879 DeclAccessPair FoundDecl,
2880 FunctionDecl *Fn);
2881
2882 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
2883 ArrayRef<Expr *> Args,
2884 OverloadCandidateSet &CandidateSet,
2885 bool PartialOverloading = false);
2886
2887 // An enum used to represent the different possible results of building a
2888 // range-based for loop.
2889 enum ForRangeStatus {
2890 FRS_Success,
2891 FRS_NoViableFunction,
2892 FRS_DiagnosticIssued
2893 };
2894
2895 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
2896 SourceLocation RangeLoc,
2897 const DeclarationNameInfo &NameInfo,
2898 LookupResult &MemberLookup,
2899 OverloadCandidateSet *CandidateSet,
2900 Expr *Range, ExprResult *CallExpr);
2901
2902 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
2903 UnresolvedLookupExpr *ULE,
2904 SourceLocation LParenLoc,
2905 MultiExprArg Args,
2906 SourceLocation RParenLoc,
2907 Expr *ExecConfig,
2908 bool AllowTypoCorrection=true,
2909 bool CalleesAddressIsTaken=false);
2910
2911 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
2912 MultiExprArg Args, SourceLocation RParenLoc,
2913 OverloadCandidateSet *CandidateSet,
2914 ExprResult *Result);
2915
2916 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
2917 UnaryOperatorKind Opc,
2918 const UnresolvedSetImpl &Fns,
2919 Expr *input, bool RequiresADL = true);
2920
2921 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
2922 BinaryOperatorKind Opc,
2923 const UnresolvedSetImpl &Fns,
2924 Expr *LHS, Expr *RHS,
2925 bool RequiresADL = true);
2926
2927 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
2928 SourceLocation RLoc,
2929 Expr *Base,Expr *Idx);
2930
2931 ExprResult
2932 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
2933 SourceLocation LParenLoc,
2934 MultiExprArg Args,
2935 SourceLocation RParenLoc);
2936 ExprResult
2937 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
2938 MultiExprArg Args,
2939 SourceLocation RParenLoc);
2940
2941 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
2942 SourceLocation OpLoc,
2943 bool *NoArrowOperatorFound = nullptr);
2944
2945 /// CheckCallReturnType - Checks that a call expression's return type is
2946 /// complete. Returns true on failure. The location passed in is the location
2947 /// that best represents the call.
2948 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
2949 CallExpr *CE, FunctionDecl *FD);
2950
2951 /// Helpers for dealing with blocks and functions.
2952 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
2953 bool CheckParameterNames);
2954 void CheckCXXDefaultArguments(FunctionDecl *FD);
2955 void CheckExtraCXXDefaultArguments(Declarator &D);
2956 Scope *getNonFieldDeclScope(Scope *S);
2957
2958 /// \name Name lookup
2959 ///
2960 /// These routines provide name lookup that is used during semantic
2961 /// analysis to resolve the various kinds of names (identifiers,
2962 /// overloaded operator names, constructor names, etc.) into zero or
2963 /// more declarations within a particular scope. The major entry
2964 /// points are LookupName, which performs unqualified name lookup,
2965 /// and LookupQualifiedName, which performs qualified name lookup.
2966 ///
2967 /// All name lookup is performed based on some specific criteria,
2968 /// which specify what names will be visible to name lookup and how
2969 /// far name lookup should work. These criteria are important both
2970 /// for capturing language semantics (certain lookups will ignore
2971 /// certain names, for example) and for performance, since name
2972 /// lookup is often a bottleneck in the compilation of C++. Name
2973 /// lookup criteria is specified via the LookupCriteria enumeration.
2974 ///
2975 /// The results of name lookup can vary based on the kind of name
2976 /// lookup performed, the current language, and the translation
2977 /// unit. In C, for example, name lookup will either return nothing
2978 /// (no entity found) or a single declaration. In C++, name lookup
2979 /// can additionally refer to a set of overloaded functions or
2980 /// result in an ambiguity. All of the possible results of name
2981 /// lookup are captured by the LookupResult class, which provides
2982 /// the ability to distinguish among them.
2983 //@{
2984
2985 /// @brief Describes the kind of name lookup to perform.
2986 enum LookupNameKind {
2987 /// Ordinary name lookup, which finds ordinary names (functions,
2988 /// variables, typedefs, etc.) in C and most kinds of names
2989 /// (functions, variables, members, types, etc.) in C++.
2990 LookupOrdinaryName = 0,
2991 /// Tag name lookup, which finds the names of enums, classes,
2992 /// structs, and unions.
2993 LookupTagName,
2994 /// Label name lookup.
2995 LookupLabel,
2996 /// Member name lookup, which finds the names of
2997 /// class/struct/union members.
2998 LookupMemberName,
2999 /// Look up of an operator name (e.g., operator+) for use with
3000 /// operator overloading. This lookup is similar to ordinary name
3001 /// lookup, but will ignore any declarations that are class members.
3002 LookupOperatorName,
3003 /// Look up of a name that precedes the '::' scope resolution
3004 /// operator in C++. This lookup completely ignores operator, object,
3005 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3006 LookupNestedNameSpecifierName,
3007 /// Look up a namespace name within a C++ using directive or
3008 /// namespace alias definition, ignoring non-namespace names (C++
3009 /// [basic.lookup.udir]p1).
3010 LookupNamespaceName,
3011 /// Look up all declarations in a scope with the given name,
3012 /// including resolved using declarations. This is appropriate
3013 /// for checking redeclarations for a using declaration.
3014 LookupUsingDeclName,
3015 /// Look up an ordinary name that is going to be redeclared as a
3016 /// name with linkage. This lookup ignores any declarations that
3017 /// are outside of the current scope unless they have linkage. See
3018 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3019 LookupRedeclarationWithLinkage,
3020 /// Look up a friend of a local class. This lookup does not look
3021 /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3022 LookupLocalFriendName,
3023 /// Look up the name of an Objective-C protocol.
3024 LookupObjCProtocolName,
3025 /// Look up implicit 'self' parameter of an objective-c method.
3026 LookupObjCImplicitSelfParam,
3027 /// \brief Look up the name of an OpenMP user-defined reduction operation.
3028 LookupOMPReductionName,
3029 /// \brief Look up any declaration with any name.
3030 LookupAnyName
3031 };
3032
3033 /// \brief Specifies whether (or how) name lookup is being performed for a
3034 /// redeclaration (vs. a reference).
3035 enum RedeclarationKind {
3036 /// \brief The lookup is a reference to this name that is not for the
3037 /// purpose of redeclaring the name.
3038 NotForRedeclaration = 0,
3039 /// \brief The lookup results will be used for redeclaration of a name,
3040 /// if an entity by that name already exists and is visible.
3041 ForVisibleRedeclaration,
3042 /// \brief The lookup results will be used for redeclaration of a name
3043 /// with external linkage; non-visible lookup results with external linkage
3044 /// may also be found.
3045 ForExternalRedeclaration
3046 };
3047
3048 RedeclarationKind forRedeclarationInCurContext() {
3049 // A declaration with an owning module for linkage can never link against
3050 // anything that is not visible. We don't need to check linkage here; if
3051 // the context has internal linkage, redeclaration lookup won't find things
3052 // from other TUs, and we can't safely compute linkage yet in general.
3053 if (cast<Decl>(CurContext)
3054 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
3055 return ForVisibleRedeclaration;
3056 return ForExternalRedeclaration;
3057 }
3058
3059 /// \brief The possible outcomes of name lookup for a literal operator.
3060 enum LiteralOperatorLookupResult {
3061 /// \brief The lookup resulted in an error.
3062 LOLR_Error,
3063 /// \brief The lookup found no match but no diagnostic was issued.
3064 LOLR_ErrorNoDiagnostic,
3065 /// \brief The lookup found a single 'cooked' literal operator, which
3066 /// expects a normal literal to be built and passed to it.
3067 LOLR_Cooked,
3068 /// \brief The lookup found a single 'raw' literal operator, which expects
3069 /// a string literal containing the spelling of the literal token.
3070 LOLR_Raw,
3071 /// \brief The lookup found an overload set of literal operator templates,
3072 /// which expect the characters of the spelling of the literal token to be
3073 /// passed as a non-type template argument pack.
3074 LOLR_Template,
3075 /// \brief The lookup found an overload set of literal operator templates,
3076 /// which expect the character type and characters of the spelling of the
3077 /// string literal token to be passed as template arguments.
3078 LOLR_StringTemplate
3079 };
3080
3081 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
3082 CXXSpecialMember SM,
3083 bool ConstArg,
3084 bool VolatileArg,
3085 bool RValueThis,
3086 bool ConstThis,
3087 bool VolatileThis);
3088
3089 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
3090 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
3091 TypoRecoveryCallback;
3092
3093private:
3094 bool CppLookupName(LookupResult &R, Scope *S);
3095
3096 struct TypoExprState {
3097 std::unique_ptr<TypoCorrectionConsumer> Consumer;
3098 TypoDiagnosticGenerator DiagHandler;
3099 TypoRecoveryCallback RecoveryHandler;
3100 TypoExprState();
3101 TypoExprState(TypoExprState &&other) noexcept;
3102 TypoExprState &operator=(TypoExprState &&other) noexcept;
3103 };
3104
3105 /// \brief The set of unhandled TypoExprs and their associated state.
3106 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
3107
3108 /// \brief Creates a new TypoExpr AST node.
3109 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
3110 TypoDiagnosticGenerator TDG,
3111 TypoRecoveryCallback TRC);
3112
3113 // \brief The set of known/encountered (unique, canonicalized) NamespaceDecls.
3114 //
3115 // The boolean value will be true to indicate that the namespace was loaded
3116 // from an AST/PCH file, or false otherwise.
3117 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
3118
3119 /// \brief Whether we have already loaded known namespaces from an extenal
3120 /// source.
3121 bool LoadedExternalKnownNamespaces;
3122
3123 /// \brief Helper for CorrectTypo and CorrectTypoDelayed used to create and
3124 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
3125 /// should be skipped entirely.
3126 std::unique_ptr<TypoCorrectionConsumer>
3127 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
3128 Sema::LookupNameKind LookupKind, Scope *S,
3129 CXXScopeSpec *SS,
3130 std::unique_ptr<CorrectionCandidateCallback> CCC,
3131 DeclContext *MemberContext, bool EnteringContext,
3132 const ObjCObjectPointerType *OPT,
3133 bool ErrorRecovery);
3134
3135public:
3136 const TypoExprState &getTypoExprState(TypoExpr *TE) const;
3137
3138 /// \brief Clears the state of the given TypoExpr.
3139 void clearDelayedTypo(TypoExpr *TE);
3140
3141 /// \brief Look up a name, looking for a single declaration. Return
3142 /// null if the results were absent, ambiguous, or overloaded.
3143 ///
3144 /// It is preferable to use the elaborated form and explicitly handle
3145 /// ambiguity and overloaded.
3146 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
3147 SourceLocation Loc,
3148 LookupNameKind NameKind,
3149 RedeclarationKind Redecl
3150 = NotForRedeclaration);
3151 bool LookupName(LookupResult &R, Scope *S,
3152 bool AllowBuiltinCreation = false);
3153 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3154 bool InUnqualifiedLookup = false);
3155 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3156 CXXScopeSpec &SS);
3157 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
3158 bool AllowBuiltinCreation = false,
3159 bool EnteringContext = false);
3160 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
3161 RedeclarationKind Redecl
3162 = NotForRedeclaration);
3163 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
3164
3165 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
3166 QualType T1, QualType T2,
3167 UnresolvedSetImpl &Functions);
3168
3169 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
3170 SourceLocation GnuLabelLoc = SourceLocation());
3171
3172 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
3173 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
3174 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
3175 unsigned Quals);
3176 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
3177 bool RValueThis, unsigned ThisQuals);
3178 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
3179 unsigned Quals);
3180 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
3181 bool RValueThis, unsigned ThisQuals);
3182 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
3183
3184 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);
3185 LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R,
3186 ArrayRef<QualType> ArgTys,
3187 bool AllowRaw,
3188 bool AllowTemplate,
3189 bool AllowStringTemplate,
3190 bool DiagnoseMissing);
3191 bool isKnownName(StringRef name);
3192
3193 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3194 ArrayRef<Expr *> Args, ADLResult &Functions);
3195
3196 void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
3197 VisibleDeclConsumer &Consumer,
3198 bool IncludeGlobalScope = true,
3199 bool LoadExternal = true);
3200 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
3201 VisibleDeclConsumer &Consumer,
3202 bool IncludeGlobalScope = true,
3203 bool IncludeDependentBases = false,
3204 bool LoadExternal = true);
3205
3206 enum CorrectTypoKind {
3207 CTK_NonError, // CorrectTypo used in a non error recovery situation.
3208 CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
3209 };
3210
3211 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
3212 Sema::LookupNameKind LookupKind,
3213 Scope *S, CXXScopeSpec *SS,
3214 std::unique_ptr<CorrectionCandidateCallback> CCC,
3215 CorrectTypoKind Mode,
3216 DeclContext *MemberContext = nullptr,
3217 bool EnteringContext = false,
3218 const ObjCObjectPointerType *OPT = nullptr,
3219 bool RecordFailure = true);
3220
3221 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
3222 Sema::LookupNameKind LookupKind, Scope *S,
3223 CXXScopeSpec *SS,
3224 std::unique_ptr<CorrectionCandidateCallback> CCC,
3225 TypoDiagnosticGenerator TDG,
3226 TypoRecoveryCallback TRC, CorrectTypoKind Mode,
3227 DeclContext *MemberContext = nullptr,
3228 bool EnteringContext = false,
3229 const ObjCObjectPointerType *OPT = nullptr);
3230
3231 /// \brief Process any TypoExprs in the given Expr and its children,
3232 /// generating diagnostics as appropriate and returning a new Expr if there
3233 /// were typos that were all successfully corrected and ExprError if one or
3234 /// more typos could not be corrected.
3235 ///
3236 /// \param E The Expr to check for TypoExprs.
3237 ///
3238 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
3239 /// initializer.
3240 ///
3241 /// \param Filter A function applied to a newly rebuilt Expr to determine if
3242 /// it is an acceptable/usable result from a single combination of typo
3243 /// corrections. As long as the filter returns ExprError, different
3244 /// combinations of corrections will be tried until all are exhausted.
3245 ExprResult
3246 CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl = nullptr,
3247 llvm::function_ref<ExprResult(Expr *)> Filter =
3248 [](Expr *E) -> ExprResult { return E; });
3249
3250 ExprResult
3251 CorrectDelayedTyposInExpr(Expr *E,
3252 llvm::function_ref<ExprResult(Expr *)> Filter) {
3253 return CorrectDelayedTyposInExpr(E, nullptr, Filter);
3254 }
3255
3256 ExprResult
3257 CorrectDelayedTyposInExpr(ExprResult ER, VarDecl *InitDecl = nullptr,
3258 llvm::function_ref<ExprResult(Expr *)> Filter =
3259 [](Expr *E) -> ExprResult { return E; }) {
3260 return ER.isInvalid() ? ER : CorrectDelayedTyposInExpr(ER.get(), Filter);
3261 }
3262
3263 ExprResult
3264 CorrectDelayedTyposInExpr(ExprResult ER,
3265 llvm::function_ref<ExprResult(Expr *)> Filter) {
3266 return CorrectDelayedTyposInExpr(ER, nullptr, Filter);
3267 }
3268
3269 void diagnoseTypo(const TypoCorrection &Correction,
3270 const PartialDiagnostic &TypoDiag,
3271 bool ErrorRecovery = true);
3272
3273 void diagnoseTypo(const TypoCorrection &Correction,
3274 const PartialDiagnostic &TypoDiag,
3275 const PartialDiagnostic &PrevNote,
3276 bool ErrorRecovery = true);
3277
3278 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
3279
3280 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
3281 ArrayRef<Expr *> Args,
3282 AssociatedNamespaceSet &AssociatedNamespaces,
3283 AssociatedClassSet &AssociatedClasses);
3284
3285 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
3286 bool ConsiderLinkage, bool AllowInlineNamespace);
3287
3288 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
3289
3290 void DiagnoseAmbiguousLookup(LookupResult &Result);
3291 //@}
3292
3293 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
3294 SourceLocation IdLoc,
3295 bool TypoCorrection = false);
3296 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
3297 Scope *S, bool ForRedeclaration,
3298 SourceLocation Loc);
3299 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
3300 Scope *S);
3301 void AddKnownFunctionAttributes(FunctionDecl *FD);
3302
3303 // More parsing and symbol table subroutines.
3304
3305 void ProcessPragmaWeak(Scope *S, Decl *D);
3306 // Decl attributes - this routine is the top level dispatcher.
3307 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
3308 // Helper for delayed processing of attributes.
3309 void ProcessDeclAttributeDelayed(Decl *D, const AttributeList *AttrList);
3310 void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL,
3311 bool IncludeCXX11Attributes = true);
3312 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
3313 const AttributeList *AttrList);
3314
3315 void checkUnusedDeclAttributes(Declarator &D);
3316
3317 /// Determine if type T is a valid subject for a nonnull and similar
3318 /// attributes. By default, we look through references (the behavior used by
3319 /// nonnull), but if the second parameter is true, then we treat a reference
3320 /// type as valid.
3321 bool isValidPointerAttrType(QualType T, bool RefOkay = false);
3322
3323 bool CheckRegparmAttr(const AttributeList &attr, unsigned &value);
3324 bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
3325 const FunctionDecl *FD = nullptr);
3326 bool CheckAttrTarget(const AttributeList &CurrAttr);
3327 bool CheckAttrNoArgs(const AttributeList &CurrAttr);
3328 bool checkStringLiteralArgumentAttr(const AttributeList &Attr,
3329 unsigned ArgNum, StringRef &Str,
3330 SourceLocation *ArgLocation = nullptr);
3331 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
3332 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
3333 bool checkMSInheritanceAttrOnDefinition(
3334 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3335 MSInheritanceAttr::Spelling SemanticSpelling);
3336
3337 void CheckAlignasUnderalignment(Decl *D);
3338
3339 /// Adjust the calling convention of a method to be the ABI default if it
3340 /// wasn't specified explicitly. This handles method types formed from
3341 /// function type typedefs and typename template arguments.
3342 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
3343 SourceLocation Loc);
3344
3345 // Check if there is an explicit attribute, but only look through parens.
3346 // The intent is to look for an attribute on the current declarator, but not
3347 // one that came from a typedef.
3348 bool hasExplicitCallingConv(QualType &T);
3349
3350 /// Get the outermost AttributedType node that sets a calling convention.
3351 /// Valid types should not have multiple attributes with different CCs.
3352 const AttributedType *getCallingConvAttributedType(QualType T) const;
3353
3354 /// Check whether a nullability type specifier can be added to the given
3355 /// type.
3356 ///
3357 /// \param type The type to which the nullability specifier will be
3358 /// added. On success, this type will be updated appropriately.
3359 ///
3360 /// \param nullability The nullability specifier to add.
3361 ///
3362 /// \param nullabilityLoc The location of the nullability specifier.
3363 ///
3364 /// \param isContextSensitive Whether this nullability specifier was
3365 /// written as a context-sensitive keyword (in an Objective-C
3366 /// method) or an Objective-C property attribute, rather than as an
3367 /// underscored type specifier.
3368 ///
3369 /// \param allowArrayTypes Whether to accept nullability specifiers on an
3370 /// array type (e.g., because it will decay to a pointer).
3371 ///
3372 /// \returns true if nullability cannot be applied, false otherwise.
3373 bool checkNullabilityTypeSpecifier(QualType &type, NullabilityKind nullability,
3374 SourceLocation nullabilityLoc,
3375 bool isContextSensitive,
3376 bool allowArrayTypes);
3377
3378 /// \brief Stmt attributes - this routine is the top level dispatcher.
3379 StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs,
3380 SourceRange Range);
3381
3382 void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
3383 ObjCMethodDecl *MethodDecl,
3384 bool IsProtocolMethodDecl);
3385
3386 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
3387 ObjCMethodDecl *Overridden,
3388 bool IsProtocolMethodDecl);
3389
3390 /// WarnExactTypedMethods - This routine issues a warning if method
3391 /// implementation declaration matches exactly that of its declaration.
3392 void WarnExactTypedMethods(ObjCMethodDecl *Method,
3393 ObjCMethodDecl *MethodDecl,
3394 bool IsProtocolMethodDecl);
3395
3396 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
3397
3398 /// CheckImplementationIvars - This routine checks if the instance variables
3399 /// listed in the implelementation match those listed in the interface.
3400 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
3401 ObjCIvarDecl **Fields, unsigned nIvars,
3402 SourceLocation Loc);
3403
3404 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
3405 /// remains unimplemented in the class or category \@implementation.
3406 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
3407 ObjCContainerDecl* IDecl,
3408 bool IncompleteImpl = false);
3409
3410 /// DiagnoseUnimplementedProperties - This routine warns on those properties
3411 /// which must be implemented by this implementation.
3412 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
3413 ObjCContainerDecl *CDecl,
3414 bool SynthesizeProperties);
3415
3416 /// Diagnose any null-resettable synthesized setters.
3417 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
3418
3419 /// DefaultSynthesizeProperties - This routine default synthesizes all
3420 /// properties which must be synthesized in the class's \@implementation.
3421 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
3422 ObjCInterfaceDecl *IDecl,
3423 SourceLocation AtEnd);
3424 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);
3425
3426 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
3427 /// an ivar synthesized for 'Method' and 'Method' is a property accessor
3428 /// declared in class 'IFace'.
3429 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
3430 ObjCMethodDecl *Method, ObjCIvarDecl *IV);
3431
3432 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
3433 /// backs the property is not used in the property's accessor.
3434 void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
3435 const ObjCImplementationDecl *ImplD);
3436
3437 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
3438 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
3439 /// It also returns ivar's property on success.
3440 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
3441 const ObjCPropertyDecl *&PDecl) const;
3442
3443 /// Called by ActOnProperty to handle \@property declarations in
3444 /// class extensions.
3445 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,
3446 SourceLocation AtLoc,
3447 SourceLocation LParenLoc,
3448 FieldDeclarator &FD,
3449 Selector GetterSel,
3450 SourceLocation GetterNameLoc,
3451 Selector SetterSel,
3452 SourceLocation SetterNameLoc,
3453 const bool isReadWrite,
3454 unsigned &Attributes,
3455 const unsigned AttributesAsWritten,
3456 QualType T,
3457 TypeSourceInfo *TSI,
3458 tok::ObjCKeywordKind MethodImplKind);
3459
3460 /// Called by ActOnProperty and HandlePropertyInClassExtension to
3461 /// handle creating the ObjcPropertyDecl for a category or \@interface.
3462 ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
3463 ObjCContainerDecl *CDecl,
3464 SourceLocation AtLoc,
3465 SourceLocation LParenLoc,
3466 FieldDeclarator &FD,
3467 Selector GetterSel,
3468 SourceLocation GetterNameLoc,
3469 Selector SetterSel,
3470 SourceLocation SetterNameLoc,
3471 const bool isReadWrite,
3472 const unsigned Attributes,
3473 const unsigned AttributesAsWritten,
3474 QualType T,
3475 TypeSourceInfo *TSI,
3476 tok::ObjCKeywordKind MethodImplKind,
3477 DeclContext *lexicalDC = nullptr);
3478
3479 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
3480 /// warning) when atomic property has one but not the other user-declared
3481 /// setter or getter.
3482 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
3483 ObjCInterfaceDecl* IDecl);
3484
3485 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
3486
3487 void DiagnoseMissingDesignatedInitOverrides(
3488 const ObjCImplementationDecl *ImplD,
3489 const ObjCInterfaceDecl *IFD);
3490
3491 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
3492
3493 enum MethodMatchStrategy {
3494 MMS_loose,
3495 MMS_strict
3496 };
3497
3498 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
3499 /// true, or false, accordingly.
3500 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
3501 const ObjCMethodDecl *PrevMethod,
3502 MethodMatchStrategy strategy = MMS_strict);
3503
3504 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
3505 /// or protocol against those declared in their implementations.
3506 void MatchAllMethodDeclarations(const SelectorSet &InsMap,
3507 const SelectorSet &ClsMap,
3508 SelectorSet &InsMapSeen,
3509 SelectorSet &ClsMapSeen,
3510 ObjCImplDecl* IMPDecl,
3511 ObjCContainerDecl* IDecl,
3512 bool &IncompleteImpl,
3513 bool ImmediateClass,
3514 bool WarnCategoryMethodImpl=false);
3515
3516 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
3517 /// category matches with those implemented in its primary class and
3518 /// warns each time an exact match is found.
3519 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
3520
3521 /// \brief Add the given method to the list of globally-known methods.
3522 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
3523
3524private:
3525 /// AddMethodToGlobalPool - Add an instance or factory method to the global
3526 /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
3527 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
3528
3529 /// LookupMethodInGlobalPool - Returns the instance or factory method and
3530 /// optionally warns if there are multiple signatures.
3531 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
3532 bool receiverIdOrClass,
3533 bool instance);
3534
3535public:
3536 /// \brief - Returns instance or factory methods in global method pool for
3537 /// given selector. It checks the desired kind first, if none is found, and
3538 /// parameter checkTheOther is set, it then checks the other kind. If no such
3539 /// method or only one method is found, function returns false; otherwise, it
3540 /// returns true.
3541 bool
3542 CollectMultipleMethodsInGlobalPool(Selector Sel,
3543 SmallVectorImpl<ObjCMethodDecl*>& Methods,
3544 bool InstanceFirst, bool CheckTheOther,
3545 const ObjCObjectType *TypeBound = nullptr);
3546
3547 bool
3548 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
3549 SourceRange R, bool receiverIdOrClass,
3550 SmallVectorImpl<ObjCMethodDecl*>& Methods);
3551
3552 void
3553 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
3554 Selector Sel, SourceRange R,
3555 bool receiverIdOrClass);
3556
3557private:
3558 /// \brief - Returns a selector which best matches given argument list or
3559 /// nullptr if none could be found
3560 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
3561 bool IsInstance,
3562 SmallVectorImpl<ObjCMethodDecl*>& Methods);
3563
3564
3565 /// \brief Record the typo correction failure and return an empty correction.
3566 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
3567 bool RecordFailure = true) {
3568 if (RecordFailure)
3569 TypoCorrectionFailures[Typo].insert(TypoLoc);
3570 return TypoCorrection();
3571 }
3572
3573public:
3574 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
3575 /// unit are added to a global pool. This allows us to efficiently associate
3576 /// a selector with a method declaraation for purposes of typechecking
3577 /// messages sent to "id" (where the class of the object is unknown).
3578 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
3579 AddMethodToGlobalPool(Method, impl, /*instance*/true);
3580 }
3581
3582 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
3583 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
3584 AddMethodToGlobalPool(Method, impl, /*instance*/false);
3585 }
3586
3587 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
3588 /// pool.
3589 void AddAnyMethodToGlobalPool(Decl *D);
3590
3591 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
3592 /// there are multiple signatures.
3593 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
3594 bool receiverIdOrClass=false) {
3595 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
3596 /*instance*/true);
3597 }
3598
3599 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
3600 /// there are multiple signatures.
3601 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
3602 bool receiverIdOrClass=false) {
3603 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
3604 /*instance*/false);
3605 }
3606
3607 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
3608 QualType ObjectType=QualType());
3609 /// LookupImplementedMethodInGlobalPool - Returns the method which has an
3610 /// implementation.
3611 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
3612
3613 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
3614 /// initialization.
3615 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
3616 SmallVectorImpl<ObjCIvarDecl*> &Ivars);
3617
3618 //===--------------------------------------------------------------------===//
3619 // Statement Parsing Callbacks: SemaStmt.cpp.
3620public:
3621 class FullExprArg {
3622 public:
3623 FullExprArg() : E(nullptr) { }
3624 FullExprArg(Sema &actions) : E(nullptr) { }
3625
3626 ExprResult release() {
3627 return E;
3628 }
3629
3630 Expr *get() const { return E; }
3631
3632 Expr *operator->() {
3633 return E;
3634 }
3635
3636 private:
3637 // FIXME: No need to make the entire Sema class a friend when it's just
3638 // Sema::MakeFullExpr that needs access to the constructor below.
3639 friend class Sema;
3640
3641 explicit FullExprArg(Expr *expr) : E(expr) {}
3642
3643 Expr *E;
3644 };
3645
3646 FullExprArg MakeFullExpr(Expr *Arg) {
3647 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
3648 }
3649 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
3650 return FullExprArg(ActOnFinishFullExpr(Arg, CC).get());
3651 }
3652 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
3653 ExprResult FE =
3654 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),
3655 /*DiscardedValue*/ true);
3656 return FullExprArg(FE.get());
3657 }
3658
3659 StmtResult ActOnExprStmt(ExprResult Arg);
3660 StmtResult ActOnExprStmtError();
3661
3662 StmtResult ActOnNullStmt(SourceLocation SemiLoc,
3663 bool HasLeadingEmptyMacro = false);
3664
3665 void ActOnStartOfCompoundStmt(bool IsStmtExpr);
3666 void ActOnFinishOfCompoundStmt();
3667 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
3668 ArrayRef<Stmt *> Elts, bool isStmtExpr);
3669
3670 /// \brief A RAII object to enter scope of a compound statement.
3671 class CompoundScopeRAII {
3672 public:
3673 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {
3674 S.ActOnStartOfCompoundStmt(IsStmtExpr);
3675 }
3676
3677 ~CompoundScopeRAII() {
3678 S.ActOnFinishOfCompoundStmt();
3679 }
3680
3681 private:
3682 Sema &S;
3683 };
3684
3685 /// An RAII helper that pops function a function scope on exit.
3686 struct FunctionScopeRAII {
3687 Sema &S;
3688 bool Active;
3689 FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
3690 ~FunctionScopeRAII() {
3691 if (Active)
3692 S.PopFunctionScopeInfo();
3693 }
3694 void disable() { Active = false; }
3695 };
3696
3697 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
3698 SourceLocation StartLoc,
3699 SourceLocation EndLoc);
3700 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
3701 StmtResult ActOnForEachLValueExpr(Expr *E);
3702 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
3703 SourceLocation DotDotDotLoc, Expr *RHSVal,
3704 SourceLocation ColonLoc);
3705 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
3706
3707 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
3708 SourceLocation ColonLoc,
3709 Stmt *SubStmt, Scope *CurScope);
3710 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
3711 SourceLocation ColonLoc, Stmt *SubStmt);
3712
3713 StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,
3714 ArrayRef<const Attr*> Attrs,
3715 Stmt *SubStmt);
3716
3717 class ConditionResult;
3718 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
3719 Stmt *InitStmt,
3720 ConditionResult Cond, Stmt *ThenVal,
3721 SourceLocation ElseLoc, Stmt *ElseVal);
3722 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
3723 Stmt *InitStmt,
3724 ConditionResult Cond, Stmt *ThenVal,
3725 SourceLocation ElseLoc, Stmt *ElseVal);
3726 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
3727 Stmt *InitStmt,
3728 ConditionResult Cond);
3729 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
3730 Stmt *Switch, Stmt *Body);
3731 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, ConditionResult Cond,
3732 Stmt *Body);
3733 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
3734 SourceLocation WhileLoc, SourceLocation CondLParen,
3735 Expr *Cond, SourceLocation CondRParen);
3736
3737 StmtResult ActOnForStmt(SourceLocation ForLoc,
3738 SourceLocation LParenLoc,
3739 Stmt *First,
3740 ConditionResult Second,
3741 FullExprArg Third,
3742 SourceLocation RParenLoc,
3743 Stmt *Body);
3744 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
3745 Expr *collection);
3746 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
3747 Stmt *First, Expr *collection,
3748 SourceLocation RParenLoc);
3749 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
3750
3751 enum BuildForRangeKind {
3752 /// Initial building of a for-range statement.
3753 BFRK_Build,
3754 /// Instantiation or recovery rebuild of a for-range statement. Don't
3755 /// attempt any typo-correction.
3756 BFRK_Rebuild,
3757 /// Determining whether a for-range statement could be built. Avoid any
3758 /// unnecessary or irreversible actions.
3759 BFRK_Check
3760 };
3761
3762 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
3763 SourceLocation CoawaitLoc,
3764 Stmt *LoopVar,
3765 SourceLocation ColonLoc, Expr *Collection,
3766 SourceLocation RParenLoc,
3767 BuildForRangeKind Kind);
3768 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
3769 SourceLocation CoawaitLoc,
3770 SourceLocation ColonLoc,
3771 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
3772 Expr *Cond, Expr *Inc,
3773 Stmt *LoopVarDecl,
3774 SourceLocation RParenLoc,
3775 BuildForRangeKind Kind);
3776 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
3777
3778 StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
3779 SourceLocation LabelLoc,
3780 LabelDecl *TheDecl);
3781 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
3782 SourceLocation StarLoc,
3783 Expr *DestExp);
3784 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
3785 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
3786
3787 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
3788 CapturedRegionKind Kind, unsigned NumParams);
3789 typedef std::pair<StringRef, QualType> CapturedParamNameType;
3790 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
3791 CapturedRegionKind Kind,
3792 ArrayRef<CapturedParamNameType> Params);
3793 StmtResult ActOnCapturedRegionEnd(Stmt *S);
3794 void ActOnCapturedRegionError();
3795 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
3796 SourceLocation Loc,
3797 unsigned NumParams);
3798
3799 enum CopyElisionSemanticsKind {
3800 CES_Strict = 0,
3801 CES_AllowParameters = 1,
3802 CES_AllowDifferentTypes = 2,
3803 CES_Default = (CES_AllowParameters | CES_AllowDifferentTypes),
3804 };
3805
3806 VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
3807 CopyElisionSemanticsKind CESK);
3808 bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
3809 CopyElisionSemanticsKind CESK);
3810
3811 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
3812 Scope *CurScope);
3813 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
3814 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
3815
3816 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
3817 bool IsVolatile, unsigned NumOutputs,
3818 unsigned NumInputs, IdentifierInfo **Names,
3819 MultiExprArg Constraints, MultiExprArg Exprs,
3820 Expr *AsmString, MultiExprArg Clobbers,
3821 SourceLocation RParenLoc);
3822
3823 void FillInlineAsmIdentifierInfo(Expr *Res,
3824 llvm::InlineAsmIdentifierInfo &Info);
3825 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
3826 SourceLocation TemplateKWLoc,
3827 UnqualifiedId &Id,
3828 bool IsUnevaluatedContext);
3829 bool LookupInlineAsmField(StringRef Base, StringRef Member,
3830 unsigned &Offset, SourceLocation AsmLoc);
3831 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
3832 SourceLocation AsmLoc);
3833 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
3834 ArrayRef<Token> AsmToks,
3835 StringRef AsmString,
3836 unsigned NumOutputs, unsigned NumInputs,
3837 ArrayRef<StringRef> Constraints,
3838 ArrayRef<StringRef> Clobbers,
3839 ArrayRef<Expr*> Exprs,
3840 SourceLocation EndLoc);
3841 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
3842 SourceLocation Location,
3843 bool AlwaysCreate);
3844
3845 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
3846 SourceLocation StartLoc,
3847 SourceLocation IdLoc, IdentifierInfo *Id,
3848 bool Invalid = false);
3849
3850 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
3851
3852 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
3853 Decl *Parm, Stmt *Body);
3854
3855 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
3856
3857 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
3858 MultiStmtArg Catch, Stmt *Finally);
3859
3860 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
3861 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
3862 Scope *CurScope);
3863 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
3864 Expr *operand);
3865 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
3866 Expr *SynchExpr,
3867 Stmt *SynchBody);
3868
3869 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
3870
3871 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
3872 SourceLocation StartLoc,
3873 SourceLocation IdLoc,
3874 IdentifierInfo *Id);
3875
3876 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
3877
3878 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
3879 Decl *ExDecl, Stmt *HandlerBlock);
3880 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
3881 ArrayRef<Stmt *> Handlers);
3882
3883 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
3884 SourceLocation TryLoc, Stmt *TryBlock,
3885 Stmt *Handler);
3886 StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
3887 Expr *FilterExpr,
3888 Stmt *Block);
3889 void ActOnStartSEHFinallyBlock();
3890 void ActOnAbortSEHFinallyBlock();
3891 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
3892 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
3893
3894 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
3895
3896 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
3897
3898 /// \brief If it's a file scoped decl that must warn if not used, keep track
3899 /// of it.
3900 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
3901
3902 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
3903 /// whose result is unused, warn.
3904 void DiagnoseUnusedExprResult(const Stmt *S);
3905 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
3906 void DiagnoseUnusedDecl(const NamedDecl *ND);
3907
3908 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
3909 /// statement as a \p Body, and it is located on the same line.
3910 ///
3911 /// This helps prevent bugs due to typos, such as:
3912 /// if (condition);
3913 /// do_stuff();
3914 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
3915 const Stmt *Body,
3916 unsigned DiagID);
3917
3918 /// Warn if a for/while loop statement \p S, which is followed by
3919 /// \p PossibleBody, has a suspicious null statement as a body.
3920 void DiagnoseEmptyLoopBody(const Stmt *S,
3921 const Stmt *PossibleBody);
3922
3923 /// Warn if a value is moved to itself.
3924 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
3925 SourceLocation OpLoc);
3926
3927 /// \brief Warn if we're implicitly casting from a _Nullable pointer type to a
3928 /// _Nonnull one.
3929 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
3930 SourceLocation Loc);
3931
3932 /// Warn when implicitly casting 0 to nullptr.
3933 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
3934
3935 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
3936 return DelayedDiagnostics.push(pool);
3937 }
3938 void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
3939
3940 typedef ProcessingContextState ParsingClassState;
3941 ParsingClassState PushParsingClass() {
3942 return DelayedDiagnostics.pushUndelayed();
3943 }
3944 void PopParsingClass(ParsingClassState state) {
3945 DelayedDiagnostics.popUndelayed(state);
3946 }
3947
3948 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
3949
3950 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
3951 const ObjCInterfaceDecl *UnknownObjCClass,
3952 bool ObjCPropertyAccess,
3953 bool AvoidPartialAvailabilityChecks = false);
3954
3955 bool makeUnavailableInSystemHeader(SourceLocation loc,
3956 UnavailableAttr::ImplicitReason reason);
3957
3958 /// \brief Issue any -Wunguarded-availability warnings in \c FD
3959 void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
3960
3961 //===--------------------------------------------------------------------===//
3962 // Expression Parsing Callbacks: SemaExpr.cpp.
3963
3964 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
3965 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
3966 const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
3967 bool ObjCPropertyAccess = false,
3968 bool AvoidPartialAvailabilityChecks = false);
3969 void NoteDeletedFunction(FunctionDecl *FD);
3970 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
3971 std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD);
3972 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
3973 ObjCMethodDecl *Getter,
3974 SourceLocation Loc);
3975 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
3976 ArrayRef<Expr *> Args);
3977
3978 void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
3979 Decl *LambdaContextDecl = nullptr,
3980 bool IsDecltype = false);
3981 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
3982 void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
3983 ReuseLambdaContextDecl_t,
3984 bool IsDecltype = false);
3985 void PopExpressionEvaluationContext();
3986
3987 void DiscardCleanupsInEvaluationContext();
3988
3989 ExprResult TransformToPotentiallyEvaluated(Expr *E);
3990 ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
3991
3992 ExprResult ActOnConstantExpression(ExprResult Res);
3993
3994 // Functions for marking a declaration referenced. These functions also
3995 // contain the relevant logic for marking if a reference to a function or
3996 // variable is an odr-use (in the C++11 sense). There are separate variants
3997 // for expressions referring to a decl; these exist because odr-use marking
3998 // needs to be delayed for some constant variables when we build one of the
3999 // named expressions.
4000 //
4001 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
4002 // should usually be true. This only needs to be set to false if the lack of
4003 // odr-use cannot be determined from the current context (for instance,
4004 // because the name denotes a virtual function and was written without an
4005 // explicit nested-name-specifier).
4006 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
4007 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
4008 bool MightBeOdrUse = true);
4009 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
4010 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
4011 void MarkMemberReferenced(MemberExpr *E);
4012
4013 void UpdateMarkingForLValueToRValue(Expr *E);
4014 void CleanupVarDeclMarking();
4015
4016 enum TryCaptureKind {
4017 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
4018 };
4019
4020 /// \brief Try to capture the given variable.
4021 ///
4022 /// \param Var The variable to capture.
4023 ///
4024 /// \param Loc The location at which the capture occurs.
4025 ///
4026 /// \param Kind The kind of capture, which may be implicit (for either a
4027 /// block or a lambda), or explicit by-value or by-reference (for a lambda).
4028 ///
4029 /// \param EllipsisLoc The location of the ellipsis, if one is provided in
4030 /// an explicit lambda capture.
4031 ///
4032 /// \param BuildAndDiagnose Whether we are actually supposed to add the
4033 /// captures or diagnose errors. If false, this routine merely check whether
4034 /// the capture can occur without performing the capture itself or complaining
4035 /// if the variable cannot be captured.
4036 ///
4037 /// \param CaptureType Will be set to the type of the field used to capture
4038 /// this variable in the innermost block or lambda. Only valid when the
4039 /// variable can be captured.
4040 ///
4041 /// \param DeclRefType Will be set to the type of a reference to the capture
4042 /// from within the current scope. Only valid when the variable can be
4043 /// captured.
4044 ///
4045 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
4046 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
4047 /// This is useful when enclosing lambdas must speculatively capture
4048 /// variables that may or may not be used in certain specializations of
4049 /// a nested generic lambda.
4050 ///
4051 /// \returns true if an error occurred (i.e., the variable cannot be
4052 /// captured) and false if the capture succeeded.
4053 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
4054 SourceLocation EllipsisLoc, bool BuildAndDiagnose,
4055 QualType &CaptureType,
4056 QualType &DeclRefType,
4057 const unsigned *const FunctionScopeIndexToStopAt);
4058
4059 /// \brief Try to capture the given variable.
4060 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
4061 TryCaptureKind Kind = TryCapture_Implicit,
4062 SourceLocation EllipsisLoc = SourceLocation());
4063
4064 /// \brief Checks if the variable must be captured.
4065 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
4066
4067 /// \brief Given a variable, determine the type that a reference to that
4068 /// variable will have in the given scope.
4069 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
4070
4071 /// Mark all of the declarations referenced within a particular AST node as
4072 /// referenced. Used when template instantiation instantiates a non-dependent
4073 /// type -- entities referenced by the type are now referenced.
4074 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
4075 void MarkDeclarationsReferencedInExpr(Expr *E,
4076 bool SkipLocalVariables = false);
4077
4078 /// \brief Try to recover by turning the given expression into a
4079 /// call. Returns true if recovery was attempted or an error was
4080 /// emitted; this may also leave the ExprResult invalid.
4081 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
4082 bool ForceComplain = false,
4083 bool (*IsPlausibleResult)(QualType) = nullptr);
4084
4085 /// \brief Figure out if an expression could be turned into a call.
4086 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
4087 UnresolvedSetImpl &NonTemplateOverloads);
4088
4089 /// \brief Conditionally issue a diagnostic based on the current
4090 /// evaluation context.
4091 ///
4092 /// \param Statement If Statement is non-null, delay reporting the
4093 /// diagnostic until the function body is parsed, and then do a basic
4094 /// reachability analysis to determine if the statement is reachable.
4095 /// If it is unreachable, the diagnostic will not be emitted.
4096 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
4097 const PartialDiagnostic &PD);
4098
4099 // Primary Expressions.
4100 SourceRange getExprRange(Expr *E) const;
4101
4102 ExprResult ActOnIdExpression(
4103 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
4104 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
4105 std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr,
4106 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
4107
4108 void DecomposeUnqualifiedId(const UnqualifiedId &Id,
4109 TemplateArgumentListInfo &Buffer,
4110 DeclarationNameInfo &NameInfo,
4111 const TemplateArgumentListInfo *&TemplateArgs);
4112
4113 bool
4114 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
4115 std::unique_ptr<CorrectionCandidateCallback> CCC,
4116 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
4117 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
4118
4119 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
4120 IdentifierInfo *II,
4121 bool AllowBuiltinCreation=false);
4122
4123 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
4124 SourceLocation TemplateKWLoc,
4125 const DeclarationNameInfo &NameInfo,
4126 bool isAddressOfOperand,
4127 const TemplateArgumentListInfo *TemplateArgs);
4128
4129 ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty,
4130 ExprValueKind VK,
4131 SourceLocation Loc,
4132 const CXXScopeSpec *SS = nullptr);
4133 ExprResult
4134 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
4135 const DeclarationNameInfo &NameInfo,
4136 const CXXScopeSpec *SS = nullptr,
4137 NamedDecl *FoundD = nullptr,
4138 const TemplateArgumentListInfo *TemplateArgs = nullptr);
4139 ExprResult
4140 BuildAnonymousStructUnionMemberReference(
4141 const CXXScopeSpec &SS,
4142 SourceLocation nameLoc,
4143 IndirectFieldDecl *indirectField,
4144 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
4145 Expr *baseObjectExpr = nullptr,
4146 SourceLocation opLoc = SourceLocation());
4147
4148 ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
4149 SourceLocation TemplateKWLoc,
4150 LookupResult &R,
4151 const TemplateArgumentListInfo *TemplateArgs,
4152 const Scope *S);
4153 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
4154 SourceLocation TemplateKWLoc,
4155 LookupResult &R,
4156 const TemplateArgumentListInfo *TemplateArgs,
4157 bool IsDefiniteInstance,
4158 const Scope *S);
4159 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
4160 const LookupResult &R,
4161 bool HasTrailingLParen);
4162
4163 ExprResult
4164 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
4165 const DeclarationNameInfo &NameInfo,
4166 bool IsAddressOfOperand, const Scope *S,
4167 TypeSourceInfo **RecoveryTSI = nullptr);
4168
4169 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
4170 SourceLocation TemplateKWLoc,
4171 const DeclarationNameInfo &NameInfo,
4172 const TemplateArgumentListInfo *TemplateArgs);
4173
4174 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
4175 LookupResult &R,
4176 bool NeedsADL,
4177 bool AcceptInvalidDecl = false);
4178 ExprResult BuildDeclarationNameExpr(
4179 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
4180 NamedDecl *FoundD = nullptr,
4181 const TemplateArgumentListInfo *TemplateArgs = nullptr,
4182 bool AcceptInvalidDecl = false);
4183
4184 ExprResult BuildLiteralOperatorCall(LookupResult &R,
4185 DeclarationNameInfo &SuffixInfo,
4186 ArrayRef<Expr *> Args,
4187 SourceLocation LitEndLoc,
4188 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
4189
4190 ExprResult BuildPredefinedExpr(SourceLocation Loc,
4191 PredefinedExpr::IdentType IT);
4192 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
4193 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
4194
4195 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
4196
4197 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
4198 ExprResult ActOnCharacterConstant(const Token &Tok,
4199 Scope *UDLScope = nullptr);
4200 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
4201 ExprResult ActOnParenListExpr(SourceLocation L,
4202 SourceLocation R,
4203 MultiExprArg Val);
4204
4205 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
4206 /// fragments (e.g. "foo" "bar" L"baz").
4207 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
4208 Scope *UDLScope = nullptr);
4209
4210 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
4211 SourceLocation DefaultLoc,
4212 SourceLocation RParenLoc,
4213 Expr *ControllingExpr,
4214 ArrayRef<ParsedType> ArgTypes,
4215 ArrayRef<Expr *> ArgExprs);
4216 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
4217 SourceLocation DefaultLoc,
4218 SourceLocation RParenLoc,
4219 Expr *ControllingExpr,
4220 ArrayRef<TypeSourceInfo *> Types,
4221 ArrayRef<Expr *> Exprs);
4222
4223 // Binary/Unary Operators. 'Tok' is the token for the operator.
4224 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
4225 Expr *InputExpr);
4226 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
4227 UnaryOperatorKind Opc, Expr *Input);
4228 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
4229 tok::TokenKind Op, Expr *Input);
4230
4231 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
4232
4233 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
4234 SourceLocation OpLoc,
4235 UnaryExprOrTypeTrait ExprKind,
4236 SourceRange R);
4237 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
4238 UnaryExprOrTypeTrait ExprKind);
4239 ExprResult
4240 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
4241 UnaryExprOrTypeTrait ExprKind,
4242 bool IsType, void *TyOrEx,
4243 SourceRange ArgRange);
4244
4245 ExprResult CheckPlaceholderExpr(Expr *E);
4246 bool CheckVecStepExpr(Expr *E);
4247
4248 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
4249 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
4250 SourceRange ExprRange,
4251 UnaryExprOrTypeTrait ExprKind);
4252 ExprResult ActOnSizeofParameterPackExpr(Scope *S,
4253 SourceLocation OpLoc,
4254 IdentifierInfo &Name,
4255 SourceLocation NameLoc,
4256 SourceLocation RParenLoc);
4257 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
4258 tok::TokenKind Kind, Expr *Input);
4259
4260 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
4261 Expr *Idx, SourceLocation RLoc);
4262 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
4263 Expr *Idx, SourceLocation RLoc);
4264 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
4265 Expr *LowerBound, SourceLocation ColonLoc,
4266 Expr *Length, SourceLocation RBLoc);
4267
4268 // This struct is for use by ActOnMemberAccess to allow
4269 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
4270 // changing the access operator from a '.' to a '->' (to see if that is the
4271 // change needed to fix an error about an unknown member, e.g. when the class
4272 // defines a custom operator->).
4273 struct ActOnMemberAccessExtraArgs {
4274 Scope *S;
4275 UnqualifiedId &Id;
4276 Decl *ObjCImpDecl;
4277 };
4278
4279 ExprResult BuildMemberReferenceExpr(
4280 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
4281 CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
4282 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,
4283 const TemplateArgumentListInfo *TemplateArgs,
4284 const Scope *S,
4285 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
4286
4287 ExprResult
4288 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
4289 bool IsArrow, const CXXScopeSpec &SS,
4290 SourceLocation TemplateKWLoc,
4291 NamedDecl *FirstQualifierInScope, LookupResult &R,
4292 const TemplateArgumentListInfo *TemplateArgs,
4293 const Scope *S,
4294 bool SuppressQualifierCheck = false,
4295 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
4296
4297 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
4298 SourceLocation OpLoc,
4299 const CXXScopeSpec &SS, FieldDecl *Field,
4300 DeclAccessPair FoundDecl,
4301 const DeclarationNameInfo &MemberNameInfo);
4302
4303 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
4304
4305 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
4306 const CXXScopeSpec &SS,
4307 const LookupResult &R);
4308
4309 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
4310 bool IsArrow, SourceLocation OpLoc,
4311 const CXXScopeSpec &SS,
4312 SourceLocation TemplateKWLoc,
4313 NamedDecl *FirstQualifierInScope,
4314 const DeclarationNameInfo &NameInfo,
4315 const TemplateArgumentListInfo *TemplateArgs);
4316
4317 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
4318 SourceLocation OpLoc,
4319 tok::TokenKind OpKind,
4320 CXXScopeSpec &SS,
4321 SourceLocation TemplateKWLoc,
4322 UnqualifiedId &Member,
4323 Decl *ObjCImpDecl);
4324
4325 void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
4326 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
4327 FunctionDecl *FDecl,
4328 const FunctionProtoType *Proto,
4329 ArrayRef<Expr *> Args,
4330 SourceLocation RParenLoc,
4331 bool ExecConfig = false);
4332 void CheckStaticArrayArgument(SourceLocation CallLoc,
4333 ParmVarDecl *Param,
4334 const Expr *ArgExpr);
4335
4336 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
4337 /// This provides the location of the left/right parens and a list of comma
4338 /// locations.
4339 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
4340 MultiExprArg ArgExprs, SourceLocation RParenLoc,
4341 Expr *ExecConfig = nullptr,
4342 bool IsExecConfig = false);
4343 ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
4344 SourceLocation LParenLoc,
4345 ArrayRef<Expr *> Arg,
4346 SourceLocation RParenLoc,
4347 Expr *Config = nullptr,
4348 bool IsExecConfig = false);
4349
4350 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
4351 MultiExprArg ExecConfig,
4352 SourceLocation GGGLoc);
4353
4354 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
4355 Declarator &D, ParsedType &Ty,
4356 SourceLocation RParenLoc, Expr *CastExpr);
4357 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
4358 TypeSourceInfo *Ty,
4359 SourceLocation RParenLoc,
4360 Expr *Op);
4361 CastKind PrepareScalarCast(ExprResult &src, QualType destType);
4362
4363 /// \brief Build an altivec or OpenCL literal.
4364 ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
4365 SourceLocation RParenLoc, Expr *E,
4366 TypeSourceInfo *TInfo);
4367
4368 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
4369
4370 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
4371 ParsedType Ty,
4372 SourceLocation RParenLoc,
4373 Expr *InitExpr);
4374
4375 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
4376 TypeSourceInfo *TInfo,
4377 SourceLocation RParenLoc,
4378 Expr *LiteralExpr);
4379
4380 ExprResult ActOnInitList(SourceLocation LBraceLoc,
4381 MultiExprArg InitArgList,
4382 SourceLocation RBraceLoc);
4383
4384 ExprResult ActOnDesignatedInitializer(Designation &Desig,
4385 SourceLocation Loc,
4386 bool GNUSyntax,
4387 ExprResult Init);
4388
4389private:
4390 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
4391
4392public:
4393 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
4394 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
4395 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
4396 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
4397 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
4398 Expr *LHSExpr, Expr *RHSExpr);
4399
4400 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
4401
4402 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
4403 /// in the case of a the GNU conditional expr extension.
4404 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
4405 SourceLocation ColonLoc,
4406 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
4407
4408 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
4409 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
4410 LabelDecl *TheDecl);
4411
4412 void ActOnStartStmtExpr();
4413 ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
4414 SourceLocation RPLoc); // "({..})"
4415 void ActOnStmtExprError();
4416
4417 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
4418 struct OffsetOfComponent {
4419 SourceLocation LocStart, LocEnd;
4420 bool isBrackets; // true if [expr], false if .ident
4421 union {
4422 IdentifierInfo *IdentInfo;
4423 Expr *E;
4424 } U;
4425 };
4426
4427 /// __builtin_offsetof(type, a.b[123][456].c)
4428 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
4429 TypeSourceInfo *TInfo,
4430 ArrayRef<OffsetOfComponent> Components,
4431 SourceLocation RParenLoc);
4432 ExprResult ActOnBuiltinOffsetOf(Scope *S,
4433 SourceLocation BuiltinLoc,
4434 SourceLocation TypeLoc,
4435 ParsedType ParsedArgTy,
4436 ArrayRef<OffsetOfComponent> Components,
4437 SourceLocation RParenLoc);
4438
4439 // __builtin_choose_expr(constExpr, expr1, expr2)
4440 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
4441 Expr *CondExpr, Expr *LHSExpr,
4442 Expr *RHSExpr, SourceLocation RPLoc);
4443
4444 // __builtin_va_arg(expr, type)
4445 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
4446 SourceLocation RPLoc);
4447 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
4448 TypeSourceInfo *TInfo, SourceLocation RPLoc);
4449
4450 // __null
4451 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
4452
4453 bool CheckCaseExpression(Expr *E);
4454
4455 /// \brief Describes the result of an "if-exists" condition check.
4456 enum IfExistsResult {
4457 /// \brief The symbol exists.
4458 IER_Exists,
4459
4460 /// \brief The symbol does not exist.
4461 IER_DoesNotExist,
4462
4463 /// \brief The name is a dependent name, so the results will differ
4464 /// from one instantiation to the next.
4465 IER_Dependent,
4466
4467 /// \brief An error occurred.
4468 IER_Error
4469 };
4470
4471 IfExistsResult
4472 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
4473 const DeclarationNameInfo &TargetNameInfo);
4474
4475 IfExistsResult
4476 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
4477 bool IsIfExists, CXXScopeSpec &SS,
4478 UnqualifiedId &Name);
4479
4480 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
4481 bool IsIfExists,
4482 NestedNameSpecifierLoc QualifierLoc,
4483 DeclarationNameInfo NameInfo,
4484 Stmt *Nested);
4485 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
4486 bool IsIfExists,
4487 CXXScopeSpec &SS, UnqualifiedId &Name,
4488 Stmt *Nested);
4489
4490 //===------------------------- "Block" Extension ------------------------===//
4491
4492 /// ActOnBlockStart - This callback is invoked when a block literal is
4493 /// started.
4494 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
4495
4496 /// ActOnBlockArguments - This callback allows processing of block arguments.
4497 /// If there are no arguments, this is still invoked.
4498 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
4499 Scope *CurScope);
4500
4501 /// ActOnBlockError - If there is an error parsing a block, this callback
4502 /// is invoked to pop the information about the block from the action impl.
4503 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
4504
4505 /// ActOnBlockStmtExpr - This is called when the body of a block statement
4506 /// literal was successfully completed. ^(int x){...}
4507 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
4508 Scope *CurScope);
4509
4510 //===---------------------------- Clang Extensions ----------------------===//
4511
4512 /// __builtin_convertvector(...)
4513 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
4514 SourceLocation BuiltinLoc,
4515 SourceLocation RParenLoc);
4516
4517 //===---------------------------- OpenCL Features -----------------------===//
4518
4519 /// __builtin_astype(...)
4520 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
4521 SourceLocation BuiltinLoc,
4522 SourceLocation RParenLoc);
4523
4524 //===---------------------------- C++ Features --------------------------===//
4525
4526 // Act on C++ namespaces
4527 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
4528 SourceLocation NamespaceLoc,
4529 SourceLocation IdentLoc,
4530 IdentifierInfo *Ident,
4531 SourceLocation LBrace,
4532 AttributeList *AttrList,
4533 UsingDirectiveDecl * &UsingDecl);
4534 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
4535
4536 NamespaceDecl *getStdNamespace() const;
4537 NamespaceDecl *getOrCreateStdNamespace();
4538
4539 NamespaceDecl *lookupStdExperimentalNamespace();
4540
4541 CXXRecordDecl *getStdBadAlloc() const;
4542 EnumDecl *getStdAlignValT() const;
4543
4544 /// \brief Tests whether Ty is an instance of std::initializer_list and, if
4545 /// it is and Element is not NULL, assigns the element type to Element.
4546 bool isStdInitializerList(QualType Ty, QualType *Element);
4547
4548 /// \brief Looks for the std::initializer_list template and instantiates it
4549 /// with Element, or emits an error if it's not found.
4550 ///
4551 /// \returns The instantiated template, or null on error.
4552 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
4553
4554 /// \brief Determine whether Ctor is an initializer-list constructor, as
4555 /// defined in [dcl.init.list]p2.
4556 bool isInitListConstructor(const FunctionDecl *Ctor);
4557
4558 Decl *ActOnUsingDirective(Scope *CurScope,
4559 SourceLocation UsingLoc,
4560 SourceLocation NamespcLoc,
4561 CXXScopeSpec &SS,
4562 SourceLocation IdentLoc,
4563 IdentifierInfo *NamespcName,
4564 AttributeList *AttrList);
4565
4566 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
4567
4568 Decl *ActOnNamespaceAliasDef(Scope *CurScope,
4569 SourceLocation NamespaceLoc,
4570 SourceLocation AliasLoc,
4571 IdentifierInfo *Alias,
4572 CXXScopeSpec &SS,
4573 SourceLocation IdentLoc,
4574 IdentifierInfo *Ident);
4575
4576 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
4577 bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,
4578 const LookupResult &PreviousDecls,
4579 UsingShadowDecl *&PrevShadow);
4580 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,
4581 NamedDecl *Target,
4582 UsingShadowDecl *PrevDecl);
4583
4584 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
4585 bool HasTypenameKeyword,
4586 const CXXScopeSpec &SS,
4587 SourceLocation NameLoc,
4588 const LookupResult &Previous);
4589 bool CheckUsingDeclQualifier(SourceLocation UsingLoc,
4590 bool HasTypename,
4591 const CXXScopeSpec &SS,
4592 const DeclarationNameInfo &NameInfo,
4593 SourceLocation NameLoc);
4594
4595 NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
4596 SourceLocation UsingLoc,
4597 bool HasTypenameKeyword,
4598 SourceLocation TypenameLoc,
4599 CXXScopeSpec &SS,
4600 DeclarationNameInfo NameInfo,
4601 SourceLocation EllipsisLoc,
4602 AttributeList *AttrList,
4603 bool IsInstantiation);
4604 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
4605 ArrayRef<NamedDecl *> Expansions);
4606
4607 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
4608
4609 /// Given a derived-class using shadow declaration for a constructor and the
4610 /// correspnding base class constructor, find or create the implicit
4611 /// synthesized derived class constructor to use for this initialization.
4612 CXXConstructorDecl *
4613 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
4614 ConstructorUsingShadowDecl *DerivedShadow);
4615
4616 Decl *ActOnUsingDeclaration(Scope *CurScope,
4617 AccessSpecifier AS,
4618 SourceLocation UsingLoc,
4619 SourceLocation TypenameLoc,
4620 CXXScopeSpec &SS,
4621 UnqualifiedId &Name,
4622 SourceLocation EllipsisLoc,
4623 AttributeList *AttrList);
4624 Decl *ActOnAliasDeclaration(Scope *CurScope,
4625 AccessSpecifier AS,
4626 MultiTemplateParamsArg TemplateParams,
4627 SourceLocation UsingLoc,
4628 UnqualifiedId &Name,
4629 AttributeList *AttrList,
4630 TypeResult Type,
4631 Decl *DeclFromDeclSpec);
4632
4633 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
4634 /// including handling of its default argument expressions.
4635 ///
4636 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind
4637 ExprResult
4638 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4639 NamedDecl *FoundDecl,
4640 CXXConstructorDecl *Constructor, MultiExprArg Exprs,
4641 bool HadMultipleCandidates, bool IsListInitialization,
4642 bool IsStdInitListInitialization,
4643 bool RequiresZeroInit, unsigned ConstructKind,
4644 SourceRange ParenRange);
4645
4646 /// Build a CXXConstructExpr whose constructor has already been resolved if
4647 /// it denotes an inherited constructor.
4648 ExprResult
4649 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4650 CXXConstructorDecl *Constructor, bool Elidable,
4651 MultiExprArg Exprs,
4652 bool HadMultipleCandidates, bool IsListInitialization,
4653 bool IsStdInitListInitialization,
4654 bool RequiresZeroInit, unsigned ConstructKind,
4655 SourceRange ParenRange);
4656
4657 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
4658 // the constructor can be elidable?
4659 ExprResult
4660 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4661 NamedDecl *FoundDecl,
4662 CXXConstructorDecl *Constructor, bool Elidable,
4663 MultiExprArg Exprs, bool HadMultipleCandidates,
4664 bool IsListInitialization,
4665 bool IsStdInitListInitialization, bool RequiresZeroInit,
4666 unsigned ConstructKind, SourceRange ParenRange);
4667
4668 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
4669
4670
4671 /// Instantiate or parse a C++ default argument expression as necessary.
4672 /// Return true on error.
4673 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
4674 ParmVarDecl *Param);
4675
4676 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
4677 /// the default expr if needed.
4678 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
4679 FunctionDecl *FD,
4680 ParmVarDecl *Param);
4681
4682 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
4683 /// constructed variable.
4684 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
4685
4686 /// \brief Helper class that collects exception specifications for
4687 /// implicitly-declared special member functions.
4688 class ImplicitExceptionSpecification {
4689 // Pointer to allow copying
4690 Sema *Self;
4691 // We order exception specifications thus:
4692 // noexcept is the most restrictive, but is only used in C++11.
4693 // throw() comes next.
4694 // Then a throw(collected exceptions)
4695 // Finally no specification, which is expressed as noexcept(false).
4696 // throw(...) is used instead if any called function uses it.
4697 ExceptionSpecificationType ComputedEST;
4698 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;
4699 SmallVector<QualType, 4> Exceptions;
4700
4701 void ClearExceptions() {
4702 ExceptionsSeen.clear();
4703 Exceptions.clear();
4704 }
4705
4706 public:
4707 explicit ImplicitExceptionSpecification(Sema &Self)
4708 : Self(&Self), ComputedEST(EST_BasicNoexcept) {
4709 if (!Self.getLangOpts().CPlusPlus11)
4710 ComputedEST = EST_DynamicNone;
4711 }
4712
4713 /// \brief Get the computed exception specification type.
4714 ExceptionSpecificationType getExceptionSpecType() const {
4715 assert(ComputedEST != EST_ComputedNoexcept &&(static_cast <bool> (ComputedEST != EST_ComputedNoexcept
&& "noexcept(expr) should not be a possible result")
? void (0) : __assert_fail ("ComputedEST != EST_ComputedNoexcept && \"noexcept(expr) should not be a possible result\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 4716, __extension__ __PRETTY_FUNCTION__))
4716 "noexcept(expr) should not be a possible result")(static_cast <bool> (ComputedEST != EST_ComputedNoexcept
&& "noexcept(expr) should not be a possible result")
? void (0) : __assert_fail ("ComputedEST != EST_ComputedNoexcept && \"noexcept(expr) should not be a possible result\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 4716, __extension__ __PRETTY_FUNCTION__))
;
4717 return ComputedEST;
4718 }
4719
4720 /// \brief The number of exceptions in the exception specification.
4721 unsigned size() const { return Exceptions.size(); }
4722
4723 /// \brief The set of exceptions in the exception specification.
4724 const QualType *data() const { return Exceptions.data(); }
4725
4726 /// \brief Integrate another called method into the collected data.
4727 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
4728
4729 /// \brief Integrate an invoked expression into the collected data.
4730 void CalledExpr(Expr *E);
4731
4732 /// \brief Overwrite an EPI's exception specification with this
4733 /// computed exception specification.
4734 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {
4735 FunctionProtoType::ExceptionSpecInfo ESI;
4736 ESI.Type = getExceptionSpecType();
4737 if (ESI.Type == EST_Dynamic) {
4738 ESI.Exceptions = Exceptions;
4739 } else if (ESI.Type == EST_None) {
4740 /// C++11 [except.spec]p14:
4741 /// The exception-specification is noexcept(false) if the set of
4742 /// potential exceptions of the special member function contains "any"
4743 ESI.Type = EST_ComputedNoexcept;
4744 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),
4745 tok::kw_false).get();
4746 }
4747 return ESI;
4748 }
4749 };
4750
4751 /// \brief Determine what sort of exception specification a defaulted
4752 /// copy constructor of a class will have.
4753 ImplicitExceptionSpecification
4754 ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
4755 CXXMethodDecl *MD);
4756
4757 /// \brief Determine what sort of exception specification a defaulted
4758 /// default constructor of a class will have, and whether the parameter
4759 /// will be const.
4760 ImplicitExceptionSpecification
4761 ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD);
4762
4763 /// \brief Determine what sort of exception specification a defautled
4764 /// copy assignment operator of a class will have, and whether the
4765 /// parameter will be const.
4766 ImplicitExceptionSpecification
4767 ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD);
4768
4769 /// \brief Determine what sort of exception specification a defaulted move
4770 /// constructor of a class will have.
4771 ImplicitExceptionSpecification
4772 ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD);
4773
4774 /// \brief Determine what sort of exception specification a defaulted move
4775 /// assignment operator of a class will have.
4776 ImplicitExceptionSpecification
4777 ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD);
4778
4779 /// \brief Determine what sort of exception specification a defaulted
4780 /// destructor of a class will have.
4781 ImplicitExceptionSpecification
4782 ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD);
4783
4784 /// \brief Determine what sort of exception specification an inheriting
4785 /// constructor of a class will have.
4786 ImplicitExceptionSpecification
4787 ComputeInheritingCtorExceptionSpec(SourceLocation Loc,
4788 CXXConstructorDecl *CD);
4789
4790 /// \brief Evaluate the implicit exception specification for a defaulted
4791 /// special member function.
4792 void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD);
4793
4794 /// \brief Check the given exception-specification and update the
4795 /// exception specification information with the results.
4796 void checkExceptionSpecification(bool IsTopLevel,
4797 ExceptionSpecificationType EST,
4798 ArrayRef<ParsedType> DynamicExceptions,
4799 ArrayRef<SourceRange> DynamicExceptionRanges,
4800 Expr *NoexceptExpr,
4801 SmallVectorImpl<QualType> &Exceptions,
4802 FunctionProtoType::ExceptionSpecInfo &ESI);
4803
4804 /// \brief Determine if we're in a case where we need to (incorrectly) eagerly
4805 /// parse an exception specification to work around a libstdc++ bug.
4806 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
4807
4808 /// \brief Add an exception-specification to the given member function
4809 /// (or member function template). The exception-specification was parsed
4810 /// after the method itself was declared.
4811 void actOnDelayedExceptionSpecification(Decl *Method,
4812 ExceptionSpecificationType EST,
4813 SourceRange SpecificationRange,
4814 ArrayRef<ParsedType> DynamicExceptions,
4815 ArrayRef<SourceRange> DynamicExceptionRanges,
4816 Expr *NoexceptExpr);
4817
4818 class InheritedConstructorInfo;
4819
4820 /// \brief Determine if a special member function should have a deleted
4821 /// definition when it is defaulted.
4822 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
4823 InheritedConstructorInfo *ICI = nullptr,
4824 bool Diagnose = false);
4825
4826 /// \brief Declare the implicit default constructor for the given class.
4827 ///
4828 /// \param ClassDecl The class declaration into which the implicit
4829 /// default constructor will be added.
4830 ///
4831 /// \returns The implicitly-declared default constructor.
4832 CXXConstructorDecl *DeclareImplicitDefaultConstructor(
4833 CXXRecordDecl *ClassDecl);
4834
4835 /// DefineImplicitDefaultConstructor - Checks for feasibility of
4836 /// defining this constructor as the default constructor.
4837 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
4838 CXXConstructorDecl *Constructor);
4839
4840 /// \brief Declare the implicit destructor for the given class.
4841 ///
4842 /// \param ClassDecl The class declaration into which the implicit
4843 /// destructor will be added.
4844 ///
4845 /// \returns The implicitly-declared destructor.
4846 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);
4847
4848 /// DefineImplicitDestructor - Checks for feasibility of
4849 /// defining this destructor as the default destructor.
4850 void DefineImplicitDestructor(SourceLocation CurrentLocation,
4851 CXXDestructorDecl *Destructor);
4852
4853 /// \brief Build an exception spec for destructors that don't have one.
4854 ///
4855 /// C++11 says that user-defined destructors with no exception spec get one
4856 /// that looks as if the destructor was implicitly declared.
4857 void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
4858 CXXDestructorDecl *Destructor);
4859
4860 /// \brief Define the specified inheriting constructor.
4861 void DefineInheritingConstructor(SourceLocation UseLoc,
4862 CXXConstructorDecl *Constructor);
4863
4864 /// \brief Declare the implicit copy constructor for the given class.
4865 ///
4866 /// \param ClassDecl The class declaration into which the implicit
4867 /// copy constructor will be added.
4868 ///
4869 /// \returns The implicitly-declared copy constructor.
4870 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);
4871
4872 /// DefineImplicitCopyConstructor - Checks for feasibility of
4873 /// defining this constructor as the copy constructor.
4874 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
4875 CXXConstructorDecl *Constructor);
4876
4877 /// \brief Declare the implicit move constructor for the given class.
4878 ///
4879 /// \param ClassDecl The Class declaration into which the implicit
4880 /// move constructor will be added.
4881 ///
4882 /// \returns The implicitly-declared move constructor, or NULL if it wasn't
4883 /// declared.
4884 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);
4885
4886 /// DefineImplicitMoveConstructor - Checks for feasibility of
4887 /// defining this constructor as the move constructor.
4888 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
4889 CXXConstructorDecl *Constructor);
4890
4891 /// \brief Declare the implicit copy assignment operator for the given class.
4892 ///
4893 /// \param ClassDecl The class declaration into which the implicit
4894 /// copy assignment operator will be added.
4895 ///
4896 /// \returns The implicitly-declared copy assignment operator.
4897 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);
4898
4899 /// \brief Defines an implicitly-declared copy assignment operator.
4900 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
4901 CXXMethodDecl *MethodDecl);
4902
4903 /// \brief Declare the implicit move assignment operator for the given class.
4904 ///
4905 /// \param ClassDecl The Class declaration into which the implicit
4906 /// move assignment operator will be added.
4907 ///
4908 /// \returns The implicitly-declared move assignment operator, or NULL if it
4909 /// wasn't declared.
4910 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);
4911
4912 /// \brief Defines an implicitly-declared move assignment operator.
4913 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
4914 CXXMethodDecl *MethodDecl);
4915
4916 /// \brief Force the declaration of any implicitly-declared members of this
4917 /// class.
4918 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
4919
4920 /// \brief Check a completed declaration of an implicit special member.
4921 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);
4922
4923 /// \brief Determine whether the given function is an implicitly-deleted
4924 /// special member function.
4925 bool isImplicitlyDeleted(FunctionDecl *FD);
4926
4927 /// \brief Check whether 'this' shows up in the type of a static member
4928 /// function after the (naturally empty) cv-qualifier-seq would be.
4929 ///
4930 /// \returns true if an error occurred.
4931 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
4932
4933 /// \brief Whether this' shows up in the exception specification of a static
4934 /// member function.
4935 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
4936
4937 /// \brief Check whether 'this' shows up in the attributes of the given
4938 /// static member function.
4939 ///
4940 /// \returns true if an error occurred.
4941 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
4942
4943 /// MaybeBindToTemporary - If the passed in expression has a record type with
4944 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
4945 /// it simply returns the passed in expression.
4946 ExprResult MaybeBindToTemporary(Expr *E);
4947
4948 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
4949 MultiExprArg ArgsPtr,
4950 SourceLocation Loc,
4951 SmallVectorImpl<Expr*> &ConvertedArgs,
4952 bool AllowExplicit = false,
4953 bool IsListInitialization = false);
4954
4955 ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
4956 SourceLocation NameLoc,
4957 IdentifierInfo &Name);
4958
4959 ParsedType getDestructorName(SourceLocation TildeLoc,
4960 IdentifierInfo &II, SourceLocation NameLoc,
4961 Scope *S, CXXScopeSpec &SS,
4962 ParsedType ObjectType,
4963 bool EnteringContext);
4964
4965 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
4966 ParsedType ObjectType);
4967
4968 // Checks that reinterpret casts don't have undefined behavior.
4969 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
4970 bool IsDereference, SourceRange Range);
4971
4972 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
4973 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
4974 tok::TokenKind Kind,
4975 SourceLocation LAngleBracketLoc,
4976 Declarator &D,
4977 SourceLocation RAngleBracketLoc,
4978 SourceLocation LParenLoc,
4979 Expr *E,
4980 SourceLocation RParenLoc);
4981
4982 ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
4983 tok::TokenKind Kind,
4984 TypeSourceInfo *Ty,
4985 Expr *E,
4986 SourceRange AngleBrackets,
4987 SourceRange Parens);
4988
4989 ExprResult BuildCXXTypeId(QualType TypeInfoType,
4990 SourceLocation TypeidLoc,
4991 TypeSourceInfo *Operand,
4992 SourceLocation RParenLoc);
4993 ExprResult BuildCXXTypeId(QualType TypeInfoType,
4994 SourceLocation TypeidLoc,
4995 Expr *Operand,
4996 SourceLocation RParenLoc);
4997
4998 /// ActOnCXXTypeid - Parse typeid( something ).
4999 ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
5000 SourceLocation LParenLoc, bool isType,
5001 void *TyOrExpr,
5002 SourceLocation RParenLoc);
5003
5004 ExprResult BuildCXXUuidof(QualType TypeInfoType,
5005 SourceLocation TypeidLoc,
5006 TypeSourceInfo *Operand,
5007 SourceLocation RParenLoc);
5008 ExprResult BuildCXXUuidof(QualType TypeInfoType,
5009 SourceLocation TypeidLoc,
5010 Expr *Operand,
5011 SourceLocation RParenLoc);
5012
5013 /// ActOnCXXUuidof - Parse __uuidof( something ).
5014 ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
5015 SourceLocation LParenLoc, bool isType,
5016 void *TyOrExpr,
5017 SourceLocation RParenLoc);
5018
5019 /// \brief Handle a C++1z fold-expression: ( expr op ... op expr ).
5020 ExprResult ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5021 tok::TokenKind Operator,
5022 SourceLocation EllipsisLoc, Expr *RHS,
5023 SourceLocation RParenLoc);
5024 ExprResult BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5025 BinaryOperatorKind Operator,
5026 SourceLocation EllipsisLoc, Expr *RHS,
5027 SourceLocation RParenLoc);
5028 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
5029 BinaryOperatorKind Operator);
5030
5031 //// ActOnCXXThis - Parse 'this' pointer.
5032 ExprResult ActOnCXXThis(SourceLocation loc);
5033
5034 /// \brief Try to retrieve the type of the 'this' pointer.
5035 ///
5036 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
5037 QualType getCurrentThisType();
5038
5039 /// \brief When non-NULL, the C++ 'this' expression is allowed despite the
5040 /// current context not being a non-static member function. In such cases,
5041 /// this provides the type used for 'this'.
5042 QualType CXXThisTypeOverride;
5043
5044 /// \brief RAII object used to temporarily allow the C++ 'this' expression
5045 /// to be used, with the given qualifiers on the current class type.
5046 class CXXThisScopeRAII {
5047 Sema &S;
5048 QualType OldCXXThisTypeOverride;
5049 bool Enabled;
5050
5051 public:
5052 /// \brief Introduce a new scope where 'this' may be allowed (when enabled),
5053 /// using the given declaration (which is either a class template or a
5054 /// class) along with the given qualifiers.
5055 /// along with the qualifiers placed on '*this'.
5056 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, unsigned CXXThisTypeQuals,
5057 bool Enabled = true);
5058
5059 ~CXXThisScopeRAII();
5060 };
5061
5062 /// \brief Make sure the value of 'this' is actually available in the current
5063 /// context, if it is a potentially evaluated context.
5064 ///
5065 /// \param Loc The location at which the capture of 'this' occurs.
5066 ///
5067 /// \param Explicit Whether 'this' is explicitly captured in a lambda
5068 /// capture list.
5069 ///
5070 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
5071 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
5072 /// This is useful when enclosing lambdas must speculatively capture
5073 /// 'this' that may or may not be used in certain specializations of
5074 /// a nested generic lambda (depending on whether the name resolves to
5075 /// a non-static member function or a static function).
5076 /// \return returns 'true' if failed, 'false' if success.
5077 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
5078 bool BuildAndDiagnose = true,
5079 const unsigned *const FunctionScopeIndexToStopAt = nullptr,
5080 bool ByCopy = false);
5081
5082 /// \brief Determine whether the given type is the type of *this that is used
5083 /// outside of the body of a member function for a type that is currently
5084 /// being defined.
5085 bool isThisOutsideMemberFunctionBody(QualType BaseType);
5086
5087 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
5088 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
5089
5090
5091 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
5092 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
5093
5094 ExprResult
5095 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
5096 SourceLocation AtLoc, SourceLocation RParen);
5097
5098 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
5099 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
5100
5101 //// ActOnCXXThrow - Parse throw expressions.
5102 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
5103 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
5104 bool IsThrownVarInScope);
5105 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
5106
5107 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
5108 /// Can be interpreted either as function-style casting ("int(x)")
5109 /// or class type construction ("ClassType(x,y,z)")
5110 /// or creation of a value-initialized type ("int()").
5111 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
5112 SourceLocation LParenOrBraceLoc,
5113 MultiExprArg Exprs,
5114 SourceLocation RParenOrBraceLoc,
5115 bool ListInitialization);
5116
5117 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
5118 SourceLocation LParenLoc,
5119 MultiExprArg Exprs,
5120 SourceLocation RParenLoc,
5121 bool ListInitialization);
5122
5123 /// ActOnCXXNew - Parsed a C++ 'new' expression.
5124 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
5125 SourceLocation PlacementLParen,
5126 MultiExprArg PlacementArgs,
5127 SourceLocation PlacementRParen,
5128 SourceRange TypeIdParens, Declarator &D,
5129 Expr *Initializer);
5130 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
5131 SourceLocation PlacementLParen,
5132 MultiExprArg PlacementArgs,
5133 SourceLocation PlacementRParen,
5134 SourceRange TypeIdParens,
5135 QualType AllocType,
5136 TypeSourceInfo *AllocTypeInfo,
5137 Expr *ArraySize,
5138 SourceRange DirectInitRange,
5139 Expr *Initializer);
5140
5141 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
5142 SourceRange R);
5143
5144 /// \brief The scope in which to find allocation functions.
5145 enum AllocationFunctionScope {
5146 /// \brief Only look for allocation functions in the global scope.
5147 AFS_Global,
5148 /// \brief Only look for allocation functions in the scope of the
5149 /// allocated class.
5150 AFS_Class,
5151 /// \brief Look for allocation functions in both the global scope
5152 /// and in the scope of the allocated class.
5153 AFS_Both
5154 };
5155
5156 /// \brief Finds the overloads of operator new and delete that are appropriate
5157 /// for the allocation.
5158 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
5159 AllocationFunctionScope NewScope,
5160 AllocationFunctionScope DeleteScope,
5161 QualType AllocType, bool IsArray,
5162 bool &PassAlignment, MultiExprArg PlaceArgs,
5163 FunctionDecl *&OperatorNew,
5164 FunctionDecl *&OperatorDelete,
5165 bool Diagnose = true);
5166 void DeclareGlobalNewDelete();
5167 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
5168 ArrayRef<QualType> Params);
5169
5170 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
5171 DeclarationName Name, FunctionDecl* &Operator,
5172 bool Diagnose = true);
5173 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
5174 bool CanProvideSize,
5175 bool Overaligned,
5176 DeclarationName Name);
5177 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
5178 CXXRecordDecl *RD);
5179
5180 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
5181 ExprResult ActOnCXXDelete(SourceLocation StartLoc,
5182 bool UseGlobal, bool ArrayForm,
5183 Expr *Operand);
5184 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
5185 bool IsDelete, bool CallCanBeVirtual,
5186 bool WarnOnNonAbstractTypes,
5187 SourceLocation DtorLoc);
5188
5189 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
5190 Expr *Operand, SourceLocation RParen);
5191 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
5192 SourceLocation RParen);
5193
5194 /// \brief Parsed one of the type trait support pseudo-functions.
5195 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
5196 ArrayRef<ParsedType> Args,
5197 SourceLocation RParenLoc);
5198 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
5199 ArrayRef<TypeSourceInfo *> Args,
5200 SourceLocation RParenLoc);
5201
5202 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support
5203 /// pseudo-functions.
5204 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
5205 SourceLocation KWLoc,
5206 ParsedType LhsTy,
5207 Expr *DimExpr,
5208 SourceLocation RParen);
5209
5210 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
5211 SourceLocation KWLoc,
5212 TypeSourceInfo *TSInfo,
5213 Expr *DimExpr,
5214 SourceLocation RParen);
5215
5216 /// ActOnExpressionTrait - Parsed one of the unary type trait support
5217 /// pseudo-functions.
5218 ExprResult ActOnExpressionTrait(ExpressionTrait OET,
5219 SourceLocation KWLoc,
5220 Expr *Queried,
5221 SourceLocation RParen);
5222
5223 ExprResult BuildExpressionTrait(ExpressionTrait OET,
5224 SourceLocation KWLoc,
5225 Expr *Queried,
5226 SourceLocation RParen);
5227
5228 ExprResult ActOnStartCXXMemberReference(Scope *S,
5229 Expr *Base,
5230 SourceLocation OpLoc,
5231 tok::TokenKind OpKind,
5232 ParsedType &ObjectType,
5233 bool &MayBePseudoDestructor);
5234
5235 ExprResult BuildPseudoDestructorExpr(Expr *Base,
5236 SourceLocation OpLoc,
5237 tok::TokenKind OpKind,
5238 const CXXScopeSpec &SS,
5239 TypeSourceInfo *ScopeType,
5240 SourceLocation CCLoc,
5241 SourceLocation TildeLoc,
5242 PseudoDestructorTypeStorage DestroyedType);
5243
5244 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5245 SourceLocation OpLoc,
5246 tok::TokenKind OpKind,
5247 CXXScopeSpec &SS,
5248 UnqualifiedId &FirstTypeName,
5249 SourceLocation CCLoc,
5250 SourceLocation TildeLoc,
5251 UnqualifiedId &SecondTypeName);
5252
5253 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5254 SourceLocation OpLoc,
5255 tok::TokenKind OpKind,
5256 SourceLocation TildeLoc,
5257 const DeclSpec& DS);
5258
5259 /// MaybeCreateExprWithCleanups - If the current full-expression
5260 /// requires any cleanups, surround it with a ExprWithCleanups node.
5261 /// Otherwise, just returns the passed-in expression.
5262 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
5263 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
5264 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
5265
5266 MaterializeTemporaryExpr *
5267 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
5268 bool BoundToLvalueReference);
5269
5270 ExprResult ActOnFinishFullExpr(Expr *Expr) {
5271 return ActOnFinishFullExpr(Expr, Expr ? Expr->getExprLoc()
5272 : SourceLocation());
5273 }
5274 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
5275 bool DiscardedValue = false,
5276 bool IsConstexpr = false,
5277 bool IsLambdaInitCaptureInitializer = false);
5278 StmtResult ActOnFinishFullStmt(Stmt *Stmt);
5279
5280 // Marks SS invalid if it represents an incomplete type.
5281 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
5282
5283 DeclContext *computeDeclContext(QualType T);
5284 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
5285 bool EnteringContext = false);
5286 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
5287 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
5288
5289 /// \brief The parser has parsed a global nested-name-specifier '::'.
5290 ///
5291 /// \param CCLoc The location of the '::'.
5292 ///
5293 /// \param SS The nested-name-specifier, which will be updated in-place
5294 /// to reflect the parsed nested-name-specifier.
5295 ///
5296 /// \returns true if an error occurred, false otherwise.
5297 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
5298
5299 /// \brief The parser has parsed a '__super' nested-name-specifier.
5300 ///
5301 /// \param SuperLoc The location of the '__super' keyword.
5302 ///
5303 /// \param ColonColonLoc The location of the '::'.
5304 ///
5305 /// \param SS The nested-name-specifier, which will be updated in-place
5306 /// to reflect the parsed nested-name-specifier.
5307 ///
5308 /// \returns true if an error occurred, false otherwise.
5309 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
5310 SourceLocation ColonColonLoc, CXXScopeSpec &SS);
5311
5312 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
5313 bool *CanCorrect = nullptr);
5314 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
5315
5316 /// \brief Keeps information about an identifier in a nested-name-spec.
5317 ///
5318 struct NestedNameSpecInfo {
5319 /// \brief The type of the object, if we're parsing nested-name-specifier in
5320 /// a member access expression.
5321 ParsedType ObjectType;
5322
5323 /// \brief The identifier preceding the '::'.
5324 IdentifierInfo *Identifier;
5325
5326 /// \brief The location of the identifier.
5327 SourceLocation IdentifierLoc;
5328
5329 /// \brief The location of the '::'.
5330 SourceLocation CCLoc;
5331
5332 /// \brief Creates info object for the most typical case.
5333 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
5334 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())
5335 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),
5336 CCLoc(ColonColonLoc) {
5337 }
5338
5339 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
5340 SourceLocation ColonColonLoc, QualType ObjectType)
5341 : ObjectType(ParsedType::make(ObjectType)), Identifier(II),
5342 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {
5343 }
5344 };
5345
5346 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
5347 NestedNameSpecInfo &IdInfo);
5348
5349 bool BuildCXXNestedNameSpecifier(Scope *S,
5350 NestedNameSpecInfo &IdInfo,
5351 bool EnteringContext,
5352 CXXScopeSpec &SS,
5353 NamedDecl *ScopeLookupResult,
5354 bool ErrorRecoveryLookup,
5355 bool *IsCorrectedToColon = nullptr,
5356 bool OnlyNamespace = false);
5357
5358 /// \brief The parser has parsed a nested-name-specifier 'identifier::'.
5359 ///
5360 /// \param S The scope in which this nested-name-specifier occurs.
5361 ///
5362 /// \param IdInfo Parser information about an identifier in the
5363 /// nested-name-spec.
5364 ///
5365 /// \param EnteringContext Whether we're entering the context nominated by
5366 /// this nested-name-specifier.
5367 ///
5368 /// \param SS The nested-name-specifier, which is both an input
5369 /// parameter (the nested-name-specifier before this type) and an
5370 /// output parameter (containing the full nested-name-specifier,
5371 /// including this new type).
5372 ///
5373 /// \param ErrorRecoveryLookup If true, then this method is called to improve
5374 /// error recovery. In this case do not emit error message.
5375 ///
5376 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
5377 /// are allowed. The bool value pointed by this parameter is set to 'true'
5378 /// if the identifier is treated as if it was followed by ':', not '::'.
5379 ///
5380 /// \param OnlyNamespace If true, only considers namespaces in lookup.
5381 ///
5382 /// \returns true if an error occurred, false otherwise.
5383 bool ActOnCXXNestedNameSpecifier(Scope *S,
5384 NestedNameSpecInfo &IdInfo,
5385 bool EnteringContext,
5386 CXXScopeSpec &SS,
5387 bool ErrorRecoveryLookup = false,
5388 bool *IsCorrectedToColon = nullptr,
5389 bool OnlyNamespace = false);
5390
5391 ExprResult ActOnDecltypeExpression(Expr *E);
5392
5393 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
5394 const DeclSpec &DS,
5395 SourceLocation ColonColonLoc);
5396
5397 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
5398 NestedNameSpecInfo &IdInfo,
5399 bool EnteringContext);
5400
5401 /// \brief The parser has parsed a nested-name-specifier
5402 /// 'template[opt] template-name < template-args >::'.
5403 ///
5404 /// \param S The scope in which this nested-name-specifier occurs.
5405 ///
5406 /// \param SS The nested-name-specifier, which is both an input
5407 /// parameter (the nested-name-specifier before this type) and an
5408 /// output parameter (containing the full nested-name-specifier,
5409 /// including this new type).
5410 ///
5411 /// \param TemplateKWLoc the location of the 'template' keyword, if any.
5412 /// \param TemplateName the template name.
5413 /// \param TemplateNameLoc The location of the template name.
5414 /// \param LAngleLoc The location of the opening angle bracket ('<').
5415 /// \param TemplateArgs The template arguments.
5416 /// \param RAngleLoc The location of the closing angle bracket ('>').
5417 /// \param CCLoc The location of the '::'.
5418 ///
5419 /// \param EnteringContext Whether we're entering the context of the
5420 /// nested-name-specifier.
5421 ///
5422 ///
5423 /// \returns true if an error occurred, false otherwise.
5424 bool ActOnCXXNestedNameSpecifier(Scope *S,
5425 CXXScopeSpec &SS,
5426 SourceLocation TemplateKWLoc,
5427 TemplateTy TemplateName,
5428 SourceLocation TemplateNameLoc,
5429 SourceLocation LAngleLoc,
5430 ASTTemplateArgsPtr TemplateArgs,
5431 SourceLocation RAngleLoc,
5432 SourceLocation CCLoc,
5433 bool EnteringContext);
5434
5435 /// \brief Given a C++ nested-name-specifier, produce an annotation value
5436 /// that the parser can use later to reconstruct the given
5437 /// nested-name-specifier.
5438 ///
5439 /// \param SS A nested-name-specifier.
5440 ///
5441 /// \returns A pointer containing all of the information in the
5442 /// nested-name-specifier \p SS.
5443 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
5444
5445 /// \brief Given an annotation pointer for a nested-name-specifier, restore
5446 /// the nested-name-specifier structure.
5447 ///
5448 /// \param Annotation The annotation pointer, produced by
5449 /// \c SaveNestedNameSpecifierAnnotation().
5450 ///
5451 /// \param AnnotationRange The source range corresponding to the annotation.
5452 ///
5453 /// \param SS The nested-name-specifier that will be updated with the contents
5454 /// of the annotation pointer.
5455 void RestoreNestedNameSpecifierAnnotation(void *Annotation,
5456 SourceRange AnnotationRange,
5457 CXXScopeSpec &SS);
5458
5459 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
5460
5461 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
5462 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
5463 /// After this method is called, according to [C++ 3.4.3p3], names should be
5464 /// looked up in the declarator-id's scope, until the declarator is parsed and
5465 /// ActOnCXXExitDeclaratorScope is called.
5466 /// The 'SS' should be a non-empty valid CXXScopeSpec.
5467 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
5468
5469 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
5470 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
5471 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
5472 /// Used to indicate that names should revert to being looked up in the
5473 /// defining scope.
5474 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
5475
5476 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
5477 /// initializer for the declaration 'Dcl'.
5478 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5479 /// static data member of class X, names should be looked up in the scope of
5480 /// class X.
5481 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);
5482
5483 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
5484 /// initializer for the declaration 'Dcl'.
5485 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
5486
5487 /// \brief Create a new lambda closure type.
5488 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
5489 TypeSourceInfo *Info,
5490 bool KnownDependent,
5491 LambdaCaptureDefault CaptureDefault);
5492
5493 /// \brief Start the definition of a lambda expression.
5494 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
5495 SourceRange IntroducerRange,
5496 TypeSourceInfo *MethodType,
5497 SourceLocation EndLoc,
5498 ArrayRef<ParmVarDecl *> Params,
5499 bool IsConstexprSpecified);
5500
5501 /// \brief Endow the lambda scope info with the relevant properties.
5502 void buildLambdaScope(sema::LambdaScopeInfo *LSI,
5503 CXXMethodDecl *CallOperator,
5504 SourceRange IntroducerRange,
5505 LambdaCaptureDefault CaptureDefault,
5506 SourceLocation CaptureDefaultLoc,
5507 bool ExplicitParams,
5508 bool ExplicitResultType,
5509 bool Mutable);
5510
5511 /// \brief Perform initialization analysis of the init-capture and perform
5512 /// any implicit conversions such as an lvalue-to-rvalue conversion if
5513 /// not being used to initialize a reference.
5514 ParsedType actOnLambdaInitCaptureInitialization(
5515 SourceLocation Loc, bool ByRef, IdentifierInfo *Id,
5516 LambdaCaptureInitKind InitKind, Expr *&Init) {
5517 return ParsedType::make(buildLambdaInitCaptureInitialization(
5518 Loc, ByRef, Id, InitKind != LambdaCaptureInitKind::CopyInit, Init));
5519 }
5520 QualType buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef,
5521 IdentifierInfo *Id,
5522 bool DirectInit, Expr *&Init);
5523
5524 /// \brief Create a dummy variable within the declcontext of the lambda's
5525 /// call operator, for name lookup purposes for a lambda init capture.
5526 ///
5527 /// CodeGen handles emission of lambda captures, ignoring these dummy
5528 /// variables appropriately.
5529 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
5530 QualType InitCaptureType,
5531 IdentifierInfo *Id,
5532 unsigned InitStyle, Expr *Init);
5533
5534 /// \brief Build the implicit field for an init-capture.
5535 FieldDecl *buildInitCaptureField(sema::LambdaScopeInfo *LSI, VarDecl *Var);
5536
5537 /// \brief Note that we have finished the explicit captures for the
5538 /// given lambda.
5539 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
5540
5541 /// \brief Introduce the lambda parameters into scope.
5542 void addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope);
5543
5544 /// \brief Deduce a block or lambda's return type based on the return
5545 /// statements present in the body.
5546 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
5547
5548 /// ActOnStartOfLambdaDefinition - This is called just before we start
5549 /// parsing the body of a lambda; it analyzes the explicit captures and
5550 /// arguments, and sets up various data-structures for the body of the
5551 /// lambda.
5552 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
5553 Declarator &ParamInfo, Scope *CurScope);
5554
5555 /// ActOnLambdaError - If there is an error parsing a lambda, this callback
5556 /// is invoked to pop the information about the lambda.
5557 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
5558 bool IsInstantiation = false);
5559
5560 /// ActOnLambdaExpr - This is called when the body of a lambda expression
5561 /// was successfully completed.
5562 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
5563 Scope *CurScope);
5564
5565 /// \brief Does copying/destroying the captured variable have side effects?
5566 bool CaptureHasSideEffects(const sema::Capture &From);
5567
5568 /// \brief Diagnose if an explicit lambda capture is unused.
5569 void DiagnoseUnusedLambdaCapture(const sema::Capture &From);
5570
5571 /// \brief Complete a lambda-expression having processed and attached the
5572 /// lambda body.
5573 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
5574 sema::LambdaScopeInfo *LSI);
5575
5576 /// Get the return type to use for a lambda's conversion function(s) to
5577 /// function pointer type, given the type of the call operator.
5578 QualType
5579 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType);
5580
5581 /// \brief Define the "body" of the conversion from a lambda object to a
5582 /// function pointer.
5583 ///
5584 /// This routine doesn't actually define a sensible body; rather, it fills
5585 /// in the initialization expression needed to copy the lambda object into
5586 /// the block, and IR generation actually generates the real body of the
5587 /// block pointer conversion.
5588 void DefineImplicitLambdaToFunctionPointerConversion(
5589 SourceLocation CurrentLoc, CXXConversionDecl *Conv);
5590
5591 /// \brief Define the "body" of the conversion from a lambda object to a
5592 /// block pointer.
5593 ///
5594 /// This routine doesn't actually define a sensible body; rather, it fills
5595 /// in the initialization expression needed to copy the lambda object into
5596 /// the block, and IR generation actually generates the real body of the
5597 /// block pointer conversion.
5598 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
5599 CXXConversionDecl *Conv);
5600
5601 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
5602 SourceLocation ConvLocation,
5603 CXXConversionDecl *Conv,
5604 Expr *Src);
5605
5606 // ParseObjCStringLiteral - Parse Objective-C string literals.
5607 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
5608 ArrayRef<Expr *> Strings);
5609
5610 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
5611
5612 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
5613 /// numeric literal expression. Type of the expression will be "NSNumber *"
5614 /// or "id" if NSNumber is unavailable.
5615 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
5616 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
5617 bool Value);
5618 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
5619
5620 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
5621 /// '@' prefixed parenthesized expression. The type of the expression will
5622 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type
5623 /// of ValueType, which is allowed to be a built-in numeric type, "char *",
5624 /// "const char *" or C structure with attribute 'objc_boxable'.
5625 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
5626
5627 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
5628 Expr *IndexExpr,
5629 ObjCMethodDecl *getterMethod,
5630 ObjCMethodDecl *setterMethod);
5631
5632 ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
5633 MutableArrayRef<ObjCDictionaryElement> Elements);
5634
5635 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
5636 TypeSourceInfo *EncodedTypeInfo,
5637 SourceLocation RParenLoc);
5638 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
5639 CXXConversionDecl *Method,
5640 bool HadMultipleCandidates);
5641
5642 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
5643 SourceLocation EncodeLoc,
5644 SourceLocation LParenLoc,
5645 ParsedType Ty,
5646 SourceLocation RParenLoc);
5647
5648 /// ParseObjCSelectorExpression - Build selector expression for \@selector
5649 ExprResult ParseObjCSelectorExpression(Selector Sel,
5650 SourceLocation AtLoc,
5651 SourceLocation SelLoc,
5652 SourceLocation LParenLoc,
5653 SourceLocation RParenLoc,
5654 bool WarnMultipleSelectors);
5655
5656 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol
5657 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
5658 SourceLocation AtLoc,
5659 SourceLocation ProtoLoc,
5660 SourceLocation LParenLoc,
5661 SourceLocation ProtoIdLoc,
5662 SourceLocation RParenLoc);
5663
5664 //===--------------------------------------------------------------------===//
5665 // C++ Declarations
5666 //
5667 Decl *ActOnStartLinkageSpecification(Scope *S,
5668 SourceLocation ExternLoc,
5669 Expr *LangStr,
5670 SourceLocation LBraceLoc);
5671 Decl *ActOnFinishLinkageSpecification(Scope *S,
5672 Decl *LinkageSpec,
5673 SourceLocation RBraceLoc);
5674
5675
5676 //===--------------------------------------------------------------------===//
5677 // C++ Classes
5678 //
5679 bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
5680 const CXXScopeSpec *SS = nullptr);
5681 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);
5682
5683 bool ActOnAccessSpecifier(AccessSpecifier Access,
5684 SourceLocation ASLoc,
5685 SourceLocation ColonLoc,
5686 AttributeList *Attrs = nullptr);
5687
5688 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
5689 Declarator &D,
5690 MultiTemplateParamsArg TemplateParameterLists,
5691 Expr *BitfieldWidth, const VirtSpecifiers &VS,
5692 InClassInitStyle InitStyle);
5693
5694 void ActOnStartCXXInClassMemberInitializer();
5695 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
5696 SourceLocation EqualLoc,
5697 Expr *Init);
5698
5699 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
5700 Scope *S,
5701 CXXScopeSpec &SS,
5702 IdentifierInfo *MemberOrBase,
5703 ParsedType TemplateTypeTy,
5704 const DeclSpec &DS,
5705 SourceLocation IdLoc,
5706 SourceLocation LParenLoc,
5707 ArrayRef<Expr *> Args,
5708 SourceLocation RParenLoc,
5709 SourceLocation EllipsisLoc);
5710
5711 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
5712 Scope *S,
5713 CXXScopeSpec &SS,
5714 IdentifierInfo *MemberOrBase,
5715 ParsedType TemplateTypeTy,
5716 const DeclSpec &DS,
5717 SourceLocation IdLoc,
5718 Expr *InitList,
5719 SourceLocation EllipsisLoc);
5720
5721 MemInitResult BuildMemInitializer(Decl *ConstructorD,
5722 Scope *S,
5723 CXXScopeSpec &SS,
5724 IdentifierInfo *MemberOrBase,
5725 ParsedType TemplateTypeTy,
5726 const DeclSpec &DS,
5727 SourceLocation IdLoc,
5728 Expr *Init,
5729 SourceLocation EllipsisLoc);
5730
5731 MemInitResult BuildMemberInitializer(ValueDecl *Member,
5732 Expr *Init,
5733 SourceLocation IdLoc);
5734
5735 MemInitResult BuildBaseInitializer(QualType BaseType,
5736 TypeSourceInfo *BaseTInfo,
5737 Expr *Init,
5738 CXXRecordDecl *ClassDecl,
5739 SourceLocation EllipsisLoc);
5740
5741 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
5742 Expr *Init,
5743 CXXRecordDecl *ClassDecl);
5744
5745 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
5746 CXXCtorInitializer *Initializer);
5747
5748 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
5749 ArrayRef<CXXCtorInitializer *> Initializers = None);
5750
5751 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
5752
5753
5754 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
5755 /// mark all the non-trivial destructors of its members and bases as
5756 /// referenced.
5757 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
5758 CXXRecordDecl *Record);
5759
5760 /// \brief The list of classes whose vtables have been used within
5761 /// this translation unit, and the source locations at which the
5762 /// first use occurred.
5763 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
5764
5765 /// \brief The list of vtables that are required but have not yet been
5766 /// materialized.
5767 SmallVector<VTableUse, 16> VTableUses;
5768
5769 /// \brief The set of classes whose vtables have been used within
5770 /// this translation unit, and a bit that will be true if the vtable is
5771 /// required to be emitted (otherwise, it should be emitted only if needed
5772 /// by code generation).
5773 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
5774
5775 /// \brief Load any externally-stored vtable uses.
5776 void LoadExternalVTableUses();
5777
5778 /// \brief Note that the vtable for the given class was used at the
5779 /// given location.
5780 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
5781 bool DefinitionRequired = false);
5782
5783 /// \brief Mark the exception specifications of all virtual member functions
5784 /// in the given class as needed.
5785 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
5786 const CXXRecordDecl *RD);
5787
5788 /// MarkVirtualMembersReferenced - Will mark all members of the given
5789 /// CXXRecordDecl referenced.
5790 void MarkVirtualMembersReferenced(SourceLocation Loc,
5791 const CXXRecordDecl *RD);
5792
5793 /// \brief Define all of the vtables that have been used in this
5794 /// translation unit and reference any virtual members used by those
5795 /// vtables.
5796 ///
5797 /// \returns true if any work was done, false otherwise.
5798 bool DefineUsedVTables();
5799
5800 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
5801
5802 void ActOnMemInitializers(Decl *ConstructorDecl,
5803 SourceLocation ColonLoc,
5804 ArrayRef<CXXCtorInitializer*> MemInits,
5805 bool AnyErrors);
5806
5807 /// \brief Check class-level dllimport/dllexport attribute. The caller must
5808 /// ensure that referenceDLLExportedClassMethods is called some point later
5809 /// when all outer classes of Class are complete.
5810 void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
5811
5812 void referenceDLLExportedClassMethods();
5813
5814 void propagateDLLAttrToBaseClassTemplate(
5815 CXXRecordDecl *Class, Attr *ClassAttr,
5816 ClassTemplateSpecializationDecl *BaseTemplateSpec,
5817 SourceLocation BaseLoc);
5818
5819 void CheckCompletedCXXClass(CXXRecordDecl *Record);
5820
5821 /// Check that the C++ class annoated with "trivial_abi" satisfies all the
5822 /// conditions that are needed for the attribute to have an effect.
5823 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);
5824
5825 void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
5826 Decl *TagDecl,
5827 SourceLocation LBrac,
5828 SourceLocation RBrac,
5829 AttributeList *AttrList);
5830 void ActOnFinishCXXMemberDecls();
5831 void ActOnFinishCXXNonNestedClass(Decl *D);
5832
5833 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);
5834 unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template);
5835 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);
5836 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
5837 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);
5838 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);
5839 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
5840 void ActOnFinishDelayedMemberInitializers(Decl *Record);
5841 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
5842 CachedTokens &Toks);
5843 void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
5844 bool IsInsideALocalClassWithinATemplateFunction();
5845
5846 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
5847 Expr *AssertExpr,
5848 Expr *AssertMessageExpr,
5849 SourceLocation RParenLoc);
5850 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
5851 Expr *AssertExpr,
5852 StringLiteral *AssertMessageExpr,
5853 SourceLocation RParenLoc,
5854 bool Failed);
5855
5856 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
5857 SourceLocation FriendLoc,
5858 TypeSourceInfo *TSInfo);
5859 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
5860 MultiTemplateParamsArg TemplateParams);
5861 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,
5862 MultiTemplateParamsArg TemplateParams);
5863
5864 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
5865 StorageClass& SC);
5866 void CheckConstructor(CXXConstructorDecl *Constructor);
5867 QualType CheckDestructorDeclarator(Declarator &D, QualType R,
5868 StorageClass& SC);
5869 bool CheckDestructor(CXXDestructorDecl *Destructor);
5870 void CheckConversionDeclarator(Declarator &D, QualType &R,
5871 StorageClass& SC);
5872 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
5873 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
5874 StorageClass &SC);
5875 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
5876
5877 void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD);
5878 void CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl *MD,
5879 const FunctionProtoType *T);
5880 void CheckDelayedMemberExceptionSpecs();
5881
5882 //===--------------------------------------------------------------------===//
5883 // C++ Derived Classes
5884 //
5885
5886 /// ActOnBaseSpecifier - Parsed a base specifier
5887 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
5888 SourceRange SpecifierRange,
5889 bool Virtual, AccessSpecifier Access,
5890 TypeSourceInfo *TInfo,
5891 SourceLocation EllipsisLoc);
5892
5893 BaseResult ActOnBaseSpecifier(Decl *classdecl,
5894 SourceRange SpecifierRange,
5895 ParsedAttributes &Attrs,
5896 bool Virtual, AccessSpecifier Access,
5897 ParsedType basetype,
5898 SourceLocation BaseLoc,
5899 SourceLocation EllipsisLoc);
5900
5901 bool AttachBaseSpecifiers(CXXRecordDecl *Class,
5902 MutableArrayRef<CXXBaseSpecifier *> Bases);
5903 void ActOnBaseSpecifiers(Decl *ClassDecl,
5904 MutableArrayRef<CXXBaseSpecifier *> Bases);
5905
5906 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
5907 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
5908 CXXBasePaths &Paths);
5909
5910 // FIXME: I don't like this name.
5911 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
5912
5913 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
5914 SourceLocation Loc, SourceRange Range,
5915 CXXCastPath *BasePath = nullptr,
5916 bool IgnoreAccess = false);
5917 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
5918 unsigned InaccessibleBaseID,
5919 unsigned AmbigiousBaseConvID,
5920 SourceLocation Loc, SourceRange Range,
5921 DeclarationName Name,
5922 CXXCastPath *BasePath,
5923 bool IgnoreAccess = false);
5924
5925 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
5926
5927 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5928 const CXXMethodDecl *Old);
5929
5930 /// CheckOverridingFunctionReturnType - Checks whether the return types are
5931 /// covariant, according to C++ [class.virtual]p5.
5932 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
5933 const CXXMethodDecl *Old);
5934
5935 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
5936 /// spec is a subset of base spec.
5937 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
5938 const CXXMethodDecl *Old);
5939
5940 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
5941
5942 /// CheckOverrideControl - Check C++11 override control semantics.
5943 void CheckOverrideControl(NamedDecl *D);
5944
5945 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
5946 /// not used in the declaration of an overriding method.
5947 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D);
5948
5949 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function
5950 /// overrides a virtual member function marked 'final', according to
5951 /// C++11 [class.virtual]p4.
5952 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
5953 const CXXMethodDecl *Old);
5954
5955
5956 //===--------------------------------------------------------------------===//
5957 // C++ Access Control
5958 //
5959
5960 enum AccessResult {
5961 AR_accessible,
5962 AR_inaccessible,
5963 AR_dependent,
5964 AR_delayed
5965 };
5966
5967 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
5968 NamedDecl *PrevMemberDecl,
5969 AccessSpecifier LexicalAS);
5970
5971 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
5972 DeclAccessPair FoundDecl);
5973 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
5974 DeclAccessPair FoundDecl);
5975 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
5976 SourceRange PlacementRange,
5977 CXXRecordDecl *NamingClass,
5978 DeclAccessPair FoundDecl,
5979 bool Diagnose = true);
5980 AccessResult CheckConstructorAccess(SourceLocation Loc,
5981 CXXConstructorDecl *D,
5982 DeclAccessPair FoundDecl,
5983 const InitializedEntity &Entity,
5984 bool IsCopyBindingRefToTemp = false);
5985 AccessResult CheckConstructorAccess(SourceLocation Loc,
5986 CXXConstructorDecl *D,
5987 DeclAccessPair FoundDecl,
5988 const InitializedEntity &Entity,
5989 const PartialDiagnostic &PDiag);
5990 AccessResult CheckDestructorAccess(SourceLocation Loc,
5991 CXXDestructorDecl *Dtor,
5992 const PartialDiagnostic &PDiag,
5993 QualType objectType = QualType());
5994 AccessResult CheckFriendAccess(NamedDecl *D);
5995 AccessResult CheckMemberAccess(SourceLocation UseLoc,
5996 CXXRecordDecl *NamingClass,
5997 DeclAccessPair Found);
5998 AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
5999 Expr *ObjectExpr,
6000 Expr *ArgExpr,
6001 DeclAccessPair FoundDecl);
6002 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
6003 DeclAccessPair FoundDecl);
6004 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
6005 QualType Base, QualType Derived,
6006 const CXXBasePath &Path,
6007 unsigned DiagID,
6008 bool ForceCheck = false,
6009 bool ForceUnprivileged = false);
6010 void CheckLookupAccess(const LookupResult &R);
6011 bool IsSimplyAccessible(NamedDecl *decl, DeclContext *Ctx);
6012 bool isSpecialMemberAccessibleForDeletion(CXXMethodDecl *decl,
6013 AccessSpecifier access,
6014 QualType objectType);
6015
6016 void HandleDependentAccessCheck(const DependentDiagnostic &DD,
6017 const MultiLevelTemplateArgumentList &TemplateArgs);
6018 void PerformDependentDiagnostics(const DeclContext *Pattern,
6019 const MultiLevelTemplateArgumentList &TemplateArgs);
6020
6021 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
6022
6023 /// \brief When true, access checking violations are treated as SFINAE
6024 /// failures rather than hard errors.
6025 bool AccessCheckingSFINAE;
6026
6027 enum AbstractDiagSelID {
6028 AbstractNone = -1,
6029 AbstractReturnType,
6030 AbstractParamType,
6031 AbstractVariableType,
6032 AbstractFieldType,
6033 AbstractIvarType,
6034 AbstractSynthesizedIvarType,
6035 AbstractArrayType
6036 };
6037
6038 bool isAbstractType(SourceLocation Loc, QualType T);
6039 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
6040 TypeDiagnoser &Diagnoser);
6041 template <typename... Ts>
6042 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
6043 const Ts &...Args) {
6044 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
6045 return RequireNonAbstractType(Loc, T, Diagnoser);
6046 }
6047
6048 void DiagnoseAbstractType(const CXXRecordDecl *RD);
6049
6050 //===--------------------------------------------------------------------===//
6051 // C++ Overloaded Operators [C++ 13.5]
6052 //
6053
6054 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
6055
6056 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
6057
6058 //===--------------------------------------------------------------------===//
6059 // C++ Templates [C++ 14]
6060 //
6061 void FilterAcceptableTemplateNames(LookupResult &R,
6062 bool AllowFunctionTemplates = true);
6063 bool hasAnyAcceptableTemplateNames(LookupResult &R,
6064 bool AllowFunctionTemplates = true);
6065
6066 void LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS,
6067 QualType ObjectType, bool EnteringContext,
6068 bool &MemberOfUnknownSpecialization);
6069
6070 TemplateNameKind isTemplateName(Scope *S,
6071 CXXScopeSpec &SS,
6072 bool hasTemplateKeyword,
6073 UnqualifiedId &Name,
6074 ParsedType ObjectType,
6075 bool EnteringContext,
6076 TemplateTy &Template,
6077 bool &MemberOfUnknownSpecialization);
6078
6079 /// Determine whether a particular identifier might be the name in a C++1z
6080 /// deduction-guide declaration.
6081 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
6082 SourceLocation NameLoc,
6083 ParsedTemplateTy *Template = nullptr);
6084
6085 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
6086 SourceLocation IILoc,
6087 Scope *S,
6088 const CXXScopeSpec *SS,
6089 TemplateTy &SuggestedTemplate,
6090 TemplateNameKind &SuggestedKind);
6091
6092 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
6093 NamedDecl *Instantiation,
6094 bool InstantiatedFromMember,
6095 const NamedDecl *Pattern,
6096 const NamedDecl *PatternDef,
6097 TemplateSpecializationKind TSK,
6098 bool Complain = true);
6099
6100 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
6101 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);
6102
6103 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
6104 SourceLocation EllipsisLoc,
6105 SourceLocation KeyLoc,
6106 IdentifierInfo *ParamName,
6107 SourceLocation ParamNameLoc,
6108 unsigned Depth, unsigned Position,
6109 SourceLocation EqualLoc,
6110 ParsedType DefaultArg);
6111
6112 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
6113 SourceLocation Loc);
6114 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
6115
6116 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
6117 unsigned Depth,
6118 unsigned Position,
6119 SourceLocation EqualLoc,
6120 Expr *DefaultArg);
6121 NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
6122 SourceLocation TmpLoc,
6123 TemplateParameterList *Params,
6124 SourceLocation EllipsisLoc,
6125 IdentifierInfo *ParamName,
6126 SourceLocation ParamNameLoc,
6127 unsigned Depth,
6128 unsigned Position,
6129 SourceLocation EqualLoc,
6130 ParsedTemplateArgument DefaultArg);
6131
6132 TemplateParameterList *
6133 ActOnTemplateParameterList(unsigned Depth,
6134 SourceLocation ExportLoc,
6135 SourceLocation TemplateLoc,
6136 SourceLocation LAngleLoc,
6137 ArrayRef<NamedDecl *> Params,
6138 SourceLocation RAngleLoc,
6139 Expr *RequiresClause);
6140
6141 /// \brief The context in which we are checking a template parameter list.
6142 enum TemplateParamListContext {
6143 TPC_ClassTemplate,
6144 TPC_VarTemplate,
6145 TPC_FunctionTemplate,
6146 TPC_ClassTemplateMember,
6147 TPC_FriendClassTemplate,
6148 TPC_FriendFunctionTemplate,
6149 TPC_FriendFunctionTemplateDefinition,
6150 TPC_TypeAliasTemplate
6151 };
6152
6153 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
6154 TemplateParameterList *OldParams,
6155 TemplateParamListContext TPC);
6156 TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
6157 SourceLocation DeclStartLoc, SourceLocation DeclLoc,
6158 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
6159 ArrayRef<TemplateParameterList *> ParamLists,
6160 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid);
6161
6162 DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
6163 SourceLocation KWLoc, CXXScopeSpec &SS,
6164 IdentifierInfo *Name, SourceLocation NameLoc,
6165 AttributeList *Attr,
6166 TemplateParameterList *TemplateParams,
6167 AccessSpecifier AS,
6168 SourceLocation ModulePrivateLoc,
6169 SourceLocation FriendLoc,
6170 unsigned NumOuterTemplateParamLists,
6171 TemplateParameterList **OuterTemplateParamLists,
6172 SkipBodyInfo *SkipBody = nullptr);
6173
6174 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
6175 QualType NTTPType,
6176 SourceLocation Loc);
6177
6178 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
6179 TemplateArgumentListInfo &Out);
6180
6181 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
6182
6183 void NoteAllFoundTemplates(TemplateName Name);
6184
6185 QualType CheckTemplateIdType(TemplateName Template,
6186 SourceLocation TemplateLoc,
6187 TemplateArgumentListInfo &TemplateArgs);
6188
6189 TypeResult
6190 ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
6191 TemplateTy Template, IdentifierInfo *TemplateII,
6192 SourceLocation TemplateIILoc,
6193 SourceLocation LAngleLoc,
6194 ASTTemplateArgsPtr TemplateArgs,
6195 SourceLocation RAngleLoc,
6196 bool IsCtorOrDtorName = false,
6197 bool IsClassName = false);
6198
6199 /// \brief Parsed an elaborated-type-specifier that refers to a template-id,
6200 /// such as \c class T::template apply<U>.
6201 TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
6202 TypeSpecifierType TagSpec,
6203 SourceLocation TagLoc,
6204 CXXScopeSpec &SS,
6205 SourceLocation TemplateKWLoc,
6206 TemplateTy TemplateD,
6207 SourceLocation TemplateLoc,
6208 SourceLocation LAngleLoc,
6209 ASTTemplateArgsPtr TemplateArgsIn,
6210 SourceLocation RAngleLoc);
6211
6212 DeclResult ActOnVarTemplateSpecialization(
6213 Scope *S, Declarator &D, TypeSourceInfo *DI,
6214 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
6215 StorageClass SC, bool IsPartialSpecialization);
6216
6217 DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
6218 SourceLocation TemplateLoc,
6219 SourceLocation TemplateNameLoc,
6220 const TemplateArgumentListInfo &TemplateArgs);
6221
6222 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
6223 const DeclarationNameInfo &NameInfo,
6224 VarTemplateDecl *Template,
6225 SourceLocation TemplateLoc,
6226 const TemplateArgumentListInfo *TemplateArgs);
6227
6228 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
6229 SourceLocation TemplateKWLoc,
6230 LookupResult &R,
6231 bool RequiresADL,
6232 const TemplateArgumentListInfo *TemplateArgs);
6233
6234 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
6235 SourceLocation TemplateKWLoc,
6236 const DeclarationNameInfo &NameInfo,
6237 const TemplateArgumentListInfo *TemplateArgs);
6238
6239 TemplateNameKind ActOnDependentTemplateName(
6240 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
6241 UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
6242 TemplateTy &Template, bool AllowInjectedClassName = false);
6243
6244 DeclResult
6245 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
6246 SourceLocation KWLoc,
6247 SourceLocation ModulePrivateLoc,
6248 TemplateIdAnnotation &TemplateId,
6249 AttributeList *Attr,
6250 MultiTemplateParamsArg TemplateParameterLists,
6251 SkipBodyInfo *SkipBody = nullptr);
6252
6253 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
6254 TemplateDecl *PrimaryTemplate,
6255 unsigned NumExplicitArgs,
6256 ArrayRef<TemplateArgument> Args);
6257 void CheckTemplatePartialSpecialization(
6258 ClassTemplatePartialSpecializationDecl *Partial);
6259 void CheckTemplatePartialSpecialization(
6260 VarTemplatePartialSpecializationDecl *Partial);
6261
6262 Decl *ActOnTemplateDeclarator(Scope *S,
6263 MultiTemplateParamsArg TemplateParameterLists,
6264 Declarator &D);
6265
6266 bool
6267 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
6268 TemplateSpecializationKind NewTSK,
6269 NamedDecl *PrevDecl,
6270 TemplateSpecializationKind PrevTSK,
6271 SourceLocation PrevPtOfInstantiation,
6272 bool &SuppressNew);
6273
6274 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
6275 const TemplateArgumentListInfo &ExplicitTemplateArgs,
6276 LookupResult &Previous);
6277
6278 bool CheckFunctionTemplateSpecialization(FunctionDecl *FD,
6279 TemplateArgumentListInfo *ExplicitTemplateArgs,
6280 LookupResult &Previous);
6281 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
6282 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
6283
6284 DeclResult
6285 ActOnExplicitInstantiation(Scope *S,
6286 SourceLocation ExternLoc,
6287 SourceLocation TemplateLoc,
6288 unsigned TagSpec,
6289 SourceLocation KWLoc,
6290 const CXXScopeSpec &SS,
6291 TemplateTy Template,
6292 SourceLocation TemplateNameLoc,
6293 SourceLocation LAngleLoc,
6294 ASTTemplateArgsPtr TemplateArgs,
6295 SourceLocation RAngleLoc,
6296 AttributeList *Attr);
6297
6298 DeclResult
6299 ActOnExplicitInstantiation(Scope *S,
6300 SourceLocation ExternLoc,
6301 SourceLocation TemplateLoc,
6302 unsigned TagSpec,
6303 SourceLocation KWLoc,
6304 CXXScopeSpec &SS,
6305 IdentifierInfo *Name,
6306 SourceLocation NameLoc,
6307 AttributeList *Attr);
6308
6309 DeclResult ActOnExplicitInstantiation(Scope *S,
6310 SourceLocation ExternLoc,
6311 SourceLocation TemplateLoc,
6312 Declarator &D);
6313
6314 TemplateArgumentLoc
6315 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
6316 SourceLocation TemplateLoc,
6317 SourceLocation RAngleLoc,
6318 Decl *Param,
6319 SmallVectorImpl<TemplateArgument>
6320 &Converted,
6321 bool &HasDefaultArg);
6322
6323 /// \brief Specifies the context in which a particular template
6324 /// argument is being checked.
6325 enum CheckTemplateArgumentKind {
6326 /// \brief The template argument was specified in the code or was
6327 /// instantiated with some deduced template arguments.
6328 CTAK_Specified,
6329
6330 /// \brief The template argument was deduced via template argument
6331 /// deduction.
6332 CTAK_Deduced,
6333
6334 /// \brief The template argument was deduced from an array bound
6335 /// via template argument deduction.
6336 CTAK_DeducedFromArrayBound
6337 };
6338
6339 bool CheckTemplateArgument(NamedDecl *Param,
6340 TemplateArgumentLoc &Arg,
6341 NamedDecl *Template,
6342 SourceLocation TemplateLoc,
6343 SourceLocation RAngleLoc,
6344 unsigned ArgumentPackIndex,
6345 SmallVectorImpl<TemplateArgument> &Converted,
6346 CheckTemplateArgumentKind CTAK = CTAK_Specified);
6347
6348 /// \brief Check that the given template arguments can be be provided to
6349 /// the given template, converting the arguments along the way.
6350 ///
6351 /// \param Template The template to which the template arguments are being
6352 /// provided.
6353 ///
6354 /// \param TemplateLoc The location of the template name in the source.
6355 ///
6356 /// \param TemplateArgs The list of template arguments. If the template is
6357 /// a template template parameter, this function may extend the set of
6358 /// template arguments to also include substituted, defaulted template
6359 /// arguments.
6360 ///
6361 /// \param PartialTemplateArgs True if the list of template arguments is
6362 /// intentionally partial, e.g., because we're checking just the initial
6363 /// set of template arguments.
6364 ///
6365 /// \param Converted Will receive the converted, canonicalized template
6366 /// arguments.
6367 ///
6368 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
6369 /// contain the converted forms of the template arguments as written.
6370 /// Otherwise, \p TemplateArgs will not be modified.
6371 ///
6372 /// \returns true if an error occurred, false otherwise.
6373 bool CheckTemplateArgumentList(TemplateDecl *Template,
6374 SourceLocation TemplateLoc,
6375 TemplateArgumentListInfo &TemplateArgs,
6376 bool PartialTemplateArgs,
6377 SmallVectorImpl<TemplateArgument> &Converted,
6378 bool UpdateArgsWithConversions = true);
6379
6380 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
6381 TemplateArgumentLoc &Arg,
6382 SmallVectorImpl<TemplateArgument> &Converted);
6383
6384 bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
6385 TypeSourceInfo *Arg);
6386 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
6387 QualType InstantiatedParamType, Expr *Arg,
6388 TemplateArgument &Converted,
6389 CheckTemplateArgumentKind CTAK = CTAK_Specified);
6390 bool CheckTemplateTemplateArgument(TemplateParameterList *Params,
6391 TemplateArgumentLoc &Arg);
6392
6393 ExprResult
6394 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
6395 QualType ParamType,
6396 SourceLocation Loc);
6397 ExprResult
6398 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
6399 SourceLocation Loc);
6400
6401 /// \brief Enumeration describing how template parameter lists are compared
6402 /// for equality.
6403 enum TemplateParameterListEqualKind {
6404 /// \brief We are matching the template parameter lists of two templates
6405 /// that might be redeclarations.
6406 ///
6407 /// \code
6408 /// template<typename T> struct X;
6409 /// template<typename T> struct X;
6410 /// \endcode
6411 TPL_TemplateMatch,
6412
6413 /// \brief We are matching the template parameter lists of two template
6414 /// template parameters as part of matching the template parameter lists
6415 /// of two templates that might be redeclarations.
6416 ///
6417 /// \code
6418 /// template<template<int I> class TT> struct X;
6419 /// template<template<int Value> class Other> struct X;
6420 /// \endcode
6421 TPL_TemplateTemplateParmMatch,
6422
6423 /// \brief We are matching the template parameter lists of a template
6424 /// template argument against the template parameter lists of a template
6425 /// template parameter.
6426 ///
6427 /// \code
6428 /// template<template<int Value> class Metafun> struct X;
6429 /// template<int Value> struct integer_c;
6430 /// X<integer_c> xic;
6431 /// \endcode
6432 TPL_TemplateTemplateArgumentMatch
6433 };
6434
6435 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
6436 TemplateParameterList *Old,
6437 bool Complain,
6438 TemplateParameterListEqualKind Kind,
6439 SourceLocation TemplateArgLoc
6440 = SourceLocation());
6441
6442 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
6443
6444 /// \brief Called when the parser has parsed a C++ typename
6445 /// specifier, e.g., "typename T::type".
6446 ///
6447 /// \param S The scope in which this typename type occurs.
6448 /// \param TypenameLoc the location of the 'typename' keyword
6449 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
6450 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
6451 /// \param IdLoc the location of the identifier.
6452 TypeResult
6453 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6454 const CXXScopeSpec &SS, const IdentifierInfo &II,
6455 SourceLocation IdLoc);
6456
6457 /// \brief Called when the parser has parsed a C++ typename
6458 /// specifier that ends in a template-id, e.g.,
6459 /// "typename MetaFun::template apply<T1, T2>".
6460 ///
6461 /// \param S The scope in which this typename type occurs.
6462 /// \param TypenameLoc the location of the 'typename' keyword
6463 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
6464 /// \param TemplateLoc the location of the 'template' keyword, if any.
6465 /// \param TemplateName The template name.
6466 /// \param TemplateII The identifier used to name the template.
6467 /// \param TemplateIILoc The location of the template name.
6468 /// \param LAngleLoc The location of the opening angle bracket ('<').
6469 /// \param TemplateArgs The template arguments.
6470 /// \param RAngleLoc The location of the closing angle bracket ('>').
6471 TypeResult
6472 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6473 const CXXScopeSpec &SS,
6474 SourceLocation TemplateLoc,
6475 TemplateTy TemplateName,
6476 IdentifierInfo *TemplateII,
6477 SourceLocation TemplateIILoc,
6478 SourceLocation LAngleLoc,
6479 ASTTemplateArgsPtr TemplateArgs,
6480 SourceLocation RAngleLoc);
6481
6482 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
6483 SourceLocation KeywordLoc,
6484 NestedNameSpecifierLoc QualifierLoc,
6485 const IdentifierInfo &II,
6486 SourceLocation IILoc);
6487
6488 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
6489 SourceLocation Loc,
6490 DeclarationName Name);
6491 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
6492
6493 ExprResult RebuildExprInCurrentInstantiation(Expr *E);
6494 bool RebuildTemplateParamsInCurrentInstantiation(
6495 TemplateParameterList *Params);
6496
6497 std::string
6498 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6499 const TemplateArgumentList &Args);
6500
6501 std::string
6502 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6503 const TemplateArgument *Args,
6504 unsigned NumArgs);
6505
6506 //===--------------------------------------------------------------------===//
6507 // C++ Variadic Templates (C++0x [temp.variadic])
6508 //===--------------------------------------------------------------------===//
6509
6510 /// Determine whether an unexpanded parameter pack might be permitted in this
6511 /// location. Useful for error recovery.
6512 bool isUnexpandedParameterPackPermitted();
6513
6514 /// \brief The context in which an unexpanded parameter pack is
6515 /// being diagnosed.
6516 ///
6517 /// Note that the values of this enumeration line up with the first
6518 /// argument to the \c err_unexpanded_parameter_pack diagnostic.
6519 enum UnexpandedParameterPackContext {
6520 /// \brief An arbitrary expression.
6521 UPPC_Expression = 0,
6522
6523 /// \brief The base type of a class type.
6524 UPPC_BaseType,
6525
6526 /// \brief The type of an arbitrary declaration.
6527 UPPC_DeclarationType,
6528
6529 /// \brief The type of a data member.
6530 UPPC_DataMemberType,
6531
6532 /// \brief The size of a bit-field.
6533 UPPC_BitFieldWidth,
6534
6535 /// \brief The expression in a static assertion.
6536 UPPC_StaticAssertExpression,
6537
6538 /// \brief The fixed underlying type of an enumeration.
6539 UPPC_FixedUnderlyingType,
6540
6541 /// \brief The enumerator value.
6542 UPPC_EnumeratorValue,
6543
6544 /// \brief A using declaration.
6545 UPPC_UsingDeclaration,
6546
6547 /// \brief A friend declaration.
6548 UPPC_FriendDeclaration,
6549
6550 /// \brief A declaration qualifier.
6551 UPPC_DeclarationQualifier,
6552
6553 /// \brief An initializer.
6554 UPPC_Initializer,
6555
6556 /// \brief A default argument.
6557 UPPC_DefaultArgument,
6558
6559 /// \brief The type of a non-type template parameter.
6560 UPPC_NonTypeTemplateParameterType,
6561
6562 /// \brief The type of an exception.
6563 UPPC_ExceptionType,
6564
6565 /// \brief Partial specialization.
6566 UPPC_PartialSpecialization,
6567
6568 /// \brief Microsoft __if_exists.
6569 UPPC_IfExists,
6570
6571 /// \brief Microsoft __if_not_exists.
6572 UPPC_IfNotExists,
6573
6574 /// \brief Lambda expression.
6575 UPPC_Lambda,
6576
6577 /// \brief Block expression,
6578 UPPC_Block
6579 };
6580
6581 /// \brief Diagnose unexpanded parameter packs.
6582 ///
6583 /// \param Loc The location at which we should emit the diagnostic.
6584 ///
6585 /// \param UPPC The context in which we are diagnosing unexpanded
6586 /// parameter packs.
6587 ///
6588 /// \param Unexpanded the set of unexpanded parameter packs.
6589 ///
6590 /// \returns true if an error occurred, false otherwise.
6591 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
6592 UnexpandedParameterPackContext UPPC,
6593 ArrayRef<UnexpandedParameterPack> Unexpanded);
6594
6595 /// \brief If the given type contains an unexpanded parameter pack,
6596 /// diagnose the error.
6597 ///
6598 /// \param Loc The source location where a diagnostc should be emitted.
6599 ///
6600 /// \param T The type that is being checked for unexpanded parameter
6601 /// packs.
6602 ///
6603 /// \returns true if an error occurred, false otherwise.
6604 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
6605 UnexpandedParameterPackContext UPPC);
6606
6607 /// \brief If the given expression contains an unexpanded parameter
6608 /// pack, diagnose the error.
6609 ///
6610 /// \param E The expression that is being checked for unexpanded
6611 /// parameter packs.
6612 ///
6613 /// \returns true if an error occurred, false otherwise.
6614 bool DiagnoseUnexpandedParameterPack(Expr *E,
6615 UnexpandedParameterPackContext UPPC = UPPC_Expression);
6616
6617 /// \brief If the given nested-name-specifier contains an unexpanded
6618 /// parameter pack, diagnose the error.
6619 ///
6620 /// \param SS The nested-name-specifier that is being checked for
6621 /// unexpanded parameter packs.
6622 ///
6623 /// \returns true if an error occurred, false otherwise.
6624 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
6625 UnexpandedParameterPackContext UPPC);
6626
6627 /// \brief If the given name contains an unexpanded parameter pack,
6628 /// diagnose the error.
6629 ///
6630 /// \param NameInfo The name (with source location information) that
6631 /// is being checked for unexpanded parameter packs.
6632 ///
6633 /// \returns true if an error occurred, false otherwise.
6634 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
6635 UnexpandedParameterPackContext UPPC);
6636
6637 /// \brief If the given template name contains an unexpanded parameter pack,
6638 /// diagnose the error.
6639 ///
6640 /// \param Loc The location of the template name.
6641 ///
6642 /// \param Template The template name that is being checked for unexpanded
6643 /// parameter packs.
6644 ///
6645 /// \returns true if an error occurred, false otherwise.
6646 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
6647 TemplateName Template,
6648 UnexpandedParameterPackContext UPPC);
6649
6650 /// \brief If the given template argument contains an unexpanded parameter
6651 /// pack, diagnose the error.
6652 ///
6653 /// \param Arg The template argument that is being checked for unexpanded
6654 /// parameter packs.
6655 ///
6656 /// \returns true if an error occurred, false otherwise.
6657 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
6658 UnexpandedParameterPackContext UPPC);
6659
6660 /// \brief Collect the set of unexpanded parameter packs within the given
6661 /// template argument.
6662 ///
6663 /// \param Arg The template argument that will be traversed to find
6664 /// unexpanded parameter packs.
6665 void collectUnexpandedParameterPacks(TemplateArgument Arg,
6666 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6667
6668 /// \brief Collect the set of unexpanded parameter packs within the given
6669 /// template argument.
6670 ///
6671 /// \param Arg The template argument that will be traversed to find
6672 /// unexpanded parameter packs.
6673 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
6674 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6675
6676 /// \brief Collect the set of unexpanded parameter packs within the given
6677 /// type.
6678 ///
6679 /// \param T The type that will be traversed to find
6680 /// unexpanded parameter packs.
6681 void collectUnexpandedParameterPacks(QualType T,
6682 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6683
6684 /// \brief Collect the set of unexpanded parameter packs within the given
6685 /// type.
6686 ///
6687 /// \param TL The type that will be traversed to find
6688 /// unexpanded parameter packs.
6689 void collectUnexpandedParameterPacks(TypeLoc TL,
6690 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6691
6692 /// \brief Collect the set of unexpanded parameter packs within the given
6693 /// nested-name-specifier.
6694 ///
6695 /// \param NNS The nested-name-specifier that will be traversed to find
6696 /// unexpanded parameter packs.
6697 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,
6698 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6699
6700 /// \brief Collect the set of unexpanded parameter packs within the given
6701 /// name.
6702 ///
6703 /// \param NameInfo The name that will be traversed to find
6704 /// unexpanded parameter packs.
6705 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
6706 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
6707
6708 /// \brief Invoked when parsing a template argument followed by an
6709 /// ellipsis, which creates a pack expansion.
6710 ///
6711 /// \param Arg The template argument preceding the ellipsis, which
6712 /// may already be invalid.
6713 ///
6714 /// \param EllipsisLoc The location of the ellipsis.
6715 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
6716 SourceLocation EllipsisLoc);
6717
6718 /// \brief Invoked when parsing a type followed by an ellipsis, which
6719 /// creates a pack expansion.
6720 ///
6721 /// \param Type The type preceding the ellipsis, which will become
6722 /// the pattern of the pack expansion.
6723 ///
6724 /// \param EllipsisLoc The location of the ellipsis.
6725 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
6726
6727 /// \brief Construct a pack expansion type from the pattern of the pack
6728 /// expansion.
6729 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
6730 SourceLocation EllipsisLoc,
6731 Optional<unsigned> NumExpansions);
6732
6733 /// \brief Construct a pack expansion type from the pattern of the pack
6734 /// expansion.
6735 QualType CheckPackExpansion(QualType Pattern,
6736 SourceRange PatternRange,
6737 SourceLocation EllipsisLoc,
6738 Optional<unsigned> NumExpansions);
6739
6740 /// \brief Invoked when parsing an expression followed by an ellipsis, which
6741 /// creates a pack expansion.
6742 ///
6743 /// \param Pattern The expression preceding the ellipsis, which will become
6744 /// the pattern of the pack expansion.
6745 ///
6746 /// \param EllipsisLoc The location of the ellipsis.
6747 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
6748
6749 /// \brief Invoked when parsing an expression followed by an ellipsis, which
6750 /// creates a pack expansion.
6751 ///
6752 /// \param Pattern The expression preceding the ellipsis, which will become
6753 /// the pattern of the pack expansion.
6754 ///
6755 /// \param EllipsisLoc The location of the ellipsis.
6756 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
6757 Optional<unsigned> NumExpansions);
6758
6759 /// \brief Determine whether we could expand a pack expansion with the
6760 /// given set of parameter packs into separate arguments by repeatedly
6761 /// transforming the pattern.
6762 ///
6763 /// \param EllipsisLoc The location of the ellipsis that identifies the
6764 /// pack expansion.
6765 ///
6766 /// \param PatternRange The source range that covers the entire pattern of
6767 /// the pack expansion.
6768 ///
6769 /// \param Unexpanded The set of unexpanded parameter packs within the
6770 /// pattern.
6771 ///
6772 /// \param ShouldExpand Will be set to \c true if the transformer should
6773 /// expand the corresponding pack expansions into separate arguments. When
6774 /// set, \c NumExpansions must also be set.
6775 ///
6776 /// \param RetainExpansion Whether the caller should add an unexpanded
6777 /// pack expansion after all of the expanded arguments. This is used
6778 /// when extending explicitly-specified template argument packs per
6779 /// C++0x [temp.arg.explicit]p9.
6780 ///
6781 /// \param NumExpansions The number of separate arguments that will be in
6782 /// the expanded form of the corresponding pack expansion. This is both an
6783 /// input and an output parameter, which can be set by the caller if the
6784 /// number of expansions is known a priori (e.g., due to a prior substitution)
6785 /// and will be set by the callee when the number of expansions is known.
6786 /// The callee must set this value when \c ShouldExpand is \c true; it may
6787 /// set this value in other cases.
6788 ///
6789 /// \returns true if an error occurred (e.g., because the parameter packs
6790 /// are to be instantiated with arguments of different lengths), false
6791 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
6792 /// must be set.
6793 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
6794 SourceRange PatternRange,
6795 ArrayRef<UnexpandedParameterPack> Unexpanded,
6796 const MultiLevelTemplateArgumentList &TemplateArgs,
6797 bool &ShouldExpand,
6798 bool &RetainExpansion,
6799 Optional<unsigned> &NumExpansions);
6800
6801 /// \brief Determine the number of arguments in the given pack expansion
6802 /// type.
6803 ///
6804 /// This routine assumes that the number of arguments in the expansion is
6805 /// consistent across all of the unexpanded parameter packs in its pattern.
6806 ///
6807 /// Returns an empty Optional if the type can't be expanded.
6808 Optional<unsigned> getNumArgumentsInExpansion(QualType T,
6809 const MultiLevelTemplateArgumentList &TemplateArgs);
6810
6811 /// \brief Determine whether the given declarator contains any unexpanded
6812 /// parameter packs.
6813 ///
6814 /// This routine is used by the parser to disambiguate function declarators
6815 /// with an ellipsis prior to the ')', e.g.,
6816 ///
6817 /// \code
6818 /// void f(T...);
6819 /// \endcode
6820 ///
6821 /// To determine whether we have an (unnamed) function parameter pack or
6822 /// a variadic function.
6823 ///
6824 /// \returns true if the declarator contains any unexpanded parameter packs,
6825 /// false otherwise.
6826 bool containsUnexpandedParameterPacks(Declarator &D);
6827
6828 /// \brief Returns the pattern of the pack expansion for a template argument.
6829 ///
6830 /// \param OrigLoc The template argument to expand.
6831 ///
6832 /// \param Ellipsis Will be set to the location of the ellipsis.
6833 ///
6834 /// \param NumExpansions Will be set to the number of expansions that will
6835 /// be generated from this pack expansion, if known a priori.
6836 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
6837 TemplateArgumentLoc OrigLoc,
6838 SourceLocation &Ellipsis,
6839 Optional<unsigned> &NumExpansions) const;
6840
6841 /// Given a template argument that contains an unexpanded parameter pack, but
6842 /// which has already been substituted, attempt to determine the number of
6843 /// elements that will be produced once this argument is fully-expanded.
6844 ///
6845 /// This is intended for use when transforming 'sizeof...(Arg)' in order to
6846 /// avoid actually expanding the pack where possible.
6847 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
6848
6849 //===--------------------------------------------------------------------===//
6850 // C++ Template Argument Deduction (C++ [temp.deduct])
6851 //===--------------------------------------------------------------------===//
6852
6853 /// Adjust the type \p ArgFunctionType to match the calling convention,
6854 /// noreturn, and optionally the exception specification of \p FunctionType.
6855 /// Deduction often wants to ignore these properties when matching function
6856 /// types.
6857 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
6858 bool AdjustExceptionSpec = false);
6859
6860 /// \brief Describes the result of template argument deduction.
6861 ///
6862 /// The TemplateDeductionResult enumeration describes the result of
6863 /// template argument deduction, as returned from
6864 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
6865 /// structure provides additional information about the results of
6866 /// template argument deduction, e.g., the deduced template argument
6867 /// list (if successful) or the specific template parameters or
6868 /// deduced arguments that were involved in the failure.
6869 enum TemplateDeductionResult {
6870 /// \brief Template argument deduction was successful.
6871 TDK_Success = 0,
6872 /// \brief The declaration was invalid; do nothing.
6873 TDK_Invalid,
6874 /// \brief Template argument deduction exceeded the maximum template
6875 /// instantiation depth (which has already been diagnosed).
6876 TDK_InstantiationDepth,
6877 /// \brief Template argument deduction did not deduce a value
6878 /// for every template parameter.
6879 TDK_Incomplete,
6880 /// \brief Template argument deduction produced inconsistent
6881 /// deduced values for the given template parameter.
6882 TDK_Inconsistent,
6883 /// \brief Template argument deduction failed due to inconsistent
6884 /// cv-qualifiers on a template parameter type that would
6885 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
6886 /// but were given a non-const "X".
6887 TDK_Underqualified,
6888 /// \brief Substitution of the deduced template argument values
6889 /// resulted in an error.
6890 TDK_SubstitutionFailure,
6891 /// \brief After substituting deduced template arguments, a dependent
6892 /// parameter type did not match the corresponding argument.
6893 TDK_DeducedMismatch,
6894 /// \brief After substituting deduced template arguments, an element of
6895 /// a dependent parameter type did not match the corresponding element
6896 /// of the corresponding argument (when deducing from an initializer list).
6897 TDK_DeducedMismatchNested,
6898 /// \brief A non-depnedent component of the parameter did not match the
6899 /// corresponding component of the argument.
6900 TDK_NonDeducedMismatch,
6901 /// \brief When performing template argument deduction for a function
6902 /// template, there were too many call arguments.
6903 TDK_TooManyArguments,
6904 /// \brief When performing template argument deduction for a function
6905 /// template, there were too few call arguments.
6906 TDK_TooFewArguments,
6907 /// \brief The explicitly-specified template arguments were not valid
6908 /// template arguments for the given template.
6909 TDK_InvalidExplicitArguments,
6910 /// \brief Checking non-dependent argument conversions failed.
6911 TDK_NonDependentConversionFailure,
6912 /// \brief Deduction failed; that's all we know.
6913 TDK_MiscellaneousDeductionFailure,
6914 /// \brief CUDA Target attributes do not match.
6915 TDK_CUDATargetMismatch
6916 };
6917
6918 TemplateDeductionResult
6919 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
6920 const TemplateArgumentList &TemplateArgs,
6921 sema::TemplateDeductionInfo &Info);
6922
6923 TemplateDeductionResult
6924 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
6925 const TemplateArgumentList &TemplateArgs,
6926 sema::TemplateDeductionInfo &Info);
6927
6928 TemplateDeductionResult SubstituteExplicitTemplateArguments(
6929 FunctionTemplateDecl *FunctionTemplate,
6930 TemplateArgumentListInfo &ExplicitTemplateArgs,
6931 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
6932 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
6933 sema::TemplateDeductionInfo &Info);
6934
6935 /// brief A function argument from which we performed template argument
6936 // deduction for a call.
6937 struct OriginalCallArg {
6938 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
6939 unsigned ArgIdx, QualType OriginalArgType)
6940 : OriginalParamType(OriginalParamType),
6941 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
6942 OriginalArgType(OriginalArgType) {}
6943
6944 QualType OriginalParamType;
6945 bool DecomposedParam;
6946 unsigned ArgIdx;
6947 QualType OriginalArgType;
6948 };
6949
6950 TemplateDeductionResult FinishTemplateArgumentDeduction(
6951 FunctionTemplateDecl *FunctionTemplate,
6952 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
6953 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
6954 sema::TemplateDeductionInfo &Info,
6955 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
6956 bool PartialOverloading = false,
6957 llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
6958
6959 TemplateDeductionResult DeduceTemplateArguments(
6960 FunctionTemplateDecl *FunctionTemplate,
6961 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
6962 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
6963 bool PartialOverloading,
6964 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
6965
6966 TemplateDeductionResult
6967 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
6968 TemplateArgumentListInfo *ExplicitTemplateArgs,
6969 QualType ArgFunctionType,
6970 FunctionDecl *&Specialization,
6971 sema::TemplateDeductionInfo &Info,
6972 bool IsAddressOfFunction = false);
6973
6974 TemplateDeductionResult
6975 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
6976 QualType ToType,
6977 CXXConversionDecl *&Specialization,
6978 sema::TemplateDeductionInfo &Info);
6979
6980 TemplateDeductionResult
6981 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
6982 TemplateArgumentListInfo *ExplicitTemplateArgs,
6983 FunctionDecl *&Specialization,
6984 sema::TemplateDeductionInfo &Info,
6985 bool IsAddressOfFunction = false);
6986
6987 /// \brief Substitute Replacement for \p auto in \p TypeWithAuto
6988 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
6989 /// \brief Substitute Replacement for auto in TypeWithAuto
6990 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
6991 QualType Replacement);
6992 /// \brief Completely replace the \c auto in \p TypeWithAuto by
6993 /// \p Replacement. This does not retain any \c auto type sugar.
6994 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
6995
6996 /// \brief Result type of DeduceAutoType.
6997 enum DeduceAutoResult {
6998 DAR_Succeeded,
6999 DAR_Failed,
7000 DAR_FailedAlreadyDiagnosed
7001 };
7002
7003 DeduceAutoResult
7004 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
7005 Optional<unsigned> DependentDeductionDepth = None);
7006 DeduceAutoResult
7007 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
7008 Optional<unsigned> DependentDeductionDepth = None);
7009 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
7010 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
7011 bool Diagnose = true);
7012
7013 /// \brief Declare implicit deduction guides for a class template if we've
7014 /// not already done so.
7015 void DeclareImplicitDeductionGuides(TemplateDecl *Template,
7016 SourceLocation Loc);
7017
7018 QualType DeduceTemplateSpecializationFromInitializer(
7019 TypeSourceInfo *TInfo, const InitializedEntity &Entity,
7020 const InitializationKind &Kind, MultiExprArg Init);
7021
7022 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
7023 QualType Type, TypeSourceInfo *TSI,
7024 SourceRange Range, bool DirectInit,
7025 Expr *Init);
7026
7027 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
7028
7029 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
7030 SourceLocation ReturnLoc,
7031 Expr *&RetExpr, AutoType *AT);
7032
7033 FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
7034 FunctionTemplateDecl *FT2,
7035 SourceLocation Loc,
7036 TemplatePartialOrderingContext TPOC,
7037 unsigned NumCallArguments1,
7038 unsigned NumCallArguments2);
7039 UnresolvedSetIterator
7040 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
7041 TemplateSpecCandidateSet &FailedCandidates,
7042 SourceLocation Loc,
7043 const PartialDiagnostic &NoneDiag,
7044 const PartialDiagnostic &AmbigDiag,
7045 const PartialDiagnostic &CandidateDiag,
7046 bool Complain = true, QualType TargetType = QualType());
7047
7048 ClassTemplatePartialSpecializationDecl *
7049 getMoreSpecializedPartialSpecialization(
7050 ClassTemplatePartialSpecializationDecl *PS1,
7051 ClassTemplatePartialSpecializationDecl *PS2,
7052 SourceLocation Loc);
7053
7054 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
7055 sema::TemplateDeductionInfo &Info);
7056
7057 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
7058 VarTemplatePartialSpecializationDecl *PS1,
7059 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
7060
7061 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
7062 sema::TemplateDeductionInfo &Info);
7063
7064 bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
7065 TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc);
7066
7067 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
7068 bool OnlyDeduced,
7069 unsigned Depth,
7070 llvm::SmallBitVector &Used);
7071 void MarkDeducedTemplateParameters(
7072 const FunctionTemplateDecl *FunctionTemplate,
7073 llvm::SmallBitVector &Deduced) {
7074 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
7075 }
7076 static void MarkDeducedTemplateParameters(ASTContext &Ctx,
7077 const FunctionTemplateDecl *FunctionTemplate,
7078 llvm::SmallBitVector &Deduced);
7079
7080 //===--------------------------------------------------------------------===//
7081 // C++ Template Instantiation
7082 //
7083
7084 MultiLevelTemplateArgumentList
7085 getTemplateInstantiationArgs(NamedDecl *D,
7086 const TemplateArgumentList *Innermost = nullptr,
7087 bool RelativeToPrimary = false,
7088 const FunctionDecl *Pattern = nullptr);
7089
7090 /// A context in which code is being synthesized (where a source location
7091 /// alone is not sufficient to identify the context). This covers template
7092 /// instantiation and various forms of implicitly-generated functions.
7093 struct CodeSynthesisContext {
7094 /// \brief The kind of template instantiation we are performing
7095 enum SynthesisKind {
7096 /// We are instantiating a template declaration. The entity is
7097 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
7098 TemplateInstantiation,
7099
7100 /// We are instantiating a default argument for a template
7101 /// parameter. The Entity is the template parameter whose argument is
7102 /// being instantiated, the Template is the template, and the
7103 /// TemplateArgs/NumTemplateArguments provide the template arguments as
7104 /// specified.
7105 DefaultTemplateArgumentInstantiation,
7106
7107 /// We are instantiating a default argument for a function.
7108 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
7109 /// provides the template arguments as specified.
7110 DefaultFunctionArgumentInstantiation,
7111
7112 /// We are substituting explicit template arguments provided for
7113 /// a function template. The entity is a FunctionTemplateDecl.
7114 ExplicitTemplateArgumentSubstitution,
7115
7116 /// We are substituting template argument determined as part of
7117 /// template argument deduction for either a class template
7118 /// partial specialization or a function template. The
7119 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
7120 /// a TemplateDecl.
7121 DeducedTemplateArgumentSubstitution,
7122
7123 /// We are substituting prior template arguments into a new
7124 /// template parameter. The template parameter itself is either a
7125 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
7126 PriorTemplateArgumentSubstitution,
7127
7128 /// We are checking the validity of a default template argument that
7129 /// has been used when naming a template-id.
7130 DefaultTemplateArgumentChecking,
7131
7132 /// We are instantiating the exception specification for a function
7133 /// template which was deferred until it was needed.
7134 ExceptionSpecInstantiation,
7135
7136 /// We are declaring an implicit special member function.
7137 DeclaringSpecialMember,
7138
7139 /// We are defining a synthesized function (such as a defaulted special
7140 /// member).
7141 DefiningSynthesizedFunction,
7142
7143 /// Added for Template instantiation observation.
7144 /// Memoization means we are _not_ instantiating a template because
7145 /// it is already instantiated (but we entered a context where we
7146 /// would have had to if it was not already instantiated).
7147 Memoization
7148 } Kind;
7149
7150 /// \brief Was the enclosing context a non-instantiation SFINAE context?
7151 bool SavedInNonInstantiationSFINAEContext;
7152
7153 /// \brief The point of instantiation or synthesis within the source code.
7154 SourceLocation PointOfInstantiation;
7155
7156 /// \brief The entity that is being synthesized.
7157 Decl *Entity;
7158
7159 /// \brief The template (or partial specialization) in which we are
7160 /// performing the instantiation, for substitutions of prior template
7161 /// arguments.
7162 NamedDecl *Template;
7163
7164 /// \brief The list of template arguments we are substituting, if they
7165 /// are not part of the entity.
7166 const TemplateArgument *TemplateArgs;
7167
7168 // FIXME: Wrap this union around more members, or perhaps store the
7169 // kind-specific members in the RAII object owning the context.
7170 union {
7171 /// \brief The number of template arguments in TemplateArgs.
7172 unsigned NumTemplateArgs;
7173
7174 /// \brief The special member being declared or defined.
7175 CXXSpecialMember SpecialMember;
7176 };
7177
7178 ArrayRef<TemplateArgument> template_arguments() const {
7179 assert(Kind != DeclaringSpecialMember)(static_cast <bool> (Kind != DeclaringSpecialMember) ? void
(0) : __assert_fail ("Kind != DeclaringSpecialMember", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7179, __extension__ __PRETTY_FUNCTION__))
;
7180 return {TemplateArgs, NumTemplateArgs};
7181 }
7182
7183 /// \brief The template deduction info object associated with the
7184 /// substitution or checking of explicit or deduced template arguments.
7185 sema::TemplateDeductionInfo *DeductionInfo;
7186
7187 /// \brief The source range that covers the construct that cause
7188 /// the instantiation, e.g., the template-id that causes a class
7189 /// template instantiation.
7190 SourceRange InstantiationRange;
7191
7192 CodeSynthesisContext()
7193 : Kind(TemplateInstantiation), Entity(nullptr), Template(nullptr),
7194 TemplateArgs(nullptr), NumTemplateArgs(0), DeductionInfo(nullptr) {}
7195
7196 /// \brief Determines whether this template is an actual instantiation
7197 /// that should be counted toward the maximum instantiation depth.
7198 bool isInstantiationRecord() const;
7199 };
7200
7201 /// \brief List of active code synthesis contexts.
7202 ///
7203 /// This vector is treated as a stack. As synthesis of one entity requires
7204 /// synthesis of another, additional contexts are pushed onto the stack.
7205 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts;
7206
7207 /// Specializations whose definitions are currently being instantiated.
7208 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations;
7209
7210 /// Non-dependent types used in templates that have already been instantiated
7211 /// by some template instantiation.
7212 llvm::DenseSet<QualType> InstantiatedNonDependentTypes;
7213
7214 /// \brief Extra modules inspected when performing a lookup during a template
7215 /// instantiation. Computed lazily.
7216 SmallVector<Module*, 16> CodeSynthesisContextLookupModules;
7217
7218 /// \brief Cache of additional modules that should be used for name lookup
7219 /// within the current template instantiation. Computed lazily; use
7220 /// getLookupModules() to get a complete set.
7221 llvm::DenseSet<Module*> LookupModulesCache;
7222
7223 /// \brief Get the set of additional modules that should be checked during
7224 /// name lookup. A module and its imports become visible when instanting a
7225 /// template defined within it.
7226 llvm::DenseSet<Module*> &getLookupModules();
7227
7228 /// \brief Map from the most recent declaration of a namespace to the most
7229 /// recent visible declaration of that namespace.
7230 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
7231
7232 /// \brief Whether we are in a SFINAE context that is not associated with
7233 /// template instantiation.
7234 ///
7235 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
7236 /// of a template instantiation or template argument deduction.
7237 bool InNonInstantiationSFINAEContext;
7238
7239 /// \brief The number of \p CodeSynthesisContexts that are not template
7240 /// instantiations and, therefore, should not be counted as part of the
7241 /// instantiation depth.
7242 ///
7243 /// When the instantiation depth reaches the user-configurable limit
7244 /// \p LangOptions::InstantiationDepth we will abort instantiation.
7245 // FIXME: Should we have a similar limit for other forms of synthesis?
7246 unsigned NonInstantiationEntries;
7247
7248 /// \brief The depth of the context stack at the point when the most recent
7249 /// error or warning was produced.
7250 ///
7251 /// This value is used to suppress printing of redundant context stacks
7252 /// when there are multiple errors or warnings in the same instantiation.
7253 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
7254 unsigned LastEmittedCodeSynthesisContextDepth = 0;
7255
7256 /// \brief The template instantiation callbacks to trace or track
7257 /// instantiations (objects can be chained).
7258 ///
7259 /// This callbacks is used to print, trace or track template
7260 /// instantiations as they are being constructed.
7261 std::vector<std::unique_ptr<TemplateInstantiationCallback>>
7262 TemplateInstCallbacks;
7263
7264 /// \brief The current index into pack expansion arguments that will be
7265 /// used for substitution of parameter packs.
7266 ///
7267 /// The pack expansion index will be -1 to indicate that parameter packs
7268 /// should be instantiated as themselves. Otherwise, the index specifies
7269 /// which argument within the parameter pack will be used for substitution.
7270 int ArgumentPackSubstitutionIndex;
7271
7272 /// \brief RAII object used to change the argument pack substitution index
7273 /// within a \c Sema object.
7274 ///
7275 /// See \c ArgumentPackSubstitutionIndex for more information.
7276 class ArgumentPackSubstitutionIndexRAII {
7277 Sema &Self;
7278 int OldSubstitutionIndex;
7279
7280 public:
7281 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
7282 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
7283 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
7284 }
7285
7286 ~ArgumentPackSubstitutionIndexRAII() {
7287 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
7288 }
7289 };
7290
7291 friend class ArgumentPackSubstitutionRAII;
7292
7293 /// \brief For each declaration that involved template argument deduction, the
7294 /// set of diagnostics that were suppressed during that template argument
7295 /// deduction.
7296 ///
7297 /// FIXME: Serialize this structure to the AST file.
7298 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
7299 SuppressedDiagnosticsMap;
7300 SuppressedDiagnosticsMap SuppressedDiagnostics;
7301
7302 /// \brief A stack object to be created when performing template
7303 /// instantiation.
7304 ///
7305 /// Construction of an object of type \c InstantiatingTemplate
7306 /// pushes the current instantiation onto the stack of active
7307 /// instantiations. If the size of this stack exceeds the maximum
7308 /// number of recursive template instantiations, construction
7309 /// produces an error and evaluates true.
7310 ///
7311 /// Destruction of this object will pop the named instantiation off
7312 /// the stack.
7313 struct InstantiatingTemplate {
7314 /// \brief Note that we are instantiating a class template,
7315 /// function template, variable template, alias template,
7316 /// or a member thereof.
7317 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7318 Decl *Entity,
7319 SourceRange InstantiationRange = SourceRange());
7320
7321 struct ExceptionSpecification {};
7322 /// \brief Note that we are instantiating an exception specification
7323 /// of a function template.
7324 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7325 FunctionDecl *Entity, ExceptionSpecification,
7326 SourceRange InstantiationRange = SourceRange());
7327
7328 /// \brief Note that we are instantiating a default argument in a
7329 /// template-id.
7330 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7331 TemplateParameter Param, TemplateDecl *Template,
7332 ArrayRef<TemplateArgument> TemplateArgs,
7333 SourceRange InstantiationRange = SourceRange());
7334
7335 /// \brief Note that we are substituting either explicitly-specified or
7336 /// deduced template arguments during function template argument deduction.
7337 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7338 FunctionTemplateDecl *FunctionTemplate,
7339 ArrayRef<TemplateArgument> TemplateArgs,
7340 CodeSynthesisContext::SynthesisKind Kind,
7341 sema::TemplateDeductionInfo &DeductionInfo,
7342 SourceRange InstantiationRange = SourceRange());
7343
7344 /// \brief Note that we are instantiating as part of template
7345 /// argument deduction for a class template declaration.
7346 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7347 TemplateDecl *Template,
7348 ArrayRef<TemplateArgument> TemplateArgs,
7349 sema::TemplateDeductionInfo &DeductionInfo,
7350 SourceRange InstantiationRange = SourceRange());
7351
7352 /// \brief Note that we are instantiating as part of template
7353 /// argument deduction for a class template partial
7354 /// specialization.
7355 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7356 ClassTemplatePartialSpecializationDecl *PartialSpec,
7357 ArrayRef<TemplateArgument> TemplateArgs,
7358 sema::TemplateDeductionInfo &DeductionInfo,
7359 SourceRange InstantiationRange = SourceRange());
7360
7361 /// \brief Note that we are instantiating as part of template
7362 /// argument deduction for a variable template partial
7363 /// specialization.
7364 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7365 VarTemplatePartialSpecializationDecl *PartialSpec,
7366 ArrayRef<TemplateArgument> TemplateArgs,
7367 sema::TemplateDeductionInfo &DeductionInfo,
7368 SourceRange InstantiationRange = SourceRange());
7369
7370 /// \brief Note that we are instantiating a default argument for a function
7371 /// parameter.
7372 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7373 ParmVarDecl *Param,
7374 ArrayRef<TemplateArgument> TemplateArgs,
7375 SourceRange InstantiationRange = SourceRange());
7376
7377 /// \brief Note that we are substituting prior template arguments into a
7378 /// non-type parameter.
7379 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7380 NamedDecl *Template,
7381 NonTypeTemplateParmDecl *Param,
7382 ArrayRef<TemplateArgument> TemplateArgs,
7383 SourceRange InstantiationRange);
7384
7385 /// \brief Note that we are substituting prior template arguments into a
7386 /// template template parameter.
7387 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7388 NamedDecl *Template,
7389 TemplateTemplateParmDecl *Param,
7390 ArrayRef<TemplateArgument> TemplateArgs,
7391 SourceRange InstantiationRange);
7392
7393 /// \brief Note that we are checking the default template argument
7394 /// against the template parameter for a given template-id.
7395 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7396 TemplateDecl *Template,
7397 NamedDecl *Param,
7398 ArrayRef<TemplateArgument> TemplateArgs,
7399 SourceRange InstantiationRange);
7400
7401
7402 /// \brief Note that we have finished instantiating this template.
7403 void Clear();
7404
7405 ~InstantiatingTemplate() { Clear(); }
7406
7407 /// \brief Determines whether we have exceeded the maximum
7408 /// recursive template instantiations.
7409 bool isInvalid() const { return Invalid; }
7410
7411 /// \brief Determine whether we are already instantiating this
7412 /// specialization in some surrounding active instantiation.
7413 bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
7414
7415 private:
7416 Sema &SemaRef;
7417 bool Invalid;
7418 bool AlreadyInstantiating;
7419 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
7420 SourceRange InstantiationRange);
7421
7422 InstantiatingTemplate(
7423 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
7424 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
7425 Decl *Entity, NamedDecl *Template = nullptr,
7426 ArrayRef<TemplateArgument> TemplateArgs = None,
7427 sema::TemplateDeductionInfo *DeductionInfo = nullptr);
7428
7429 InstantiatingTemplate(const InstantiatingTemplate&) = delete;
7430
7431 InstantiatingTemplate&
7432 operator=(const InstantiatingTemplate&) = delete;
7433 };
7434
7435 void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
7436 void popCodeSynthesisContext();
7437
7438 /// Determine whether we are currently performing template instantiation.
7439 bool inTemplateInstantiation() const {
7440 return CodeSynthesisContexts.size() > NonInstantiationEntries;
7441 }
7442
7443 void PrintContextStack() {
7444 if (!CodeSynthesisContexts.empty() &&
7445 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
7446 PrintInstantiationStack();
7447 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
7448 }
7449 if (PragmaAttributeCurrentTargetDecl)
7450 PrintPragmaAttributeInstantiationPoint();
7451 }
7452 void PrintInstantiationStack();
7453
7454 void PrintPragmaAttributeInstantiationPoint();
7455
7456 /// \brief Determines whether we are currently in a context where
7457 /// template argument substitution failures are not considered
7458 /// errors.
7459 ///
7460 /// \returns An empty \c Optional if we're not in a SFINAE context.
7461 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest
7462 /// template-deduction context object, which can be used to capture
7463 /// diagnostics that will be suppressed.
7464 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
7465
7466 /// \brief Determines whether we are currently in a context that
7467 /// is not evaluated as per C++ [expr] p5.
7468 bool isUnevaluatedContext() const {
7469 assert(!ExprEvalContexts.empty() &&(static_cast <bool> (!ExprEvalContexts.empty() &&
"Must be in an expression evaluation context") ? void (0) : __assert_fail
("!ExprEvalContexts.empty() && \"Must be in an expression evaluation context\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7470, __extension__ __PRETTY_FUNCTION__))
7470 "Must be in an expression evaluation context")(static_cast <bool> (!ExprEvalContexts.empty() &&
"Must be in an expression evaluation context") ? void (0) : __assert_fail
("!ExprEvalContexts.empty() && \"Must be in an expression evaluation context\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7470, __extension__ __PRETTY_FUNCTION__))
;
7471 return ExprEvalContexts.back().isUnevaluated();
7472 }
7473
7474 /// \brief RAII class used to determine whether SFINAE has
7475 /// trapped any errors that occur during template argument
7476 /// deduction.
7477 class SFINAETrap {
7478 Sema &SemaRef;
7479 unsigned PrevSFINAEErrors;
7480 bool PrevInNonInstantiationSFINAEContext;
7481 bool PrevAccessCheckingSFINAE;
7482 bool PrevLastDiagnosticIgnored;
7483
7484 public:
7485 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
7486 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
7487 PrevInNonInstantiationSFINAEContext(
7488 SemaRef.InNonInstantiationSFINAEContext),
7489 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
7490 PrevLastDiagnosticIgnored(
7491 SemaRef.getDiagnostics().isLastDiagnosticIgnored())
7492 {
7493 if (!SemaRef.isSFINAEContext())
7494 SemaRef.InNonInstantiationSFINAEContext = true;
7495 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
7496 }
7497
7498 ~SFINAETrap() {
7499 SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
7500 SemaRef.InNonInstantiationSFINAEContext
7501 = PrevInNonInstantiationSFINAEContext;
7502 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
7503 SemaRef.getDiagnostics().setLastDiagnosticIgnored(
7504 PrevLastDiagnosticIgnored);
7505 }
7506
7507 /// \brief Determine whether any SFINAE errors have been trapped.
7508 bool hasErrorOccurred() const {
7509 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
7510 }
7511 };
7512
7513 /// \brief RAII class used to indicate that we are performing provisional
7514 /// semantic analysis to determine the validity of a construct, so
7515 /// typo-correction and diagnostics in the immediate context (not within
7516 /// implicitly-instantiated templates) should be suppressed.
7517 class TentativeAnalysisScope {
7518 Sema &SemaRef;
7519 // FIXME: Using a SFINAETrap for this is a hack.
7520 SFINAETrap Trap;
7521 bool PrevDisableTypoCorrection;
7522 public:
7523 explicit TentativeAnalysisScope(Sema &SemaRef)
7524 : SemaRef(SemaRef), Trap(SemaRef, true),
7525 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
7526 SemaRef.DisableTypoCorrection = true;
7527 }
7528 ~TentativeAnalysisScope() {
7529 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
7530 }
7531 };
7532
7533 /// \brief The current instantiation scope used to store local
7534 /// variables.
7535 LocalInstantiationScope *CurrentInstantiationScope;
7536
7537 /// \brief Tracks whether we are in a context where typo correction is
7538 /// disabled.
7539 bool DisableTypoCorrection;
7540
7541 /// \brief The number of typos corrected by CorrectTypo.
7542 unsigned TyposCorrected;
7543
7544 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;
7545 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
7546
7547 /// \brief A cache containing identifiers for which typo correction failed and
7548 /// their locations, so that repeated attempts to correct an identifier in a
7549 /// given location are ignored if typo correction already failed for it.
7550 IdentifierSourceLocations TypoCorrectionFailures;
7551
7552 /// \brief Worker object for performing CFG-based warnings.
7553 sema::AnalysisBasedWarnings AnalysisWarnings;
7554 threadSafety::BeforeSet *ThreadSafetyDeclCache;
7555
7556 /// \brief An entity for which implicit template instantiation is required.
7557 ///
7558 /// The source location associated with the declaration is the first place in
7559 /// the source code where the declaration was "used". It is not necessarily
7560 /// the point of instantiation (which will be either before or after the
7561 /// namespace-scope declaration that triggered this implicit instantiation),
7562 /// However, it is the location that diagnostics should generally refer to,
7563 /// because users will need to know what code triggered the instantiation.
7564 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
7565
7566 /// \brief The queue of implicit template instantiations that are required
7567 /// but have not yet been performed.
7568 std::deque<PendingImplicitInstantiation> PendingInstantiations;
7569
7570 /// Queue of implicit template instantiations that cannot be performed
7571 /// eagerly.
7572 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations;
7573
7574 class GlobalEagerInstantiationScope {
7575 public:
7576 GlobalEagerInstantiationScope(Sema &S, bool Enabled)
7577 : S(S), Enabled(Enabled) {
7578 if (!Enabled) return;
7579
7580 SavedPendingInstantiations.swap(S.PendingInstantiations);
7581 SavedVTableUses.swap(S.VTableUses);
7582 }
7583
7584 void perform() {
7585 if (Enabled) {
7586 S.DefineUsedVTables();
7587 S.PerformPendingInstantiations();
7588 }
7589 }
7590
7591 ~GlobalEagerInstantiationScope() {
7592 if (!Enabled) return;
7593
7594 // Restore the set of pending vtables.
7595 assert(S.VTableUses.empty() &&(static_cast <bool> (S.VTableUses.empty() && "VTableUses should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.VTableUses.empty() && \"VTableUses should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7596, __extension__ __PRETTY_FUNCTION__))
7596 "VTableUses should be empty before it is discarded.")(static_cast <bool> (S.VTableUses.empty() && "VTableUses should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.VTableUses.empty() && \"VTableUses should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7596, __extension__ __PRETTY_FUNCTION__))
;
7597 S.VTableUses.swap(SavedVTableUses);
7598
7599 // Restore the set of pending implicit instantiations.
7600 assert(S.PendingInstantiations.empty() &&(static_cast <bool> (S.PendingInstantiations.empty() &&
"PendingInstantiations should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.PendingInstantiations.empty() && \"PendingInstantiations should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7601, __extension__ __PRETTY_FUNCTION__))
7601 "PendingInstantiations should be empty before it is discarded.")(static_cast <bool> (S.PendingInstantiations.empty() &&
"PendingInstantiations should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.PendingInstantiations.empty() && \"PendingInstantiations should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7601, __extension__ __PRETTY_FUNCTION__))
;
7602 S.PendingInstantiations.swap(SavedPendingInstantiations);
7603 }
7604
7605 private:
7606 Sema &S;
7607 SmallVector<VTableUse, 16> SavedVTableUses;
7608 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
7609 bool Enabled;
7610 };
7611
7612 /// \brief The queue of implicit template instantiations that are required
7613 /// and must be performed within the current local scope.
7614 ///
7615 /// This queue is only used for member functions of local classes in
7616 /// templates, which must be instantiated in the same scope as their
7617 /// enclosing function, so that they can reference function-local
7618 /// types, static variables, enumerators, etc.
7619 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
7620
7621 class LocalEagerInstantiationScope {
7622 public:
7623 LocalEagerInstantiationScope(Sema &S) : S(S) {
7624 SavedPendingLocalImplicitInstantiations.swap(
7625 S.PendingLocalImplicitInstantiations);
7626 }
7627
7628 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }
7629
7630 ~LocalEagerInstantiationScope() {
7631 assert(S.PendingLocalImplicitInstantiations.empty() &&(static_cast <bool> (S.PendingLocalImplicitInstantiations
.empty() && "there shouldn't be any pending local implicit instantiations"
) ? void (0) : __assert_fail ("S.PendingLocalImplicitInstantiations.empty() && \"there shouldn't be any pending local implicit instantiations\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7632, __extension__ __PRETTY_FUNCTION__))
7632 "there shouldn't be any pending local implicit instantiations")(static_cast <bool> (S.PendingLocalImplicitInstantiations
.empty() && "there shouldn't be any pending local implicit instantiations"
) ? void (0) : __assert_fail ("S.PendingLocalImplicitInstantiations.empty() && \"there shouldn't be any pending local implicit instantiations\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7632, __extension__ __PRETTY_FUNCTION__))
;
7633 SavedPendingLocalImplicitInstantiations.swap(
7634 S.PendingLocalImplicitInstantiations);
7635 }
7636
7637 private:
7638 Sema &S;
7639 std::deque<PendingImplicitInstantiation>
7640 SavedPendingLocalImplicitInstantiations;
7641 };
7642
7643 /// A helper class for building up ExtParameterInfos.
7644 class ExtParameterInfoBuilder {
7645 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos;
7646 bool HasInteresting = false;
7647
7648 public:
7649 /// Set the ExtParameterInfo for the parameter at the given index,
7650 ///
7651 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
7652 assert(Infos.size() <= index)(static_cast <bool> (Infos.size() <= index) ? void (
0) : __assert_fail ("Infos.size() <= index", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 7652, __extension__ __PRETTY_FUNCTION__))
;
7653 Infos.resize(index);
7654 Infos.push_back(info);
7655
7656 if (!HasInteresting)
7657 HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
7658 }
7659
7660 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the
7661 /// ExtParameterInfo array we've built up.
7662 const FunctionProtoType::ExtParameterInfo *
7663 getPointerOrNull(unsigned numParams) {
7664 if (!HasInteresting) return nullptr;
7665 Infos.resize(numParams);
7666 return Infos.data();
7667 }
7668 };
7669
7670 void PerformPendingInstantiations(bool LocalOnly = false);
7671
7672 TypeSourceInfo *SubstType(TypeSourceInfo *T,
7673 const MultiLevelTemplateArgumentList &TemplateArgs,
7674 SourceLocation Loc, DeclarationName Entity,
7675 bool AllowDeducedTST = false);
7676
7677 QualType SubstType(QualType T,
7678 const MultiLevelTemplateArgumentList &TemplateArgs,
7679 SourceLocation Loc, DeclarationName Entity);
7680
7681 TypeSourceInfo *SubstType(TypeLoc TL,
7682 const MultiLevelTemplateArgumentList &TemplateArgs,
7683 SourceLocation Loc, DeclarationName Entity);
7684
7685 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
7686 const MultiLevelTemplateArgumentList &TemplateArgs,
7687 SourceLocation Loc,
7688 DeclarationName Entity,
7689 CXXRecordDecl *ThisContext,
7690 unsigned ThisTypeQuals);
7691 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
7692 const MultiLevelTemplateArgumentList &Args);
7693 bool SubstExceptionSpec(SourceLocation Loc,
7694 FunctionProtoType::ExceptionSpecInfo &ESI,
7695 SmallVectorImpl<QualType> &ExceptionStorage,
7696 const MultiLevelTemplateArgumentList &Args);
7697 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
7698 const MultiLevelTemplateArgumentList &TemplateArgs,
7699 int indexAdjustment,
7700 Optional<unsigned> NumExpansions,
7701 bool ExpectParameterPack);
7702 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
7703 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
7704 const MultiLevelTemplateArgumentList &TemplateArgs,
7705 SmallVectorImpl<QualType> &ParamTypes,
7706 SmallVectorImpl<ParmVarDecl *> *OutParams,
7707 ExtParameterInfoBuilder &ParamInfos);
7708 ExprResult SubstExpr(Expr *E,
7709 const MultiLevelTemplateArgumentList &TemplateArgs);
7710
7711 /// \brief Substitute the given template arguments into a list of
7712 /// expressions, expanding pack expansions if required.
7713 ///
7714 /// \param Exprs The list of expressions to substitute into.
7715 ///
7716 /// \param IsCall Whether this is some form of call, in which case
7717 /// default arguments will be dropped.
7718 ///
7719 /// \param TemplateArgs The set of template arguments to substitute.
7720 ///
7721 /// \param Outputs Will receive all of the substituted arguments.
7722 ///
7723 /// \returns true if an error occurred, false otherwise.
7724 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
7725 const MultiLevelTemplateArgumentList &TemplateArgs,
7726 SmallVectorImpl<Expr *> &Outputs);
7727
7728 StmtResult SubstStmt(Stmt *S,
7729 const MultiLevelTemplateArgumentList &TemplateArgs);
7730
7731 TemplateParameterList *
7732 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
7733 const MultiLevelTemplateArgumentList &TemplateArgs);
7734
7735 Decl *SubstDecl(Decl *D, DeclContext *Owner,
7736 const MultiLevelTemplateArgumentList &TemplateArgs);
7737
7738 ExprResult SubstInitializer(Expr *E,
7739 const MultiLevelTemplateArgumentList &TemplateArgs,
7740 bool CXXDirectInit);
7741
7742 bool
7743 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
7744 CXXRecordDecl *Pattern,
7745 const MultiLevelTemplateArgumentList &TemplateArgs);
7746
7747 bool
7748 InstantiateClass(SourceLocation PointOfInstantiation,
7749 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
7750 const MultiLevelTemplateArgumentList &TemplateArgs,
7751 TemplateSpecializationKind TSK,
7752 bool Complain = true);
7753
7754 bool InstantiateEnum(SourceLocation PointOfInstantiation,
7755 EnumDecl *Instantiation, EnumDecl *Pattern,
7756 const MultiLevelTemplateArgumentList &TemplateArgs,
7757 TemplateSpecializationKind TSK);
7758
7759 bool InstantiateInClassInitializer(
7760 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
7761 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
7762
7763 struct LateInstantiatedAttribute {
7764 const Attr *TmplAttr;
7765 LocalInstantiationScope *Scope;
7766 Decl *NewDecl;
7767
7768 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,
7769 Decl *D)
7770 : TmplAttr(A), Scope(S), NewDecl(D)
7771 { }
7772 };
7773 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;
7774
7775 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
7776 const Decl *Pattern, Decl *Inst,
7777 LateInstantiatedAttrVec *LateAttrs = nullptr,
7778 LocalInstantiationScope *OuterMostScope = nullptr);
7779
7780 void
7781 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
7782 const Decl *Pattern, Decl *Inst,
7783 LateInstantiatedAttrVec *LateAttrs = nullptr,
7784 LocalInstantiationScope *OuterMostScope = nullptr);
7785
7786 bool usesPartialOrExplicitSpecialization(
7787 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
7788
7789 bool
7790 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
7791 ClassTemplateSpecializationDecl *ClassTemplateSpec,
7792 TemplateSpecializationKind TSK,
7793 bool Complain = true);
7794
7795 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
7796 CXXRecordDecl *Instantiation,
7797 const MultiLevelTemplateArgumentList &TemplateArgs,
7798 TemplateSpecializationKind TSK);
7799
7800 void InstantiateClassTemplateSpecializationMembers(
7801 SourceLocation PointOfInstantiation,
7802 ClassTemplateSpecializationDecl *ClassTemplateSpec,
7803 TemplateSpecializationKind TSK);
7804
7805 NestedNameSpecifierLoc
7806 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
7807 const MultiLevelTemplateArgumentList &TemplateArgs);
7808
7809 DeclarationNameInfo
7810 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
7811 const MultiLevelTemplateArgumentList &TemplateArgs);
7812 TemplateName
7813 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
7814 SourceLocation Loc,
7815 const MultiLevelTemplateArgumentList &TemplateArgs);
7816 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
7817 TemplateArgumentListInfo &Result,
7818 const MultiLevelTemplateArgumentList &TemplateArgs);
7819
7820 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
7821 FunctionDecl *Function);
7822 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
7823 const TemplateArgumentList *Args,
7824 SourceLocation Loc);
7825 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
7826 FunctionDecl *Function,
7827 bool Recursive = false,
7828 bool DefinitionRequired = false,
7829 bool AtEndOfTU = false);
7830 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
7831 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
7832 const TemplateArgumentList &TemplateArgList,
7833 const TemplateArgumentListInfo &TemplateArgsInfo,
7834 SmallVectorImpl<TemplateArgument> &Converted,
7835 SourceLocation PointOfInstantiation, void *InsertPos,
7836 LateInstantiatedAttrVec *LateAttrs = nullptr,
7837 LocalInstantiationScope *StartingScope = nullptr);
7838 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
7839 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
7840 const MultiLevelTemplateArgumentList &TemplateArgs);
7841 void
7842 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
7843 const MultiLevelTemplateArgumentList &TemplateArgs,
7844 LateInstantiatedAttrVec *LateAttrs,
7845 DeclContext *Owner,
7846 LocalInstantiationScope *StartingScope,
7847 bool InstantiatingVarTemplate = false);
7848 void InstantiateVariableInitializer(
7849 VarDecl *Var, VarDecl *OldVar,
7850 const MultiLevelTemplateArgumentList &TemplateArgs);
7851 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
7852 VarDecl *Var, bool Recursive = false,
7853 bool DefinitionRequired = false,
7854 bool AtEndOfTU = false);
7855
7856 void InstantiateMemInitializers(CXXConstructorDecl *New,
7857 const CXXConstructorDecl *Tmpl,
7858 const MultiLevelTemplateArgumentList &TemplateArgs);
7859
7860 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
7861 const MultiLevelTemplateArgumentList &TemplateArgs,
7862 bool FindingInstantiatedContext = false);
7863 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
7864 const MultiLevelTemplateArgumentList &TemplateArgs);
7865
7866 // Objective-C declarations.
7867 enum ObjCContainerKind {
7868 OCK_None = -1,
7869 OCK_Interface = 0,
7870 OCK_Protocol,
7871 OCK_Category,
7872 OCK_ClassExtension,
7873 OCK_Implementation,
7874 OCK_CategoryImplementation
7875 };
7876 ObjCContainerKind getObjCContainerKind() const;
7877
7878 DeclResult actOnObjCTypeParam(Scope *S,
7879 ObjCTypeParamVariance variance,
7880 SourceLocation varianceLoc,
7881 unsigned index,
7882 IdentifierInfo *paramName,
7883 SourceLocation paramLoc,
7884 SourceLocation colonLoc,
7885 ParsedType typeBound);
7886
7887 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,
7888 ArrayRef<Decl *> typeParams,
7889 SourceLocation rAngleLoc);
7890 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);
7891
7892 Decl *ActOnStartClassInterface(Scope *S,
7893 SourceLocation AtInterfaceLoc,
7894 IdentifierInfo *ClassName,
7895 SourceLocation ClassLoc,
7896 ObjCTypeParamList *typeParamList,
7897 IdentifierInfo *SuperName,
7898 SourceLocation SuperLoc,
7899 ArrayRef<ParsedType> SuperTypeArgs,
7900 SourceRange SuperTypeArgsRange,
7901 Decl * const *ProtoRefs,
7902 unsigned NumProtoRefs,
7903 const SourceLocation *ProtoLocs,
7904 SourceLocation EndProtoLoc,
7905 AttributeList *AttrList);
7906
7907 void ActOnSuperClassOfClassInterface(Scope *S,
7908 SourceLocation AtInterfaceLoc,
7909 ObjCInterfaceDecl *IDecl,
7910 IdentifierInfo *ClassName,
7911 SourceLocation ClassLoc,
7912 IdentifierInfo *SuperName,
7913 SourceLocation SuperLoc,
7914 ArrayRef<ParsedType> SuperTypeArgs,
7915 SourceRange SuperTypeArgsRange);
7916
7917 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
7918 SmallVectorImpl<SourceLocation> &ProtocolLocs,
7919 IdentifierInfo *SuperName,
7920 SourceLocation SuperLoc);
7921
7922 Decl *ActOnCompatibilityAlias(
7923 SourceLocation AtCompatibilityAliasLoc,
7924 IdentifierInfo *AliasName, SourceLocation AliasLocation,
7925 IdentifierInfo *ClassName, SourceLocation ClassLocation);
7926
7927 bool CheckForwardProtocolDeclarationForCircularDependency(
7928 IdentifierInfo *PName,
7929 SourceLocation &PLoc, SourceLocation PrevLoc,
7930 const ObjCList<ObjCProtocolDecl> &PList);
7931
7932 Decl *ActOnStartProtocolInterface(
7933 SourceLocation AtProtoInterfaceLoc,
7934 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
7935 Decl * const *ProtoRefNames, unsigned NumProtoRefs,
7936 const SourceLocation *ProtoLocs,
7937 SourceLocation EndProtoLoc,
7938 AttributeList *AttrList);
7939
7940 Decl *ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
7941 IdentifierInfo *ClassName,
7942 SourceLocation ClassLoc,
7943 ObjCTypeParamList *typeParamList,
7944 IdentifierInfo *CategoryName,
7945 SourceLocation CategoryLoc,
7946 Decl * const *ProtoRefs,
7947 unsigned NumProtoRefs,
7948 const SourceLocation *ProtoLocs,
7949 SourceLocation EndProtoLoc,
7950 AttributeList *AttrList);
7951
7952 Decl *ActOnStartClassImplementation(
7953 SourceLocation AtClassImplLoc,
7954 IdentifierInfo *ClassName, SourceLocation ClassLoc,
7955 IdentifierInfo *SuperClassname,
7956 SourceLocation SuperClassLoc);
7957
7958 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
7959 IdentifierInfo *ClassName,
7960 SourceLocation ClassLoc,
7961 IdentifierInfo *CatName,
7962 SourceLocation CatLoc);
7963
7964 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
7965 ArrayRef<Decl *> Decls);
7966
7967 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
7968 IdentifierInfo **IdentList,
7969 SourceLocation *IdentLocs,
7970 ArrayRef<ObjCTypeParamList *> TypeParamLists,
7971 unsigned NumElts);
7972
7973 DeclGroupPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
7974 ArrayRef<IdentifierLocPair> IdentList,
7975 AttributeList *attrList);
7976
7977 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
7978 ArrayRef<IdentifierLocPair> ProtocolId,
7979 SmallVectorImpl<Decl *> &Protocols);
7980
7981 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
7982 SourceLocation ProtocolLoc,
7983 IdentifierInfo *TypeArgId,
7984 SourceLocation TypeArgLoc,
7985 bool SelectProtocolFirst = false);
7986
7987 /// Given a list of identifiers (and their locations), resolve the
7988 /// names to either Objective-C protocol qualifiers or type
7989 /// arguments, as appropriate.
7990 void actOnObjCTypeArgsOrProtocolQualifiers(
7991 Scope *S,
7992 ParsedType baseType,
7993 SourceLocation lAngleLoc,
7994 ArrayRef<IdentifierInfo *> identifiers,
7995 ArrayRef<SourceLocation> identifierLocs,
7996 SourceLocation rAngleLoc,
7997 SourceLocation &typeArgsLAngleLoc,
7998 SmallVectorImpl<ParsedType> &typeArgs,
7999 SourceLocation &typeArgsRAngleLoc,
8000 SourceLocation &protocolLAngleLoc,
8001 SmallVectorImpl<Decl *> &protocols,
8002 SourceLocation &protocolRAngleLoc,
8003 bool warnOnIncompleteProtocols);
8004
8005 /// Build a an Objective-C protocol-qualified 'id' type where no
8006 /// base type was specified.
8007 TypeResult actOnObjCProtocolQualifierType(
8008 SourceLocation lAngleLoc,
8009 ArrayRef<Decl *> protocols,
8010 ArrayRef<SourceLocation> protocolLocs,
8011 SourceLocation rAngleLoc);
8012
8013 /// Build a specialized and/or protocol-qualified Objective-C type.
8014 TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
8015 Scope *S,
8016 SourceLocation Loc,
8017 ParsedType BaseType,
8018 SourceLocation TypeArgsLAngleLoc,
8019 ArrayRef<ParsedType> TypeArgs,
8020 SourceLocation TypeArgsRAngleLoc,
8021 SourceLocation ProtocolLAngleLoc,
8022 ArrayRef<Decl *> Protocols,
8023 ArrayRef<SourceLocation> ProtocolLocs,
8024 SourceLocation ProtocolRAngleLoc);
8025
8026 /// Build an Objective-C type parameter type.
8027 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
8028 SourceLocation ProtocolLAngleLoc,
8029 ArrayRef<ObjCProtocolDecl *> Protocols,
8030 ArrayRef<SourceLocation> ProtocolLocs,
8031 SourceLocation ProtocolRAngleLoc,
8032 bool FailOnError = false);
8033
8034 /// Build an Objective-C object pointer type.
8035 QualType BuildObjCObjectType(QualType BaseType,
8036 SourceLocation Loc,
8037 SourceLocation TypeArgsLAngleLoc,
8038 ArrayRef<TypeSourceInfo *> TypeArgs,
8039 SourceLocation TypeArgsRAngleLoc,
8040 SourceLocation ProtocolLAngleLoc,
8041 ArrayRef<ObjCProtocolDecl *> Protocols,
8042 ArrayRef<SourceLocation> ProtocolLocs,
8043 SourceLocation ProtocolRAngleLoc,
8044 bool FailOnError = false);
8045
8046 /// Check the application of the Objective-C '__kindof' qualifier to
8047 /// the given type.
8048 bool checkObjCKindOfType(QualType &type, SourceLocation loc);
8049
8050 /// Ensure attributes are consistent with type.
8051 /// \param [in, out] Attributes The attributes to check; they will
8052 /// be modified to be consistent with \p PropertyTy.
8053 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
8054 SourceLocation Loc,
8055 unsigned &Attributes,
8056 bool propertyInPrimaryClass);
8057
8058 /// Process the specified property declaration and create decls for the
8059 /// setters and getters as needed.
8060 /// \param property The property declaration being processed
8061 void ProcessPropertyDecl(ObjCPropertyDecl *property);
8062
8063
8064 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
8065 ObjCPropertyDecl *SuperProperty,
8066 const IdentifierInfo *Name,
8067 bool OverridingProtocolProperty);
8068
8069 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
8070 ObjCInterfaceDecl *ID);
8071
8072 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,
8073 ArrayRef<Decl *> allMethods = None,
8074 ArrayRef<DeclGroupPtrTy> allTUVars = None);
8075
8076 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
8077 SourceLocation LParenLoc,
8078 FieldDeclarator &FD, ObjCDeclSpec &ODS,
8079 Selector GetterSel, Selector SetterSel,
8080 tok::ObjCKeywordKind MethodImplKind,
8081 DeclContext *lexicalDC = nullptr);
8082
8083 Decl *ActOnPropertyImplDecl(Scope *S,
8084 SourceLocation AtLoc,
8085 SourceLocation PropertyLoc,
8086 bool ImplKind,
8087 IdentifierInfo *PropertyId,
8088 IdentifierInfo *PropertyIvar,
8089 SourceLocation PropertyIvarLoc,
8090 ObjCPropertyQueryKind QueryKind);
8091
8092 enum ObjCSpecialMethodKind {
8093 OSMK_None,
8094 OSMK_Alloc,
8095 OSMK_New,
8096 OSMK_Copy,
8097 OSMK_RetainingInit,
8098 OSMK_NonRetainingInit
8099 };
8100
8101 struct ObjCArgInfo {
8102 IdentifierInfo *Name;
8103 SourceLocation NameLoc;
8104 // The Type is null if no type was specified, and the DeclSpec is invalid
8105 // in this case.
8106 ParsedType Type;
8107 ObjCDeclSpec DeclSpec;
8108
8109 /// ArgAttrs - Attribute list for this argument.
8110 AttributeList *ArgAttrs;
8111 };
8112
8113 Decl *ActOnMethodDeclaration(
8114 Scope *S,
8115 SourceLocation BeginLoc, // location of the + or -.
8116 SourceLocation EndLoc, // location of the ; or {.
8117 tok::TokenKind MethodType,
8118 ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
8119 ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
8120 // optional arguments. The number of types/arguments is obtained
8121 // from the Sel.getNumArgs().
8122 ObjCArgInfo *ArgInfo,
8123 DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
8124 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
8125 bool isVariadic, bool MethodDefinition);
8126
8127 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
8128 const ObjCObjectPointerType *OPT,
8129 bool IsInstance);
8130 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
8131 bool IsInstance);
8132
8133 bool CheckARCMethodDecl(ObjCMethodDecl *method);
8134 bool inferObjCARCLifetime(ValueDecl *decl);
8135
8136 ExprResult
8137 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
8138 Expr *BaseExpr,
8139 SourceLocation OpLoc,
8140 DeclarationName MemberName,
8141 SourceLocation MemberLoc,
8142 SourceLocation SuperLoc, QualType SuperType,
8143 bool Super);
8144
8145 ExprResult
8146 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
8147 IdentifierInfo &propertyName,
8148 SourceLocation receiverNameLoc,
8149 SourceLocation propertyNameLoc);
8150
8151 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
8152
8153 /// \brief Describes the kind of message expression indicated by a message
8154 /// send that starts with an identifier.
8155 enum ObjCMessageKind {
8156 /// \brief The message is sent to 'super'.
8157 ObjCSuperMessage,
8158 /// \brief The message is an instance message.
8159 ObjCInstanceMessage,
8160 /// \brief The message is a class message, and the identifier is a type
8161 /// name.
8162 ObjCClassMessage
8163 };
8164
8165 ObjCMessageKind getObjCMessageKind(Scope *S,
8166 IdentifierInfo *Name,
8167 SourceLocation NameLoc,
8168 bool IsSuper,
8169 bool HasTrailingDot,
8170 ParsedType &ReceiverType);
8171
8172 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
8173 Selector Sel,
8174 SourceLocation LBracLoc,
8175 ArrayRef<SourceLocation> SelectorLocs,
8176 SourceLocation RBracLoc,
8177 MultiExprArg Args);
8178
8179 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
8180 QualType ReceiverType,
8181 SourceLocation SuperLoc,
8182 Selector Sel,
8183 ObjCMethodDecl *Method,
8184 SourceLocation LBracLoc,
8185 ArrayRef<SourceLocation> SelectorLocs,
8186 SourceLocation RBracLoc,
8187 MultiExprArg Args,
8188 bool isImplicit = false);
8189
8190 ExprResult BuildClassMessageImplicit(QualType ReceiverType,
8191 bool isSuperReceiver,
8192 SourceLocation Loc,
8193 Selector Sel,
8194 ObjCMethodDecl *Method,
8195 MultiExprArg Args);
8196
8197 ExprResult ActOnClassMessage(Scope *S,
8198 ParsedType Receiver,
8199 Selector Sel,
8200 SourceLocation LBracLoc,
8201 ArrayRef<SourceLocation> SelectorLocs,
8202 SourceLocation RBracLoc,
8203 MultiExprArg Args);
8204
8205 ExprResult BuildInstanceMessage(Expr *Receiver,
8206 QualType ReceiverType,
8207 SourceLocation SuperLoc,
8208 Selector Sel,
8209 ObjCMethodDecl *Method,
8210 SourceLocation LBracLoc,
8211 ArrayRef<SourceLocation> SelectorLocs,
8212 SourceLocation RBracLoc,
8213 MultiExprArg Args,
8214 bool isImplicit = false);
8215
8216 ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
8217 QualType ReceiverType,
8218 SourceLocation Loc,
8219 Selector Sel,
8220 ObjCMethodDecl *Method,
8221 MultiExprArg Args);
8222
8223 ExprResult ActOnInstanceMessage(Scope *S,
8224 Expr *Receiver,
8225 Selector Sel,
8226 SourceLocation LBracLoc,
8227 ArrayRef<SourceLocation> SelectorLocs,
8228 SourceLocation RBracLoc,
8229 MultiExprArg Args);
8230
8231 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
8232 ObjCBridgeCastKind Kind,
8233 SourceLocation BridgeKeywordLoc,
8234 TypeSourceInfo *TSInfo,
8235 Expr *SubExpr);
8236
8237 ExprResult ActOnObjCBridgedCast(Scope *S,
8238 SourceLocation LParenLoc,
8239 ObjCBridgeCastKind Kind,
8240 SourceLocation BridgeKeywordLoc,
8241 ParsedType Type,
8242 SourceLocation RParenLoc,
8243 Expr *SubExpr);
8244
8245 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
8246
8247 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
8248
8249 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
8250 CastKind &Kind);
8251
8252 bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
8253 QualType DestType, QualType SrcType,
8254 ObjCInterfaceDecl *&RelatedClass,
8255 ObjCMethodDecl *&ClassMethod,
8256 ObjCMethodDecl *&InstanceMethod,
8257 TypedefNameDecl *&TDNDecl,
8258 bool CfToNs, bool Diagnose = true);
8259
8260 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
8261 QualType DestType, QualType SrcType,
8262 Expr *&SrcExpr, bool Diagnose = true);
8263
8264 bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr,
8265 bool Diagnose = true);
8266
8267 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
8268
8269 /// \brief Check whether the given new method is a valid override of the
8270 /// given overridden method, and set any properties that should be inherited.
8271 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
8272 const ObjCMethodDecl *Overridden);
8273
8274 /// \brief Describes the compatibility of a result type with its method.
8275 enum ResultTypeCompatibilityKind {
8276 RTC_Compatible,
8277 RTC_Incompatible,
8278 RTC_Unknown
8279 };
8280
8281 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
8282 ObjCInterfaceDecl *CurrentClass,
8283 ResultTypeCompatibilityKind RTC);
8284
8285 enum PragmaOptionsAlignKind {
8286 POAK_Native, // #pragma options align=native
8287 POAK_Natural, // #pragma options align=natural
8288 POAK_Packed, // #pragma options align=packed
8289 POAK_Power, // #pragma options align=power
8290 POAK_Mac68k, // #pragma options align=mac68k
8291 POAK_Reset // #pragma options align=reset
8292 };
8293
8294 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section
8295 void ActOnPragmaClangSection(SourceLocation PragmaLoc,
8296 PragmaClangSectionAction Action,
8297 PragmaClangSectionKind SecKind, StringRef SecName);
8298
8299 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
8300 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
8301 SourceLocation PragmaLoc);
8302
8303 /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
8304 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
8305 StringRef SlotLabel, Expr *Alignment);
8306
8307 enum class PragmaPackDiagnoseKind {
8308 NonDefaultStateAtInclude,
8309 ChangedStateAtExit
8310 };
8311
8312 void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
8313 SourceLocation IncludeLoc);
8314 void DiagnoseUnterminatedPragmaPack();
8315
8316 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off].
8317 void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
8318
8319 /// ActOnPragmaMSComment - Called on well formed
8320 /// \#pragma comment(kind, "arg").
8321 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
8322 StringRef Arg);
8323
8324 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
8325 /// pointers_to_members(representation method[, general purpose
8326 /// representation]).
8327 void ActOnPragmaMSPointersToMembers(
8328 LangOptions::PragmaMSPointersToMembersKind Kind,
8329 SourceLocation PragmaLoc);
8330
8331 /// \brief Called on well formed \#pragma vtordisp().
8332 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
8333 SourceLocation PragmaLoc,
8334 MSVtorDispAttr::Mode Value);
8335
8336 enum PragmaSectionKind {
8337 PSK_DataSeg,
8338 PSK_BSSSeg,
8339 PSK_ConstSeg,
8340 PSK_CodeSeg,
8341 };
8342
8343 bool UnifySection(StringRef SectionName,
8344 int SectionFlags,
8345 DeclaratorDecl *TheDecl);
8346 bool UnifySection(StringRef SectionName,
8347 int SectionFlags,
8348 SourceLocation PragmaSectionLocation);
8349
8350 /// \brief Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
8351 void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
8352 PragmaMsStackAction Action,
8353 llvm::StringRef StackSlotLabel,
8354 StringLiteral *SegmentName,
8355 llvm::StringRef PragmaName);
8356
8357 /// \brief Called on well formed \#pragma section().
8358 void ActOnPragmaMSSection(SourceLocation PragmaLocation,
8359 int SectionFlags, StringLiteral *SegmentName);
8360
8361 /// \brief Called on well-formed \#pragma init_seg().
8362 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
8363 StringLiteral *SegmentName);
8364
8365 /// \brief Called on #pragma clang __debug dump II
8366 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
8367
8368 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
8369 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
8370 StringRef Value);
8371
8372 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
8373 void ActOnPragmaUnused(const Token &Identifier,
8374 Scope *curScope,
8375 SourceLocation PragmaLoc);
8376
8377 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
8378 void ActOnPragmaVisibility(const IdentifierInfo* VisType,
8379 SourceLocation PragmaLoc);
8380
8381 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
8382 SourceLocation Loc);
8383 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
8384
8385 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
8386 void ActOnPragmaWeakID(IdentifierInfo* WeakName,
8387 SourceLocation PragmaLoc,
8388 SourceLocation WeakNameLoc);
8389
8390 /// ActOnPragmaRedefineExtname - Called on well formed
8391 /// \#pragma redefine_extname oldname newname.
8392 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
8393 IdentifierInfo* AliasName,
8394 SourceLocation PragmaLoc,
8395 SourceLocation WeakNameLoc,
8396 SourceLocation AliasNameLoc);
8397
8398 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
8399 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
8400 IdentifierInfo* AliasName,
8401 SourceLocation PragmaLoc,
8402 SourceLocation WeakNameLoc,
8403 SourceLocation AliasNameLoc);
8404
8405 /// ActOnPragmaFPContract - Called on well formed
8406 /// \#pragma {STDC,OPENCL} FP_CONTRACT and
8407 /// \#pragma clang fp contract
8408 void ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC);
8409
8410 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
8411 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
8412 void AddAlignmentAttributesForRecord(RecordDecl *RD);
8413
8414 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
8415 void AddMsStructLayoutForRecord(RecordDecl *RD);
8416
8417 /// FreePackedContext - Deallocate and null out PackContext.
8418 void FreePackedContext();
8419
8420 /// PushNamespaceVisibilityAttr - Note that we've entered a
8421 /// namespace with a visibility attribute.
8422 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
8423 SourceLocation Loc);
8424
8425 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
8426 /// add an appropriate visibility attribute.
8427 void AddPushedVisibilityAttribute(Decl *RD);
8428
8429 /// PopPragmaVisibility - Pop the top element of the visibility stack; used
8430 /// for '\#pragma GCC visibility' and visibility attributes on namespaces.
8431 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
8432
8433 /// FreeVisContext - Deallocate and null out VisContext.
8434 void FreeVisContext();
8435
8436 /// AddCFAuditedAttribute - Check whether we're currently within
8437 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
8438 /// the appropriate attribute.
8439 void AddCFAuditedAttribute(Decl *D);
8440
8441 /// \brief Called on well-formed '\#pragma clang attribute push'.
8442 void ActOnPragmaAttributePush(AttributeList &Attribute,
8443 SourceLocation PragmaLoc,
8444 attr::ParsedSubjectMatchRuleSet Rules);
8445
8446 /// \brief Called on well-formed '\#pragma clang attribute pop'.
8447 void ActOnPragmaAttributePop(SourceLocation PragmaLoc);
8448
8449 /// \brief Adds the attributes that have been specified using the
8450 /// '\#pragma clang attribute push' directives to the given declaration.
8451 void AddPragmaAttributes(Scope *S, Decl *D);
8452
8453 void DiagnoseUnterminatedPragmaAttribute();
8454
8455 /// \brief Called on well formed \#pragma clang optimize.
8456 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
8457
8458 /// \brief Get the location for the currently active "\#pragma clang optimize
8459 /// off". If this location is invalid, then the state of the pragma is "on".
8460 SourceLocation getOptimizeOffPragmaLocation() const {
8461 return OptimizeOffPragmaLocation;
8462 }
8463
8464 /// \brief Only called on function definitions; if there is a pragma in scope
8465 /// with the effect of a range-based optnone, consider marking the function
8466 /// with attribute optnone.
8467 void AddRangeBasedOptnone(FunctionDecl *FD);
8468
8469 /// \brief Adds the 'optnone' attribute to the function declaration if there
8470 /// are no conflicts; Loc represents the location causing the 'optnone'
8471 /// attribute to be added (usually because of a pragma).
8472 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
8473
8474 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
8475 void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
8476 unsigned SpellingListIndex, bool IsPackExpansion);
8477 void AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *T,
8478 unsigned SpellingListIndex, bool IsPackExpansion);
8479
8480 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
8481 /// declaration.
8482 void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE,
8483 unsigned SpellingListIndex);
8484
8485 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
8486 /// declaration.
8487 void AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
8488 unsigned SpellingListIndex);
8489
8490 /// AddAlignValueAttr - Adds an align_value attribute to a particular
8491 /// declaration.
8492 void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
8493 unsigned SpellingListIndex);
8494
8495 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
8496 /// declaration.
8497 void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
8498 Expr *MinBlocks, unsigned SpellingListIndex);
8499
8500 /// AddModeAttr - Adds a mode attribute to a particular declaration.
8501 void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
8502 unsigned SpellingListIndex, bool InInstantiation = false);
8503
8504 void AddParameterABIAttr(SourceRange AttrRange, Decl *D,
8505 ParameterABI ABI, unsigned SpellingListIndex);
8506
8507 void AddNSConsumedAttr(SourceRange AttrRange, Decl *D,
8508 unsigned SpellingListIndex, bool isNSConsumed,
8509 bool isTemplateInstantiation);
8510
8511 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
8512
8513 //===--------------------------------------------------------------------===//
8514 // C++ Coroutines TS
8515 //
8516 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
8517 StringRef Keyword);
8518 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
8519 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
8520 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
8521
8522 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
8523 bool IsImplicit = false);
8524 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
8525 UnresolvedLookupExpr* Lookup);
8526 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
8527 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
8528 bool IsImplicit = false);
8529 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
8530 bool buildCoroutineParameterMoves(SourceLocation Loc);
8531 VarDecl *buildCoroutinePromise(SourceLocation Loc);
8532 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
8533
8534 //===--------------------------------------------------------------------===//
8535 // OpenCL extensions.
8536 //
8537private:
8538 std::string CurrOpenCLExtension;
8539 /// Extensions required by an OpenCL type.
8540 llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;
8541 /// Extensions required by an OpenCL declaration.
8542 llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap;
8543public:
8544 llvm::StringRef getCurrentOpenCLExtension() const {
8545 return CurrOpenCLExtension;
8546 }
8547 void setCurrentOpenCLExtension(llvm::StringRef Ext) {
8548 CurrOpenCLExtension = Ext;
8549 }
8550
8551 /// \brief Set OpenCL extensions for a type which can only be used when these
8552 /// OpenCL extensions are enabled. If \p Exts is empty, do nothing.
8553 /// \param Exts A space separated list of OpenCL extensions.
8554 void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts);
8555
8556 /// \brief Set OpenCL extensions for a declaration which can only be
8557 /// used when these OpenCL extensions are enabled. If \p Exts is empty, do
8558 /// nothing.
8559 /// \param Exts A space separated list of OpenCL extensions.
8560 void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts);
8561
8562 /// \brief Set current OpenCL extensions for a type which can only be used
8563 /// when these OpenCL extensions are enabled. If current OpenCL extension is
8564 /// empty, do nothing.
8565 void setCurrentOpenCLExtensionForType(QualType T);
8566
8567 /// \brief Set current OpenCL extensions for a declaration which
8568 /// can only be used when these OpenCL extensions are enabled. If current
8569 /// OpenCL extension is empty, do nothing.
8570 void setCurrentOpenCLExtensionForDecl(Decl *FD);
8571
8572 bool isOpenCLDisabledDecl(Decl *FD);
8573
8574 /// \brief Check if type \p T corresponding to declaration specifier \p DS
8575 /// is disabled due to required OpenCL extensions being disabled. If so,
8576 /// emit diagnostics.
8577 /// \return true if type is disabled.
8578 bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T);
8579
8580 /// \brief Check if declaration \p D used by expression \p E
8581 /// is disabled due to required OpenCL extensions being disabled. If so,
8582 /// emit diagnostics.
8583 /// \return true if type is disabled.
8584 bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
8585
8586 //===--------------------------------------------------------------------===//
8587 // OpenMP directives and clauses.
8588 //
8589private:
8590 void *VarDataSharingAttributesStack;
8591 /// Set to true inside '#pragma omp declare target' region.
8592 bool IsInOpenMPDeclareTargetContext = false;
8593 /// \brief Initialization of data-sharing attributes stack.
8594 void InitDataSharingAttributesStack();
8595 void DestroyDataSharingAttributesStack();
8596 ExprResult
8597 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
8598 bool StrictlyPositive = true);
8599 /// Returns OpenMP nesting level for current directive.
8600 unsigned getOpenMPNestingLevel() const;
8601
8602 /// Adjusts the function scopes index for the target-based regions.
8603 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
8604 unsigned Level) const;
8605
8606 /// Push new OpenMP function region for non-capturing function.
8607 void pushOpenMPFunctionRegion();
8608
8609 /// Pop OpenMP function region for non-capturing function.
8610 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
8611
8612 /// Checks if a type or a declaration is disabled due to the owning extension
8613 /// being disabled, and emits diagnostic messages if it is disabled.
8614 /// \param D type or declaration to be checked.
8615 /// \param DiagLoc source location for the diagnostic message.
8616 /// \param DiagInfo information to be emitted for the diagnostic message.
8617 /// \param SrcRange source range of the declaration.
8618 /// \param Map maps type or declaration to the extensions.
8619 /// \param Selector selects diagnostic message: 0 for type and 1 for
8620 /// declaration.
8621 /// \return true if the type or declaration is disabled.
8622 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
8623 bool checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo,
8624 MapT &Map, unsigned Selector = 0,
8625 SourceRange SrcRange = SourceRange());
8626
8627public:
8628 /// \brief Return true if the provided declaration \a VD should be captured by
8629 /// reference.
8630 /// \param Level Relative level of nested OpenMP construct for that the check
8631 /// is performed.
8632 bool IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level);
8633
8634 /// \brief Check if the specified variable is used in one of the private
8635 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
8636 /// constructs.
8637 VarDecl *IsOpenMPCapturedDecl(ValueDecl *D);
8638 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
8639 ExprObjectKind OK, SourceLocation Loc);
8640
8641 /// \brief Check if the specified variable is used in 'private' clause.
8642 /// \param Level Relative level of nested OpenMP construct for that the check
8643 /// is performed.
8644 bool isOpenMPPrivateDecl(ValueDecl *D, unsigned Level);
8645
8646 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
8647 /// for \p FD based on DSA for the provided corresponding captured declaration
8648 /// \p D.
8649 void setOpenMPCaptureKind(FieldDecl *FD, ValueDecl *D, unsigned Level);
8650
8651 /// \brief Check if the specified variable is captured by 'target' directive.
8652 /// \param Level Relative level of nested OpenMP construct for that the check
8653 /// is performed.
8654 bool isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level);
8655
8656 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
8657 Expr *Op);
8658 /// \brief Called on start of new data sharing attribute block.
8659 void StartOpenMPDSABlock(OpenMPDirectiveKind K,
8660 const DeclarationNameInfo &DirName, Scope *CurScope,
8661 SourceLocation Loc);
8662 /// \brief Start analysis of clauses.
8663 void StartOpenMPClause(OpenMPClauseKind K);
8664 /// \brief End analysis of clauses.
8665 void EndOpenMPClause();
8666 /// \brief Called on end of data sharing attribute block.
8667 void EndOpenMPDSABlock(Stmt *CurDirective);
8668
8669 /// \brief Check if the current region is an OpenMP loop region and if it is,
8670 /// mark loop control variable, used in \p Init for loop initialization, as
8671 /// private by default.
8672 /// \param Init First part of the for loop.
8673 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
8674
8675 // OpenMP directives and clauses.
8676 /// \brief Called on correct id-expression from the '#pragma omp
8677 /// threadprivate'.
8678 ExprResult ActOnOpenMPIdExpression(Scope *CurScope,
8679 CXXScopeSpec &ScopeSpec,
8680 const DeclarationNameInfo &Id);
8681 /// \brief Called on well-formed '#pragma omp threadprivate'.
8682 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
8683 SourceLocation Loc,
8684 ArrayRef<Expr *> VarList);
8685 /// \brief Builds a new OpenMPThreadPrivateDecl and checks its correctness.
8686 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(
8687 SourceLocation Loc,
8688 ArrayRef<Expr *> VarList);
8689 /// \brief Check if the specified type is allowed to be used in 'omp declare
8690 /// reduction' construct.
8691 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
8692 TypeResult ParsedType);
8693 /// \brief Called on start of '#pragma omp declare reduction'.
8694 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
8695 Scope *S, DeclContext *DC, DeclarationName Name,
8696 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
8697 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);
8698 /// \brief Initialize declare reduction construct initializer.
8699 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);
8700 /// \brief Finish current declare reduction construct initializer.
8701 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
8702 /// \brief Initialize declare reduction construct initializer.
8703 /// \return omp_priv variable.
8704 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);
8705 /// \brief Finish current declare reduction construct initializer.
8706 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
8707 VarDecl *OmpPrivParm);
8708 /// \brief Called at the end of '#pragma omp declare reduction'.
8709 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
8710 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);
8711
8712 /// Called on the start of target region i.e. '#pragma omp declare target'.
8713 bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc);
8714 /// Called at the end of target region i.e. '#pragme omp end declare target'.
8715 void ActOnFinishOpenMPDeclareTargetDirective();
8716 /// Called on correct id-expression from the '#pragma omp declare target'.
8717 void ActOnOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,
8718 const DeclarationNameInfo &Id,
8719 OMPDeclareTargetDeclAttr::MapTypeTy MT,
8720 NamedDeclSetType &SameDirectiveDecls);
8721 /// Check declaration inside target region.
8722 void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
8723 SourceLocation IdLoc = SourceLocation());
8724 /// Return true inside OpenMP declare target region.
8725 bool isInOpenMPDeclareTargetContext() const {
8726 return IsInOpenMPDeclareTargetContext;
8727 }
8728 /// Return true inside OpenMP target region.
8729 bool isInOpenMPTargetExecutionDirective() const;
8730 /// Return true if (un)supported features for the current target should be
8731 /// diagnosed if OpenMP (offloading) is enabled.
8732 bool shouldDiagnoseTargetSupportFromOpenMP() const {
8733 return !getLangOpts().OpenMPIsDevice || isInOpenMPDeclareTargetContext() ||
8734 isInOpenMPTargetExecutionDirective();
8735 }
8736
8737 /// Return the number of captured regions created for an OpenMP directive.
8738 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
8739
8740 /// \brief Initialization of captured region for OpenMP region.
8741 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
8742 /// \brief End of OpenMP region.
8743 ///
8744 /// \param S Statement associated with the current OpenMP region.
8745 /// \param Clauses List of clauses for the current OpenMP region.
8746 ///
8747 /// \returns Statement for finished OpenMP region.
8748 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
8749 StmtResult ActOnOpenMPExecutableDirective(
8750 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
8751 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
8752 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
8753 /// \brief Called on well-formed '\#pragma omp parallel' after parsing
8754 /// of the associated statement.
8755 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
8756 Stmt *AStmt,
8757 SourceLocation StartLoc,
8758 SourceLocation EndLoc);
8759 /// \brief Called on well-formed '\#pragma omp simd' after parsing
8760 /// of the associated statement.
8761 StmtResult ActOnOpenMPSimdDirective(
8762 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8763 SourceLocation EndLoc,
8764 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8765 /// \brief Called on well-formed '\#pragma omp for' after parsing
8766 /// of the associated statement.
8767 StmtResult ActOnOpenMPForDirective(
8768 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8769 SourceLocation EndLoc,
8770 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8771 /// \brief Called on well-formed '\#pragma omp for simd' after parsing
8772 /// of the associated statement.
8773 StmtResult ActOnOpenMPForSimdDirective(
8774 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8775 SourceLocation EndLoc,
8776 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8777 /// \brief Called on well-formed '\#pragma omp sections' after parsing
8778 /// of the associated statement.
8779 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
8780 Stmt *AStmt, SourceLocation StartLoc,
8781 SourceLocation EndLoc);
8782 /// \brief Called on well-formed '\#pragma omp section' after parsing of the
8783 /// associated statement.
8784 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
8785 SourceLocation EndLoc);
8786 /// \brief Called on well-formed '\#pragma omp single' after parsing of the
8787 /// associated statement.
8788 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
8789 Stmt *AStmt, SourceLocation StartLoc,
8790 SourceLocation EndLoc);
8791 /// \brief Called on well-formed '\#pragma omp master' after parsing of the
8792 /// associated statement.
8793 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
8794 SourceLocation EndLoc);
8795 /// \brief Called on well-formed '\#pragma omp critical' after parsing of the
8796 /// associated statement.
8797 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
8798 ArrayRef<OMPClause *> Clauses,
8799 Stmt *AStmt, SourceLocation StartLoc,
8800 SourceLocation EndLoc);
8801 /// \brief Called on well-formed '\#pragma omp parallel for' after parsing
8802 /// of the associated statement.
8803 StmtResult ActOnOpenMPParallelForDirective(
8804 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8805 SourceLocation EndLoc,
8806 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8807 /// \brief Called on well-formed '\#pragma omp parallel for simd' after
8808 /// parsing of the associated statement.
8809 StmtResult ActOnOpenMPParallelForSimdDirective(
8810 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8811 SourceLocation EndLoc,
8812 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8813 /// \brief Called on well-formed '\#pragma omp parallel sections' after
8814 /// parsing of the associated statement.
8815 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
8816 Stmt *AStmt,
8817 SourceLocation StartLoc,
8818 SourceLocation EndLoc);
8819 /// \brief Called on well-formed '\#pragma omp task' after parsing of the
8820 /// associated statement.
8821 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
8822 Stmt *AStmt, SourceLocation StartLoc,
8823 SourceLocation EndLoc);
8824 /// \brief Called on well-formed '\#pragma omp taskyield'.
8825 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
8826 SourceLocation EndLoc);
8827 /// \brief Called on well-formed '\#pragma omp barrier'.
8828 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
8829 SourceLocation EndLoc);
8830 /// \brief Called on well-formed '\#pragma omp taskwait'.
8831 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
8832 SourceLocation EndLoc);
8833 /// \brief Called on well-formed '\#pragma omp taskgroup'.
8834 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
8835 Stmt *AStmt, SourceLocation StartLoc,
8836 SourceLocation EndLoc);
8837 /// \brief Called on well-formed '\#pragma omp flush'.
8838 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
8839 SourceLocation StartLoc,
8840 SourceLocation EndLoc);
8841 /// \brief Called on well-formed '\#pragma omp ordered' after parsing of the
8842 /// associated statement.
8843 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
8844 Stmt *AStmt, SourceLocation StartLoc,
8845 SourceLocation EndLoc);
8846 /// \brief Called on well-formed '\#pragma omp atomic' after parsing of the
8847 /// associated statement.
8848 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
8849 Stmt *AStmt, SourceLocation StartLoc,
8850 SourceLocation EndLoc);
8851 /// \brief Called on well-formed '\#pragma omp target' after parsing of the
8852 /// associated statement.
8853 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
8854 Stmt *AStmt, SourceLocation StartLoc,
8855 SourceLocation EndLoc);
8856 /// \brief Called on well-formed '\#pragma omp target data' after parsing of
8857 /// the associated statement.
8858 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
8859 Stmt *AStmt, SourceLocation StartLoc,
8860 SourceLocation EndLoc);
8861 /// \brief Called on well-formed '\#pragma omp target enter data' after
8862 /// parsing of the associated statement.
8863 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
8864 SourceLocation StartLoc,
8865 SourceLocation EndLoc,
8866 Stmt *AStmt);
8867 /// \brief Called on well-formed '\#pragma omp target exit data' after
8868 /// parsing of the associated statement.
8869 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
8870 SourceLocation StartLoc,
8871 SourceLocation EndLoc,
8872 Stmt *AStmt);
8873 /// \brief Called on well-formed '\#pragma omp target parallel' after
8874 /// parsing of the associated statement.
8875 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
8876 Stmt *AStmt,
8877 SourceLocation StartLoc,
8878 SourceLocation EndLoc);
8879 /// \brief Called on well-formed '\#pragma omp target parallel for' after
8880 /// parsing of the associated statement.
8881 StmtResult ActOnOpenMPTargetParallelForDirective(
8882 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8883 SourceLocation EndLoc,
8884 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8885 /// \brief Called on well-formed '\#pragma omp teams' after parsing of the
8886 /// associated statement.
8887 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
8888 Stmt *AStmt, SourceLocation StartLoc,
8889 SourceLocation EndLoc);
8890 /// \brief Called on well-formed '\#pragma omp cancellation point'.
8891 StmtResult
8892 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
8893 SourceLocation EndLoc,
8894 OpenMPDirectiveKind CancelRegion);
8895 /// \brief Called on well-formed '\#pragma omp cancel'.
8896 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
8897 SourceLocation StartLoc,
8898 SourceLocation EndLoc,
8899 OpenMPDirectiveKind CancelRegion);
8900 /// \brief Called on well-formed '\#pragma omp taskloop' after parsing of the
8901 /// associated statement.
8902 StmtResult ActOnOpenMPTaskLoopDirective(
8903 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8904 SourceLocation EndLoc,
8905 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8906 /// \brief Called on well-formed '\#pragma omp taskloop simd' after parsing of
8907 /// the associated statement.
8908 StmtResult ActOnOpenMPTaskLoopSimdDirective(
8909 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8910 SourceLocation EndLoc,
8911 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8912 /// \brief Called on well-formed '\#pragma omp distribute' after parsing
8913 /// of the associated statement.
8914 StmtResult ActOnOpenMPDistributeDirective(
8915 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8916 SourceLocation EndLoc,
8917 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8918 /// \brief Called on well-formed '\#pragma omp target update'.
8919 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
8920 SourceLocation StartLoc,
8921 SourceLocation EndLoc,
8922 Stmt *AStmt);
8923 /// \brief Called on well-formed '\#pragma omp distribute parallel for' after
8924 /// parsing of the associated statement.
8925 StmtResult ActOnOpenMPDistributeParallelForDirective(
8926 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8927 SourceLocation EndLoc,
8928 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8929 /// \brief Called on well-formed '\#pragma omp distribute parallel for simd'
8930 /// after parsing of the associated statement.
8931 StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
8932 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8933 SourceLocation EndLoc,
8934 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8935 /// \brief Called on well-formed '\#pragma omp distribute simd' after
8936 /// parsing of the associated statement.
8937 StmtResult ActOnOpenMPDistributeSimdDirective(
8938 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8939 SourceLocation EndLoc,
8940 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8941 /// \brief Called on well-formed '\#pragma omp target parallel for simd' after
8942 /// parsing of the associated statement.
8943 StmtResult ActOnOpenMPTargetParallelForSimdDirective(
8944 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8945 SourceLocation EndLoc,
8946 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8947 /// \brief Called on well-formed '\#pragma omp target simd' after parsing of
8948 /// the associated statement.
8949 StmtResult ActOnOpenMPTargetSimdDirective(
8950 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8951 SourceLocation EndLoc,
8952 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8953 /// Called on well-formed '\#pragma omp teams distribute' after parsing of
8954 /// the associated statement.
8955 StmtResult ActOnOpenMPTeamsDistributeDirective(
8956 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8957 SourceLocation EndLoc,
8958 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8959 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing
8960 /// of the associated statement.
8961 StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
8962 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8963 SourceLocation EndLoc,
8964 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8965 /// Called on well-formed '\#pragma omp teams distribute parallel for simd'
8966 /// after parsing of the associated statement.
8967 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
8968 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8969 SourceLocation EndLoc,
8970 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8971 /// Called on well-formed '\#pragma omp teams distribute parallel for'
8972 /// after parsing of the associated statement.
8973 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
8974 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8975 SourceLocation EndLoc,
8976 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8977 /// Called on well-formed '\#pragma omp target teams' after parsing of the
8978 /// associated statement.
8979 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
8980 Stmt *AStmt,
8981 SourceLocation StartLoc,
8982 SourceLocation EndLoc);
8983 /// Called on well-formed '\#pragma omp target teams distribute' after parsing
8984 /// of the associated statement.
8985 StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
8986 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8987 SourceLocation EndLoc,
8988 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8989 /// Called on well-formed '\#pragma omp target teams distribute parallel for'
8990 /// after parsing of the associated statement.
8991 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
8992 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8993 SourceLocation EndLoc,
8994 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8995 /// Called on well-formed '\#pragma omp target teams distribute parallel for
8996 /// simd' after parsing of the associated statement.
8997 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
8998 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8999 SourceLocation EndLoc,
9000 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
9001 /// Called on well-formed '\#pragma omp target teams distribute simd' after
9002 /// parsing of the associated statement.
9003 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
9004 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9005 SourceLocation EndLoc,
9006 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
9007
9008 /// Checks correctness of linear modifiers.
9009 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
9010 SourceLocation LinLoc);
9011 /// Checks that the specified declaration matches requirements for the linear
9012 /// decls.
9013 bool CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
9014 OpenMPLinearClauseKind LinKind, QualType Type);
9015
9016 /// \brief Called on well-formed '\#pragma omp declare simd' after parsing of
9017 /// the associated method/function.
9018 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
9019 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
9020 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
9021 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
9022 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
9023
9024 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
9025 Expr *Expr,
9026 SourceLocation StartLoc,
9027 SourceLocation LParenLoc,
9028 SourceLocation EndLoc);
9029 /// \brief Called on well-formed 'if' clause.
9030 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
9031 Expr *Condition, SourceLocation StartLoc,
9032 SourceLocation LParenLoc,
9033 SourceLocation NameModifierLoc,
9034 SourceLocation ColonLoc,
9035 SourceLocation EndLoc);
9036 /// \brief Called on well-formed 'final' clause.
9037 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
9038 SourceLocation LParenLoc,
9039 SourceLocation EndLoc);
9040 /// \brief Called on well-formed 'num_threads' clause.
9041 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
9042 SourceLocation StartLoc,
9043 SourceLocation LParenLoc,
9044 SourceLocation EndLoc);
9045 /// \brief Called on well-formed 'safelen' clause.
9046 OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
9047 SourceLocation StartLoc,
9048 SourceLocation LParenLoc,
9049 SourceLocation EndLoc);
9050 /// \brief Called on well-formed 'simdlen' clause.
9051 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
9052 SourceLocation LParenLoc,
9053 SourceLocation EndLoc);
9054 /// \brief Called on well-formed 'collapse' clause.
9055 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
9056 SourceLocation StartLoc,
9057 SourceLocation LParenLoc,
9058 SourceLocation EndLoc);
9059 /// \brief Called on well-formed 'ordered' clause.
9060 OMPClause *
9061 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
9062 SourceLocation LParenLoc = SourceLocation(),
9063 Expr *NumForLoops = nullptr);
9064 /// \brief Called on well-formed 'grainsize' clause.
9065 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
9066 SourceLocation LParenLoc,
9067 SourceLocation EndLoc);
9068 /// \brief Called on well-formed 'num_tasks' clause.
9069 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
9070 SourceLocation LParenLoc,
9071 SourceLocation EndLoc);
9072 /// \brief Called on well-formed 'hint' clause.
9073 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
9074 SourceLocation LParenLoc,
9075 SourceLocation EndLoc);
9076
9077 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
9078 unsigned Argument,
9079 SourceLocation ArgumentLoc,
9080 SourceLocation StartLoc,
9081 SourceLocation LParenLoc,
9082 SourceLocation EndLoc);
9083 /// \brief Called on well-formed 'default' clause.
9084 OMPClause *ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
9085 SourceLocation KindLoc,
9086 SourceLocation StartLoc,
9087 SourceLocation LParenLoc,
9088 SourceLocation EndLoc);
9089 /// \brief Called on well-formed 'proc_bind' clause.
9090 OMPClause *ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
9091 SourceLocation KindLoc,
9092 SourceLocation StartLoc,
9093 SourceLocation LParenLoc,
9094 SourceLocation EndLoc);
9095
9096 OMPClause *ActOnOpenMPSingleExprWithArgClause(
9097 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
9098 SourceLocation StartLoc, SourceLocation LParenLoc,
9099 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
9100 SourceLocation EndLoc);
9101 /// \brief Called on well-formed 'schedule' clause.
9102 OMPClause *ActOnOpenMPScheduleClause(
9103 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
9104 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
9105 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
9106 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
9107
9108 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
9109 SourceLocation EndLoc);
9110 /// \brief Called on well-formed 'nowait' clause.
9111 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
9112 SourceLocation EndLoc);
9113 /// \brief Called on well-formed 'untied' clause.
9114 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
9115 SourceLocation EndLoc);
9116 /// \brief Called on well-formed 'mergeable' clause.
9117 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
9118 SourceLocation EndLoc);
9119 /// \brief Called on well-formed 'read' clause.
9120 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
9121 SourceLocation EndLoc);
9122 /// \brief Called on well-formed 'write' clause.
9123 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
9124 SourceLocation EndLoc);
9125 /// \brief Called on well-formed 'update' clause.
9126 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
9127 SourceLocation EndLoc);
9128 /// \brief Called on well-formed 'capture' clause.
9129 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
9130 SourceLocation EndLoc);
9131 /// \brief Called on well-formed 'seq_cst' clause.
9132 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
9133 SourceLocation EndLoc);
9134 /// \brief Called on well-formed 'threads' clause.
9135 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
9136 SourceLocation EndLoc);
9137 /// \brief Called on well-formed 'simd' clause.
9138 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
9139 SourceLocation EndLoc);
9140 /// \brief Called on well-formed 'nogroup' clause.
9141 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
9142 SourceLocation EndLoc);
9143
9144 OMPClause *ActOnOpenMPVarListClause(
9145 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *TailExpr,
9146 SourceLocation StartLoc, SourceLocation LParenLoc,
9147 SourceLocation ColonLoc, SourceLocation EndLoc,
9148 CXXScopeSpec &ReductionIdScopeSpec,
9149 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
9150 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
9151 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
9152 SourceLocation DepLinMapLoc);
9153 /// \brief Called on well-formed 'private' clause.
9154 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
9155 SourceLocation StartLoc,
9156 SourceLocation LParenLoc,
9157 SourceLocation EndLoc);
9158 /// \brief Called on well-formed 'firstprivate' clause.
9159 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
9160 SourceLocation StartLoc,
9161 SourceLocation LParenLoc,
9162 SourceLocation EndLoc);
9163 /// \brief Called on well-formed 'lastprivate' clause.
9164 OMPClause *ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
9165 SourceLocation StartLoc,
9166 SourceLocation LParenLoc,
9167 SourceLocation EndLoc);
9168 /// \brief Called on well-formed 'shared' clause.
9169 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
9170 SourceLocation StartLoc,
9171 SourceLocation LParenLoc,
9172 SourceLocation EndLoc);
9173 /// \brief Called on well-formed 'reduction' clause.
9174 OMPClause *ActOnOpenMPReductionClause(
9175 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9176 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9177 CXXScopeSpec &ReductionIdScopeSpec,
9178 const DeclarationNameInfo &ReductionId,
9179 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9180 /// Called on well-formed 'task_reduction' clause.
9181 OMPClause *ActOnOpenMPTaskReductionClause(
9182 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9183 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9184 CXXScopeSpec &ReductionIdScopeSpec,
9185 const DeclarationNameInfo &ReductionId,
9186 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9187 /// Called on well-formed 'in_reduction' clause.
9188 OMPClause *ActOnOpenMPInReductionClause(
9189 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9190 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9191 CXXScopeSpec &ReductionIdScopeSpec,
9192 const DeclarationNameInfo &ReductionId,
9193 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9194 /// \brief Called on well-formed 'linear' clause.
9195 OMPClause *
9196 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
9197 SourceLocation StartLoc, SourceLocation LParenLoc,
9198 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
9199 SourceLocation ColonLoc, SourceLocation EndLoc);
9200 /// \brief Called on well-formed 'aligned' clause.
9201 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
9202 Expr *Alignment,
9203 SourceLocation StartLoc,
9204 SourceLocation LParenLoc,
9205 SourceLocation ColonLoc,
9206 SourceLocation EndLoc);
9207 /// \brief Called on well-formed 'copyin' clause.
9208 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9209 SourceLocation StartLoc,
9210 SourceLocation LParenLoc,
9211 SourceLocation EndLoc);
9212 /// \brief Called on well-formed 'copyprivate' clause.
9213 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9214 SourceLocation StartLoc,
9215 SourceLocation LParenLoc,
9216 SourceLocation EndLoc);
9217 /// \brief Called on well-formed 'flush' pseudo clause.
9218 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
9219 SourceLocation StartLoc,
9220 SourceLocation LParenLoc,
9221 SourceLocation EndLoc);
9222 /// \brief Called on well-formed 'depend' clause.
9223 OMPClause *
9224 ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
9225 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
9226 SourceLocation StartLoc, SourceLocation LParenLoc,
9227 SourceLocation EndLoc);
9228 /// \brief Called on well-formed 'device' clause.
9229 OMPClause *ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
9230 SourceLocation LParenLoc,
9231 SourceLocation EndLoc);
9232 /// \brief Called on well-formed 'map' clause.
9233 OMPClause *
9234 ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
9235 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
9236 SourceLocation MapLoc, SourceLocation ColonLoc,
9237 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9238 SourceLocation LParenLoc, SourceLocation EndLoc);
9239 /// \brief Called on well-formed 'num_teams' clause.
9240 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
9241 SourceLocation LParenLoc,
9242 SourceLocation EndLoc);
9243 /// \brief Called on well-formed 'thread_limit' clause.
9244 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
9245 SourceLocation StartLoc,
9246 SourceLocation LParenLoc,
9247 SourceLocation EndLoc);
9248 /// \brief Called on well-formed 'priority' clause.
9249 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
9250 SourceLocation LParenLoc,
9251 SourceLocation EndLoc);
9252 /// \brief Called on well-formed 'dist_schedule' clause.
9253 OMPClause *ActOnOpenMPDistScheduleClause(
9254 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
9255 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
9256 SourceLocation CommaLoc, SourceLocation EndLoc);
9257 /// \brief Called on well-formed 'defaultmap' clause.
9258 OMPClause *ActOnOpenMPDefaultmapClause(
9259 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
9260 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
9261 SourceLocation KindLoc, SourceLocation EndLoc);
9262 /// \brief Called on well-formed 'to' clause.
9263 OMPClause *ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
9264 SourceLocation StartLoc,
9265 SourceLocation LParenLoc,
9266 SourceLocation EndLoc);
9267 /// \brief Called on well-formed 'from' clause.
9268 OMPClause *ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
9269 SourceLocation StartLoc,
9270 SourceLocation LParenLoc,
9271 SourceLocation EndLoc);
9272 /// Called on well-formed 'use_device_ptr' clause.
9273 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
9274 SourceLocation StartLoc,
9275 SourceLocation LParenLoc,
9276 SourceLocation EndLoc);
9277 /// Called on well-formed 'is_device_ptr' clause.
9278 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
9279 SourceLocation StartLoc,
9280 SourceLocation LParenLoc,
9281 SourceLocation EndLoc);
9282
9283 /// \brief The kind of conversion being performed.
9284 enum CheckedConversionKind {
9285 /// \brief An implicit conversion.
9286 CCK_ImplicitConversion,
9287 /// \brief A C-style cast.
9288 CCK_CStyleCast,
9289 /// \brief A functional-style cast.
9290 CCK_FunctionalCast,
9291 /// \brief A cast other than a C-style cast.
9292 CCK_OtherCast
9293 };
9294
9295 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
9296 /// cast. If there is already an implicit cast, merge into the existing one.
9297 /// If isLvalue, the result of the cast is an lvalue.
9298 ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
9299 ExprValueKind VK = VK_RValue,
9300 const CXXCastPath *BasePath = nullptr,
9301 CheckedConversionKind CCK
9302 = CCK_ImplicitConversion);
9303
9304 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
9305 /// to the conversion from scalar type ScalarTy to the Boolean type.
9306 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
9307
9308 /// IgnoredValueConversions - Given that an expression's result is
9309 /// syntactically ignored, perform any conversions that are
9310 /// required.
9311 ExprResult IgnoredValueConversions(Expr *E);
9312
9313 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
9314 // functions and arrays to their respective pointers (C99 6.3.2.1).
9315 ExprResult UsualUnaryConversions(Expr *E);
9316
9317 /// CallExprUnaryConversions - a special case of an unary conversion
9318 /// performed on a function designator of a call expression.
9319 ExprResult CallExprUnaryConversions(Expr *E);
9320
9321 // DefaultFunctionArrayConversion - converts functions and arrays
9322 // to their respective pointers (C99 6.3.2.1).
9323 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
9324
9325 // DefaultFunctionArrayLvalueConversion - converts functions and
9326 // arrays to their respective pointers and performs the
9327 // lvalue-to-rvalue conversion.
9328 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
9329 bool Diagnose = true);
9330
9331 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
9332 // the operand. This is DefaultFunctionArrayLvalueConversion,
9333 // except that it assumes the operand isn't of function or array
9334 // type.
9335 ExprResult DefaultLvalueConversion(Expr *E);
9336
9337 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
9338 // do not have a prototype. Integer promotions are performed on each
9339 // argument, and arguments that have type float are promoted to double.
9340 ExprResult DefaultArgumentPromotion(Expr *E);
9341
9342 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize
9343 /// it as an xvalue. In C++98, the result will still be a prvalue, because
9344 /// we don't have xvalues there.
9345 ExprResult TemporaryMaterializationConversion(Expr *E);
9346
9347 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
9348 enum VariadicCallType {
9349 VariadicFunction,
9350 VariadicBlock,
9351 VariadicMethod,
9352 VariadicConstructor,
9353 VariadicDoesNotApply
9354 };
9355
9356 VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
9357 const FunctionProtoType *Proto,
9358 Expr *Fn);
9359
9360 // Used for determining in which context a type is allowed to be passed to a
9361 // vararg function.
9362 enum VarArgKind {
9363 VAK_Valid,
9364 VAK_ValidInCXX11,
9365 VAK_Undefined,
9366 VAK_MSVCUndefined,
9367 VAK_Invalid
9368 };
9369
9370 // Determines which VarArgKind fits an expression.
9371 VarArgKind isValidVarArgType(const QualType &Ty);
9372
9373 /// Check to see if the given expression is a valid argument to a variadic
9374 /// function, issuing a diagnostic if not.
9375 void checkVariadicArgument(const Expr *E, VariadicCallType CT);
9376
9377 /// Check to see if a given expression could have '.c_str()' called on it.
9378 bool hasCStrMethod(const Expr *E);
9379
9380 /// GatherArgumentsForCall - Collector argument expressions for various
9381 /// form of call prototypes.
9382 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
9383 const FunctionProtoType *Proto,
9384 unsigned FirstParam, ArrayRef<Expr *> Args,
9385 SmallVectorImpl<Expr *> &AllArgs,
9386 VariadicCallType CallType = VariadicDoesNotApply,
9387 bool AllowExplicit = false,
9388 bool IsListInitialization = false);
9389
9390 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
9391 // will create a runtime trap if the resulting type is not a POD type.
9392 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
9393 FunctionDecl *FDecl);
9394
9395 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
9396 // operands and then handles various conversions that are common to binary
9397 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
9398 // routine returns the first non-arithmetic type found. The client is
9399 // responsible for emitting appropriate error diagnostics.
9400 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
9401 bool IsCompAssign = false);
9402
9403 /// AssignConvertType - All of the 'assignment' semantic checks return this
9404 /// enum to indicate whether the assignment was allowed. These checks are
9405 /// done for simple assignments, as well as initialization, return from
9406 /// function, argument passing, etc. The query is phrased in terms of a
9407 /// source and destination type.
9408 enum AssignConvertType {
9409 /// Compatible - the types are compatible according to the standard.
9410 Compatible,
9411
9412 /// PointerToInt - The assignment converts a pointer to an int, which we
9413 /// accept as an extension.
9414 PointerToInt,
9415
9416 /// IntToPointer - The assignment converts an int to a pointer, which we
9417 /// accept as an extension.
9418 IntToPointer,
9419
9420 /// FunctionVoidPointer - The assignment is between a function pointer and
9421 /// void*, which the standard doesn't allow, but we accept as an extension.
9422 FunctionVoidPointer,
9423
9424 /// IncompatiblePointer - The assignment is between two pointers types that
9425 /// are not compatible, but we accept them as an extension.
9426 IncompatiblePointer,
9427
9428 /// IncompatiblePointerSign - The assignment is between two pointers types
9429 /// which point to integers which have a different sign, but are otherwise
9430 /// identical. This is a subset of the above, but broken out because it's by
9431 /// far the most common case of incompatible pointers.
9432 IncompatiblePointerSign,
9433
9434 /// CompatiblePointerDiscardsQualifiers - The assignment discards
9435 /// c/v/r qualifiers, which we accept as an extension.
9436 CompatiblePointerDiscardsQualifiers,
9437
9438 /// IncompatiblePointerDiscardsQualifiers - The assignment
9439 /// discards qualifiers that we don't permit to be discarded,
9440 /// like address spaces.
9441 IncompatiblePointerDiscardsQualifiers,
9442
9443 /// IncompatibleNestedPointerQualifiers - The assignment is between two
9444 /// nested pointer types, and the qualifiers other than the first two
9445 /// levels differ e.g. char ** -> const char **, but we accept them as an
9446 /// extension.
9447 IncompatibleNestedPointerQualifiers,
9448
9449 /// IncompatibleVectors - The assignment is between two vector types that
9450 /// have the same size, which we accept as an extension.
9451 IncompatibleVectors,
9452
9453 /// IntToBlockPointer - The assignment converts an int to a block
9454 /// pointer. We disallow this.
9455 IntToBlockPointer,
9456
9457 /// IncompatibleBlockPointer - The assignment is between two block
9458 /// pointers types that are not compatible.
9459 IncompatibleBlockPointer,
9460
9461 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
9462 /// id type and something else (that is incompatible with it). For example,
9463 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
9464 IncompatibleObjCQualifiedId,
9465
9466 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
9467 /// object with __weak qualifier.
9468 IncompatibleObjCWeakRef,
9469
9470 /// Incompatible - We reject this conversion outright, it is invalid to
9471 /// represent it in the AST.
9472 Incompatible
9473 };
9474
9475 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
9476 /// assignment conversion type specified by ConvTy. This returns true if the
9477 /// conversion was invalid or false if the conversion was accepted.
9478 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
9479 SourceLocation Loc,
9480 QualType DstType, QualType SrcType,
9481 Expr *SrcExpr, AssignmentAction Action,
9482 bool *Complained = nullptr);
9483
9484 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
9485 /// enum. If AllowMask is true, then we also allow the complement of a valid
9486 /// value, to be used as a mask.
9487 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
9488 bool AllowMask) const;
9489
9490 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
9491 /// integer not in the range of enum values.
9492 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
9493 Expr *SrcExpr);
9494
9495 /// CheckAssignmentConstraints - Perform type checking for assignment,
9496 /// argument passing, variable initialization, and function return values.
9497 /// C99 6.5.16.
9498 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
9499 QualType LHSType,
9500 QualType RHSType);
9501
9502 /// Check assignment constraints and optionally prepare for a conversion of
9503 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
9504 /// is true.
9505 AssignConvertType CheckAssignmentConstraints(QualType LHSType,
9506 ExprResult &RHS,
9507 CastKind &Kind,
9508 bool ConvertRHS = true);
9509
9510 /// Check assignment constraints for an assignment of RHS to LHSType.
9511 ///
9512 /// \param LHSType The destination type for the assignment.
9513 /// \param RHS The source expression for the assignment.
9514 /// \param Diagnose If \c true, diagnostics may be produced when checking
9515 /// for assignability. If a diagnostic is produced, \p RHS will be
9516 /// set to ExprError(). Note that this function may still return
9517 /// without producing a diagnostic, even for an invalid assignment.
9518 /// \param DiagnoseCFAudited If \c true, the target is a function parameter
9519 /// in an audited Core Foundation API and does not need to be checked
9520 /// for ARC retain issues.
9521 /// \param ConvertRHS If \c true, \p RHS will be updated to model the
9522 /// conversions necessary to perform the assignment. If \c false,
9523 /// \p Diagnose must also be \c false.
9524 AssignConvertType CheckSingleAssignmentConstraints(
9525 QualType LHSType, ExprResult &RHS, bool Diagnose = true,
9526 bool DiagnoseCFAudited = false, bool ConvertRHS = true);
9527
9528 // \brief If the lhs type is a transparent union, check whether we
9529 // can initialize the transparent union with the given expression.
9530 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
9531 ExprResult &RHS);
9532
9533 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
9534
9535 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
9536
9537 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9538 AssignmentAction Action,
9539 bool AllowExplicit = false);
9540 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9541 AssignmentAction Action,
9542 bool AllowExplicit,
9543 ImplicitConversionSequence& ICS);
9544 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9545 const ImplicitConversionSequence& ICS,
9546 AssignmentAction Action,
9547 CheckedConversionKind CCK
9548 = CCK_ImplicitConversion);
9549 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9550 const StandardConversionSequence& SCS,
9551 AssignmentAction Action,
9552 CheckedConversionKind CCK);
9553
9554 /// the following "Check" methods will return a valid/converted QualType
9555 /// or a null QualType (indicating an error diagnostic was issued).
9556
9557 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
9558 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
9559 ExprResult &RHS);
9560 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
9561 ExprResult &RHS);
9562 QualType CheckPointerToMemberOperands( // C++ 5.5
9563 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
9564 SourceLocation OpLoc, bool isIndirect);
9565 QualType CheckMultiplyDivideOperands( // C99 6.5.5
9566 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
9567 bool IsDivide);
9568 QualType CheckRemainderOperands( // C99 6.5.5
9569 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9570 bool IsCompAssign = false);
9571 QualType CheckAdditionOperands( // C99 6.5.6
9572 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9573 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
9574 QualType CheckSubtractionOperands( // C99 6.5.6
9575 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9576 QualType* CompLHSTy = nullptr);
9577 QualType CheckShiftOperands( // C99 6.5.7
9578 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9579 BinaryOperatorKind Opc, bool IsCompAssign = false);
9580 QualType CheckCompareOperands( // C99 6.5.8/9
9581 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9582 BinaryOperatorKind Opc, bool isRelational);
9583 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
9584 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9585 BinaryOperatorKind Opc);
9586 QualType CheckLogicalOperands( // C99 6.5.[13,14]
9587 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9588 BinaryOperatorKind Opc);
9589 // CheckAssignmentOperands is used for both simple and compound assignment.
9590 // For simple assignment, pass both expressions and a null converted type.
9591 // For compound assignment, pass both expressions and the converted type.
9592 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
9593 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
9594
9595 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
9596 UnaryOperatorKind Opcode, Expr *Op);
9597 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
9598 BinaryOperatorKind Opcode,
9599 Expr *LHS, Expr *RHS);
9600 ExprResult checkPseudoObjectRValue(Expr *E);
9601 Expr *recreateSyntacticForm(PseudoObjectExpr *E);
9602
9603 QualType CheckConditionalOperands( // C99 6.5.15
9604 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
9605 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
9606 QualType CXXCheckConditionalOperands( // C++ 5.16
9607 ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
9608 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
9609 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
9610 bool ConvertArgs = true);
9611 QualType FindCompositePointerType(SourceLocation Loc,
9612 ExprResult &E1, ExprResult &E2,
9613 bool ConvertArgs = true) {
9614 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
9615 QualType Composite =
9616 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
9617 E1 = E1Tmp;
9618 E2 = E2Tmp;
9619 return Composite;
9620 }
9621
9622 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
9623 SourceLocation QuestionLoc);
9624
9625 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
9626 SourceLocation QuestionLoc);
9627
9628 void DiagnoseAlwaysNonNullPointer(Expr *E,
9629 Expr::NullPointerConstantKind NullType,
9630 bool IsEqual, SourceRange Range);
9631
9632 /// type checking for vector binary operators.
9633 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
9634 SourceLocation Loc, bool IsCompAssign,
9635 bool AllowBothBool, bool AllowBoolConversion);
9636 QualType GetSignedVectorType(QualType V);
9637 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
9638 SourceLocation Loc,
9639 BinaryOperatorKind Opc);
9640 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
9641 SourceLocation Loc);
9642
9643 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
9644 bool isLaxVectorConversion(QualType srcType, QualType destType);
9645
9646 /// type checking declaration initializers (C99 6.7.8)
9647 bool CheckForConstantInitializer(Expr *e, QualType t);
9648
9649 // type checking C++ declaration initializers (C++ [dcl.init]).
9650
9651 /// ReferenceCompareResult - Expresses the result of comparing two
9652 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
9653 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
9654 enum ReferenceCompareResult {
9655 /// Ref_Incompatible - The two types are incompatible, so direct
9656 /// reference binding is not possible.
9657 Ref_Incompatible = 0,
9658 /// Ref_Related - The two types are reference-related, which means
9659 /// that their unqualified forms (T1 and T2) are either the same
9660 /// or T1 is a base class of T2.
9661 Ref_Related,
9662 /// Ref_Compatible - The two types are reference-compatible.
9663 Ref_Compatible
9664 };
9665
9666 ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc,
9667 QualType T1, QualType T2,
9668 bool &DerivedToBase,
9669 bool &ObjCConversion,
9670 bool &ObjCLifetimeConversion);
9671
9672 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
9673 Expr *CastExpr, CastKind &CastKind,
9674 ExprValueKind &VK, CXXCastPath &Path);
9675
9676 /// \brief Force an expression with unknown-type to an expression of the
9677 /// given type.
9678 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
9679
9680 /// \brief Type-check an expression that's being passed to an
9681 /// __unknown_anytype parameter.
9682 ExprResult checkUnknownAnyArg(SourceLocation callLoc,
9683 Expr *result, QualType &paramType);
9684
9685 // CheckVectorCast - check type constraints for vectors.
9686 // Since vectors are an extension, there are no C standard reference for this.
9687 // We allow casting between vectors and integer datatypes of the same size.
9688 // returns true if the cast is invalid
9689 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
9690 CastKind &Kind);
9691
9692 /// \brief Prepare `SplattedExpr` for a vector splat operation, adding
9693 /// implicit casts if necessary.
9694 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
9695
9696 // CheckExtVectorCast - check type constraints for extended vectors.
9697 // Since vectors are an extension, there are no C standard reference for this.
9698 // We allow casting between vectors and integer datatypes of the same size,
9699 // or vectors and the element type of that vector.
9700 // returns the cast expr
9701 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
9702 CastKind &Kind);
9703
9704 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
9705 SourceLocation LParenLoc,
9706 Expr *CastExpr,
9707 SourceLocation RParenLoc);
9708
9709 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
9710
9711 /// \brief Checks for invalid conversions and casts between
9712 /// retainable pointers and other pointer kinds for ARC and Weak.
9713 ARCConversionResult CheckObjCConversion(SourceRange castRange,
9714 QualType castType, Expr *&op,
9715 CheckedConversionKind CCK,
9716 bool Diagnose = true,
9717 bool DiagnoseCFAudited = false,
9718 BinaryOperatorKind Opc = BO_PtrMemD
9719 );
9720
9721 Expr *stripARCUnbridgedCast(Expr *e);
9722 void diagnoseARCUnbridgedCast(Expr *e);
9723
9724 bool CheckObjCARCUnavailableWeakConversion(QualType castType,
9725 QualType ExprType);
9726
9727 /// checkRetainCycles - Check whether an Objective-C message send
9728 /// might create an obvious retain cycle.
9729 void checkRetainCycles(ObjCMessageExpr *msg);
9730 void checkRetainCycles(Expr *receiver, Expr *argument);
9731 void checkRetainCycles(VarDecl *Var, Expr *Init);
9732
9733 /// checkUnsafeAssigns - Check whether +1 expr is being assigned
9734 /// to weak/__unsafe_unretained type.
9735 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
9736
9737 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
9738 /// to weak/__unsafe_unretained expression.
9739 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
9740
9741 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
9742 /// \param Method - May be null.
9743 /// \param [out] ReturnType - The return type of the send.
9744 /// \return true iff there were any incompatible types.
9745 bool CheckMessageArgumentTypes(QualType ReceiverType,
9746 MultiExprArg Args, Selector Sel,
9747 ArrayRef<SourceLocation> SelectorLocs,
9748 ObjCMethodDecl *Method, bool isClassMessage,
9749 bool isSuperMessage,
9750 SourceLocation lbrac, SourceLocation rbrac,
9751 SourceRange RecRange,
9752 QualType &ReturnType, ExprValueKind &VK);
9753
9754 /// \brief Determine the result of a message send expression based on
9755 /// the type of the receiver, the method expected to receive the message,
9756 /// and the form of the message send.
9757 QualType getMessageSendResultType(QualType ReceiverType,
9758 ObjCMethodDecl *Method,
9759 bool isClassMessage, bool isSuperMessage);
9760
9761 /// \brief If the given expression involves a message send to a method
9762 /// with a related result type, emit a note describing what happened.
9763 void EmitRelatedResultTypeNote(const Expr *E);
9764
9765 /// \brief Given that we had incompatible pointer types in a return
9766 /// statement, check whether we're in a method with a related result
9767 /// type, and if so, emit a note describing what happened.
9768 void EmitRelatedResultTypeNoteForReturn(QualType destType);
9769
9770 class ConditionResult {
9771 Decl *ConditionVar;
9772 FullExprArg Condition;
9773 bool Invalid;
9774 bool HasKnownValue;
9775 bool KnownValue;
9776
9777 friend class Sema;
9778 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
9779 bool IsConstexpr)
9780 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),
9781 HasKnownValue(IsConstexpr && Condition.get() &&
9782 !Condition.get()->isValueDependent()),
9783 KnownValue(HasKnownValue &&
9784 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
9785 explicit ConditionResult(bool Invalid)
9786 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),
9787 HasKnownValue(false), KnownValue(false) {}
9788
9789 public:
9790 ConditionResult() : ConditionResult(false) {}
9791 bool isInvalid() const { return Invalid; }
9792 std::pair<VarDecl *, Expr *> get() const {
9793 return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
9794 Condition.get());
9795 }
9796 llvm::Optional<bool> getKnownValue() const {
9797 if (!HasKnownValue)
9798 return None;
9799 return KnownValue;
9800 }
9801 };
9802 static ConditionResult ConditionError() { return ConditionResult(true); }
9803
9804 enum class ConditionKind {
9805 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
9806 ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
9807 Switch ///< An integral condition for a 'switch' statement.
9808 };
9809
9810 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
9811 Expr *SubExpr, ConditionKind CK);
9812
9813 ConditionResult ActOnConditionVariable(Decl *ConditionVar,
9814 SourceLocation StmtLoc,
9815 ConditionKind CK);
9816
9817 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
9818
9819 ExprResult CheckConditionVariable(VarDecl *ConditionVar,
9820 SourceLocation StmtLoc,
9821 ConditionKind CK);
9822 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
9823
9824 /// CheckBooleanCondition - Diagnose problems involving the use of
9825 /// the given expression as a boolean condition (e.g. in an if
9826 /// statement). Also performs the standard function and array
9827 /// decays, possibly changing the input variable.
9828 ///
9829 /// \param Loc - A location associated with the condition, e.g. the
9830 /// 'if' keyword.
9831 /// \return true iff there were any errors
9832 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
9833 bool IsConstexpr = false);
9834
9835 /// DiagnoseAssignmentAsCondition - Given that an expression is
9836 /// being used as a boolean condition, warn if it's an assignment.
9837 void DiagnoseAssignmentAsCondition(Expr *E);
9838
9839 /// \brief Redundant parentheses over an equality comparison can indicate
9840 /// that the user intended an assignment used as condition.
9841 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
9842
9843 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
9844 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
9845
9846 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
9847 /// the specified width and sign. If an overflow occurs, detect it and emit
9848 /// the specified diagnostic.
9849 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
9850 unsigned NewWidth, bool NewSign,
9851 SourceLocation Loc, unsigned DiagID);
9852
9853 /// Checks that the Objective-C declaration is declared in the global scope.
9854 /// Emits an error and marks the declaration as invalid if it's not declared
9855 /// in the global scope.
9856 bool CheckObjCDeclScope(Decl *D);
9857
9858 /// \brief Abstract base class used for diagnosing integer constant
9859 /// expression violations.
9860 class VerifyICEDiagnoser {
9861 public:
9862 bool Suppress;
9863
9864 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
9865
9866 virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) =0;
9867 virtual void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR);
9868 virtual ~VerifyICEDiagnoser() { }
9869 };
9870
9871 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
9872 /// and reports the appropriate diagnostics. Returns false on success.
9873 /// Can optionally return the value of the expression.
9874 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
9875 VerifyICEDiagnoser &Diagnoser,
9876 bool AllowFold = true);
9877 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
9878 unsigned DiagID,
9879 bool AllowFold = true);
9880 ExprResult VerifyIntegerConstantExpression(Expr *E,
9881 llvm::APSInt *Result = nullptr);
9882
9883 /// VerifyBitField - verifies that a bit field expression is an ICE and has
9884 /// the correct width, and that the field type is valid.
9885 /// Returns false on success.
9886 /// Can optionally return whether the bit-field is of width 0
9887 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
9888 QualType FieldTy, bool IsMsStruct,
9889 Expr *BitWidth, bool *ZeroWidth = nullptr);
9890
9891private:
9892 unsigned ForceCUDAHostDeviceDepth = 0;
9893
9894public:
9895 /// Increments our count of the number of times we've seen a pragma forcing
9896 /// functions to be __host__ __device__. So long as this count is greater
9897 /// than zero, all functions encountered will be __host__ __device__.
9898 void PushForceCUDAHostDevice();
9899
9900 /// Decrements our count of the number of times we've seen a pragma forcing
9901 /// functions to be __host__ __device__. Returns false if the count is 0
9902 /// before incrementing, so you can emit an error.
9903 bool PopForceCUDAHostDevice();
9904
9905 /// Diagnostics that are emitted only if we discover that the given function
9906 /// must be codegen'ed. Because handling these correctly adds overhead to
9907 /// compilation, this is currently only enabled for CUDA compilations.
9908 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
9909 std::vector<PartialDiagnosticAt>>
9910 CUDADeferredDiags;
9911
9912 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
9913 /// key in a hashtable, both the FD and location are hashed.
9914 struct FunctionDeclAndLoc {
9915 CanonicalDeclPtr<FunctionDecl> FD;
9916 SourceLocation Loc;
9917 };
9918
9919 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
9920 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
9921 /// same deferred diag twice.
9922 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;
9923
9924 /// An inverse call graph, mapping known-emitted functions to one of their
9925 /// known-emitted callers (plus the location of the call).
9926 ///
9927 /// Functions that we can tell a priori must be emitted aren't added to this
9928 /// map.
9929 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
9930 /* Caller = */ FunctionDeclAndLoc>
9931 CUDAKnownEmittedFns;
9932
9933 /// A partial call graph maintained during CUDA compilation to support
9934 /// deferred diagnostics.
9935 ///
9936 /// Functions are only added here if, at the time they're considered, they are
9937 /// not known-emitted. As soon as we discover that a function is
9938 /// known-emitted, we remove it and everything it transitively calls from this
9939 /// set and add those functions to CUDAKnownEmittedFns.
9940 llvm::DenseMap</* Caller = */ CanonicalDeclPtr<FunctionDecl>,
9941 /* Callees = */ llvm::MapVector<CanonicalDeclPtr<FunctionDecl>,
9942 SourceLocation>>
9943 CUDACallGraph;
9944
9945 /// Diagnostic builder for CUDA errors which may or may not be deferred.
9946 ///
9947 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
9948 /// which are not allowed to appear inside __device__ functions and are
9949 /// allowed to appear in __host__ __device__ functions only if the host+device
9950 /// function is never codegen'ed.
9951 ///
9952 /// To handle this, we use the notion of "deferred diagnostics", where we
9953 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
9954 ///
9955 /// This class lets you emit either a regular diagnostic, a deferred
9956 /// diagnostic, or no diagnostic at all, according to an argument you pass to
9957 /// its constructor, thus simplifying the process of creating these "maybe
9958 /// deferred" diagnostics.
9959 class CUDADiagBuilder {
9960 public:
9961 enum Kind {
9962 /// Emit no diagnostics.
9963 K_Nop,
9964 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
9965 K_Immediate,
9966 /// Emit the diagnostic immediately, and, if it's a warning or error, also
9967 /// emit a call stack showing how this function can be reached by an a
9968 /// priori known-emitted function.
9969 K_ImmediateWithCallStack,
9970 /// Create a deferred diagnostic, which is emitted only if the function
9971 /// it's attached to is codegen'ed. Also emit a call stack as with
9972 /// K_ImmediateWithCallStack.
9973 K_Deferred
9974 };
9975
9976 CUDADiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
9977 FunctionDecl *Fn, Sema &S);
9978 ~CUDADiagBuilder();
9979
9980 /// Convertible to bool: True if we immediately emitted an error, false if
9981 /// we didn't emit an error or we created a deferred error.
9982 ///
9983 /// Example usage:
9984 ///
9985 /// if (CUDADiagBuilder(...) << foo << bar)
9986 /// return ExprError();
9987 ///
9988 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
9989 /// want to use these instead of creating a CUDADiagBuilder yourself.
9990 operator bool() const { return ImmediateDiag.hasValue(); }
9991
9992 template <typename T>
9993 friend const CUDADiagBuilder &operator<<(const CUDADiagBuilder &Diag,
9994 const T &Value) {
9995 if (Diag.ImmediateDiag.hasValue())
9996 *Diag.ImmediateDiag << Value;
9997 else if (Diag.PartialDiag.hasValue())
9998 *Diag.PartialDiag << Value;
9999 return Diag;
10000 }
10001
10002 private:
10003 Sema &S;
10004 SourceLocation Loc;
10005 unsigned DiagID;
10006 FunctionDecl *Fn;
10007 bool ShowCallStack;
10008
10009 // Invariant: At most one of these Optionals has a value.
10010 // FIXME: Switch these to a Variant once that exists.
10011 llvm::Optional<SemaDiagnosticBuilder> ImmediateDiag;
10012 llvm::Optional<PartialDiagnostic> PartialDiag;
10013 };
10014
10015 /// Creates a CUDADiagBuilder that emits the diagnostic if the current context
10016 /// is "used as device code".
10017 ///
10018 /// - If CurContext is a __host__ function, does not emit any diagnostics.
10019 /// - If CurContext is a __device__ or __global__ function, emits the
10020 /// diagnostics immediately.
10021 /// - If CurContext is a __host__ __device__ function and we are compiling for
10022 /// the device, creates a diagnostic which is emitted if and when we realize
10023 /// that the function will be codegen'ed.
10024 ///
10025 /// Example usage:
10026 ///
10027 /// // Variable-length arrays are not allowed in CUDA device code.
10028 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
10029 /// return ExprError();
10030 /// // Otherwise, continue parsing as normal.
10031 CUDADiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID);
10032
10033 /// Creates a CUDADiagBuilder that emits the diagnostic if the current context
10034 /// is "used as host code".
10035 ///
10036 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
10037 CUDADiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
10038
10039 enum CUDAFunctionTarget {
10040 CFT_Device,
10041 CFT_Global,
10042 CFT_Host,
10043 CFT_HostDevice,
10044 CFT_InvalidTarget
10045 };
10046
10047 /// Determines whether the given function is a CUDA device/host/kernel/etc.
10048 /// function.
10049 ///
10050 /// Use this rather than examining the function's attributes yourself -- you
10051 /// will get it wrong. Returns CFT_Host if D is null.
10052 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
10053 bool IgnoreImplicitHDAttr = false);
10054 CUDAFunctionTarget IdentifyCUDATarget(const AttributeList *Attr);
10055
10056 /// Gets the CUDA target for the current context.
10057 CUDAFunctionTarget CurrentCUDATarget() {
10058 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
10059 }
10060
10061 // CUDA function call preference. Must be ordered numerically from
10062 // worst to best.
10063 enum CUDAFunctionPreference {
10064 CFP_Never, // Invalid caller/callee combination.
10065 CFP_WrongSide, // Calls from host-device to host or device
10066 // function that do not match current compilation
10067 // mode.
10068 CFP_HostDevice, // Any calls to host/device functions.
10069 CFP_SameSide, // Calls from host-device to host or device
10070 // function matching current compilation mode.
10071 CFP_Native, // host-to-host or device-to-device calls.
10072 };
10073
10074 /// Identifies relative preference of a given Caller/Callee
10075 /// combination, based on their host/device attributes.
10076 /// \param Caller function which needs address of \p Callee.
10077 /// nullptr in case of global context.
10078 /// \param Callee target function
10079 ///
10080 /// \returns preference value for particular Caller/Callee combination.
10081 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
10082 const FunctionDecl *Callee);
10083
10084 /// Determines whether Caller may invoke Callee, based on their CUDA
10085 /// host/device attributes. Returns false if the call is not allowed.
10086 ///
10087 /// Note: Will return true for CFP_WrongSide calls. These may appear in
10088 /// semantically correct CUDA programs, but only if they're never codegen'ed.
10089 bool IsAllowedCUDACall(const FunctionDecl *Caller,
10090 const FunctionDecl *Callee) {
10091 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
10092 }
10093
10094 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
10095 /// depending on FD and the current compilation settings.
10096 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
10097 const LookupResult &Previous);
10098
10099public:
10100 /// Check whether we're allowed to call Callee from the current context.
10101 ///
10102 /// - If the call is never allowed in a semantically-correct program
10103 /// (CFP_Never), emits an error and returns false.
10104 ///
10105 /// - If the call is allowed in semantically-correct programs, but only if
10106 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
10107 /// be emitted if and when the caller is codegen'ed, and returns true.
10108 ///
10109 /// Will only create deferred diagnostics for a given SourceLocation once,
10110 /// so you can safely call this multiple times without generating duplicate
10111 /// deferred errors.
10112 ///
10113 /// - Otherwise, returns true without emitting any diagnostics.
10114 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
10115
10116 /// Set __device__ or __host__ __device__ attributes on the given lambda
10117 /// operator() method.
10118 ///
10119 /// CUDA lambdas declared inside __device__ or __global__ functions inherit
10120 /// the __device__ attribute. Similarly, lambdas inside __host__ __device__
10121 /// functions become __host__ __device__ themselves.
10122 void CUDASetLambdaAttrs(CXXMethodDecl *Method);
10123
10124 /// Finds a function in \p Matches with highest calling priority
10125 /// from \p Caller context and erases all functions with lower
10126 /// calling priority.
10127 void EraseUnwantedCUDAMatches(
10128 const FunctionDecl *Caller,
10129 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
10130
10131 /// Given a implicit special member, infer its CUDA target from the
10132 /// calls it needs to make to underlying base/field special members.
10133 /// \param ClassDecl the class for which the member is being created.
10134 /// \param CSM the kind of special member.
10135 /// \param MemberDecl the special member itself.
10136 /// \param ConstRHS true if this is a copy operation with a const object on
10137 /// its RHS.
10138 /// \param Diagnose true if this call should emit diagnostics.
10139 /// \return true if there was an error inferring.
10140 /// The result of this call is implicit CUDA target attribute(s) attached to
10141 /// the member declaration.
10142 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
10143 CXXSpecialMember CSM,
10144 CXXMethodDecl *MemberDecl,
10145 bool ConstRHS,
10146 bool Diagnose);
10147
10148 /// \return true if \p CD can be considered empty according to CUDA
10149 /// (E.2.3.1 in CUDA 7.5 Programming guide).
10150 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
10151 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
10152
10153 /// Check whether NewFD is a valid overload for CUDA. Emits
10154 /// diagnostics and invalidates NewFD if not.
10155 void checkCUDATargetOverload(FunctionDecl *NewFD,
10156 const LookupResult &Previous);
10157 /// Copies target attributes from the template TD to the function FD.
10158 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);
10159
10160 /// \name Code completion
10161 //@{
10162 /// \brief Describes the context in which code completion occurs.
10163 enum ParserCompletionContext {
10164 /// \brief Code completion occurs at top-level or namespace context.
10165 PCC_Namespace,
10166 /// \brief Code completion occurs within a class, struct, or union.
10167 PCC_Class,
10168 /// \brief Code completion occurs within an Objective-C interface, protocol,
10169 /// or category.
10170 PCC_ObjCInterface,
10171 /// \brief Code completion occurs within an Objective-C implementation or
10172 /// category implementation
10173 PCC_ObjCImplementation,
10174 /// \brief Code completion occurs within the list of instance variables
10175 /// in an Objective-C interface, protocol, category, or implementation.
10176 PCC_ObjCInstanceVariableList,
10177 /// \brief Code completion occurs following one or more template
10178 /// headers.
10179 PCC_Template,
10180 /// \brief Code completion occurs following one or more template
10181 /// headers within a class.
10182 PCC_MemberTemplate,
10183 /// \brief Code completion occurs within an expression.
10184 PCC_Expression,
10185 /// \brief Code completion occurs within a statement, which may
10186 /// also be an expression or a declaration.
10187 PCC_Statement,
10188 /// \brief Code completion occurs at the beginning of the
10189 /// initialization statement (or expression) in a for loop.
10190 PCC_ForInit,
10191 /// \brief Code completion occurs within the condition of an if,
10192 /// while, switch, or for statement.
10193 PCC_Condition,
10194 /// \brief Code completion occurs within the body of a function on a
10195 /// recovery path, where we do not have a specific handle on our position
10196 /// in the grammar.
10197 PCC_RecoveryInFunction,
10198 /// \brief Code completion occurs where only a type is permitted.
10199 PCC_Type,
10200 /// \brief Code completion occurs in a parenthesized expression, which
10201 /// might also be a type cast.
10202 PCC_ParenthesizedExpression,
10203 /// \brief Code completion occurs within a sequence of declaration
10204 /// specifiers within a function, method, or block.
10205 PCC_LocalDeclarationSpecifiers
10206 };
10207
10208 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
10209 void CodeCompleteOrdinaryName(Scope *S,
10210 ParserCompletionContext CompletionContext);
10211 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
10212 bool AllowNonIdentifiers,
10213 bool AllowNestedNameSpecifiers);
10214
10215 struct CodeCompleteExpressionData;
10216 void CodeCompleteExpression(Scope *S,
10217 const CodeCompleteExpressionData &Data);
10218 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
10219 SourceLocation OpLoc, bool IsArrow,
10220 bool IsBaseExprStatement);
10221 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS);
10222 void CodeCompleteTag(Scope *S, unsigned TagSpec);
10223 void CodeCompleteTypeQualifiers(DeclSpec &DS);
10224 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
10225 const VirtSpecifiers *VS = nullptr);
10226 void CodeCompleteBracketDeclarator(Scope *S);
10227 void CodeCompleteCase(Scope *S);
10228 void CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args);
10229 void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
10230 ArrayRef<Expr *> Args);
10231 void CodeCompleteInitializer(Scope *S, Decl *D);
10232 void CodeCompleteReturn(Scope *S);
10233 void CodeCompleteAfterIf(Scope *S);
10234 void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS);
10235
10236 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
10237 bool EnteringContext);
10238 void CodeCompleteUsing(Scope *S);
10239 void CodeCompleteUsingDirective(Scope *S);
10240 void CodeCompleteNamespaceDecl(Scope *S);
10241 void CodeCompleteNamespaceAliasDecl(Scope *S);
10242 void CodeCompleteOperatorName(Scope *S);
10243 void CodeCompleteConstructorInitializer(
10244 Decl *Constructor,
10245 ArrayRef<CXXCtorInitializer *> Initializers);
10246
10247 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
10248 bool AfterAmpersand);
10249
10250 void CodeCompleteObjCAtDirective(Scope *S);
10251 void CodeCompleteObjCAtVisibility(Scope *S);
10252 void CodeCompleteObjCAtStatement(Scope *S);
10253 void CodeCompleteObjCAtExpression(Scope *S);
10254 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
10255 void CodeCompleteObjCPropertyGetter(Scope *S);
10256 void CodeCompleteObjCPropertySetter(Scope *S);
10257 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
10258 bool IsParameter);
10259 void CodeCompleteObjCMessageReceiver(Scope *S);
10260 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
10261 ArrayRef<IdentifierInfo *> SelIdents,
10262 bool AtArgumentExpression);
10263 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
10264 ArrayRef<IdentifierInfo *> SelIdents,
10265 bool AtArgumentExpression,
10266 bool IsSuper = false);
10267 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
10268 ArrayRef<IdentifierInfo *> SelIdents,
10269 bool AtArgumentExpression,
10270 ObjCInterfaceDecl *Super = nullptr);
10271 void CodeCompleteObjCForCollection(Scope *S,
10272 DeclGroupPtrTy IterationVar);
10273 void CodeCompleteObjCSelector(Scope *S,
10274 ArrayRef<IdentifierInfo *> SelIdents);
10275 void CodeCompleteObjCProtocolReferences(
10276 ArrayRef<IdentifierLocPair> Protocols);
10277 void CodeCompleteObjCProtocolDecl(Scope *S);
10278 void CodeCompleteObjCInterfaceDecl(Scope *S);
10279 void CodeCompleteObjCSuperclass(Scope *S,
10280 IdentifierInfo *ClassName,
10281 SourceLocation ClassNameLoc);
10282 void CodeCompleteObjCImplementationDecl(Scope *S);
10283 void CodeCompleteObjCInterfaceCategory(Scope *S,
10284 IdentifierInfo *ClassName,
10285 SourceLocation ClassNameLoc);
10286 void CodeCompleteObjCImplementationCategory(Scope *S,
10287 IdentifierInfo *ClassName,
10288 SourceLocation ClassNameLoc);
10289 void CodeCompleteObjCPropertyDefinition(Scope *S);
10290 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
10291 IdentifierInfo *PropertyName);
10292 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
10293 ParsedType ReturnType);
10294 void CodeCompleteObjCMethodDeclSelector(Scope *S,
10295 bool IsInstanceMethod,
10296 bool AtParameterName,
10297 ParsedType ReturnType,
10298 ArrayRef<IdentifierInfo *> SelIdents);
10299 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
10300 SourceLocation ClassNameLoc,
10301 bool IsBaseExprStatement);
10302 void CodeCompletePreprocessorDirective(bool InConditional);
10303 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
10304 void CodeCompletePreprocessorMacroName(bool IsDefinition);
10305 void CodeCompletePreprocessorExpression();
10306 void CodeCompletePreprocessorMacroArgument(Scope *S,
10307 IdentifierInfo *Macro,
10308 MacroInfo *MacroInfo,
10309 unsigned Argument);
10310 void CodeCompleteNaturalLanguage();
10311 void CodeCompleteAvailabilityPlatformName();
10312 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
10313 CodeCompletionTUInfo &CCTUInfo,
10314 SmallVectorImpl<CodeCompletionResult> &Results);
10315 //@}
10316
10317 //===--------------------------------------------------------------------===//
10318 // Extra semantic analysis beyond the C type system
10319
10320public:
10321 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
10322 unsigned ByteNo) const;
10323
10324private:
10325 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
10326 const ArraySubscriptExpr *ASE=nullptr,
10327 bool AllowOnePastEnd=true, bool IndexNegated=false);
10328 void CheckArrayAccess(const Expr *E);
10329 // Used to grab the relevant information from a FormatAttr and a
10330 // FunctionDeclaration.
10331 struct FormatStringInfo {
10332 unsigned FormatIdx;
10333 unsigned FirstDataArg;
10334 bool HasVAListArg;
10335 };
10336
10337 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
10338 FormatStringInfo *FSI);
10339 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
10340 const FunctionProtoType *Proto);
10341 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
10342 ArrayRef<const Expr *> Args);
10343 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
10344 const FunctionProtoType *Proto);
10345 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
10346 void CheckConstructorCall(FunctionDecl *FDecl,
10347 ArrayRef<const Expr *> Args,
10348 const FunctionProtoType *Proto,
10349 SourceLocation Loc);
10350
10351 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
10352 const Expr *ThisArg, ArrayRef<const Expr *> Args,
10353 bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
10354 VariadicCallType CallType);
10355
10356 bool CheckObjCString(Expr *Arg);
10357 ExprResult CheckOSLogFormatStringArg(Expr *Arg);
10358
10359 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
10360 unsigned BuiltinID, CallExpr *TheCall);
10361
10362 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
10363 unsigned MaxWidth);
10364 bool CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10365 bool CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10366
10367 bool CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10368 bool CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10369 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10370 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
10371 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
10372 bool CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10373 bool CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10374
10375 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
10376 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
10377 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
10378 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
10379 bool SemaBuiltinVSX(CallExpr *TheCall);
10380 bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
10381
10382public:
10383 // Used by C++ template instantiation.
10384 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
10385 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
10386 SourceLocation BuiltinLoc,
10387 SourceLocation RParenLoc);
10388
10389private:
10390 bool SemaBuiltinPrefetch(CallExpr *TheCall);
10391 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
10392 bool SemaBuiltinAssume(CallExpr *TheCall);
10393 bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
10394 bool SemaBuiltinLongjmp(CallExpr *TheCall);
10395 bool SemaBuiltinSetjmp(CallExpr *TheCall);
10396 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
10397 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
10398 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
10399 AtomicExpr::AtomicOp Op);
10400 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
10401 bool IsDelete);
10402 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
10403 llvm::APSInt &Result);
10404 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
10405 int Low, int High);
10406 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
10407 unsigned Multiple);
10408 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
10409 int ArgNum, unsigned ExpectedFieldNum,
10410 bool AllowName);
10411public:
10412 enum FormatStringType {
10413 FST_Scanf,
10414 FST_Printf,
10415 FST_NSString,
10416 FST_Strftime,
10417 FST_Strfmon,
10418 FST_Kprintf,
10419 FST_FreeBSDKPrintf,
10420 FST_OSTrace,
10421 FST_OSLog,
10422 FST_Unknown
10423 };
10424 static FormatStringType GetFormatStringType(const FormatAttr *Format);
10425
10426 bool FormatStringHasSArg(const StringLiteral *FExpr);
10427
10428 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);
10429
10430private:
10431 bool CheckFormatArguments(const FormatAttr *Format,
10432 ArrayRef<const Expr *> Args,
10433 bool IsCXXMember,
10434 VariadicCallType CallType,
10435 SourceLocation Loc, SourceRange Range,
10436 llvm::SmallBitVector &CheckedVarArgs);
10437 bool CheckFormatArguments(ArrayRef<const Expr *> Args,
10438 bool HasVAListArg, unsigned format_idx,
10439 unsigned firstDataArg, FormatStringType Type,
10440 VariadicCallType CallType,
10441 SourceLocation Loc, SourceRange range,
10442 llvm::SmallBitVector &CheckedVarArgs);
10443
10444 void CheckAbsoluteValueFunction(const CallExpr *Call,
10445 const FunctionDecl *FDecl);
10446
10447 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
10448
10449 void CheckMemaccessArguments(const CallExpr *Call,
10450 unsigned BId,
10451 IdentifierInfo *FnName);
10452
10453 void CheckStrlcpycatArguments(const CallExpr *Call,
10454 IdentifierInfo *FnName);
10455
10456 void CheckStrncatArguments(const CallExpr *Call,
10457 IdentifierInfo *FnName);
10458
10459 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
10460 SourceLocation ReturnLoc,
10461 bool isObjCMethod = false,
10462 const AttrVec *Attrs = nullptr,
10463 const FunctionDecl *FD = nullptr);
10464
10465public:
10466 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
10467
10468private:
10469 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
10470 void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
10471 void CheckForIntOverflow(Expr *E);
10472 void CheckUnsequencedOperations(Expr *E);
10473
10474 /// \brief Perform semantic checks on a completed expression. This will either
10475 /// be a full-expression or a default argument expression.
10476 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
10477 bool IsConstexpr = false);
10478
10479 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
10480 Expr *Init);
10481
10482 /// Check if there is a field shadowing.
10483 void CheckShadowInheritedFields(const SourceLocation &Loc,
10484 DeclarationName FieldName,
10485 const CXXRecordDecl *RD);
10486
10487 /// \brief Check if the given expression contains 'break' or 'continue'
10488 /// statement that produces control flow different from GCC.
10489 void CheckBreakContinueBinding(Expr *E);
10490
10491 /// \brief Check whether receiver is mutable ObjC container which
10492 /// attempts to add itself into the container
10493 void CheckObjCCircularContainer(ObjCMessageExpr *Message);
10494
10495 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
10496 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
10497 bool DeleteWasArrayForm);
10498public:
10499 /// \brief Register a magic integral constant to be used as a type tag.
10500 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
10501 uint64_t MagicValue, QualType Type,
10502 bool LayoutCompatible, bool MustBeNull);
10503
10504 struct TypeTagData {
10505 TypeTagData() {}
10506
10507 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
10508 Type(Type), LayoutCompatible(LayoutCompatible),
10509 MustBeNull(MustBeNull)
10510 {}
10511
10512 QualType Type;
10513
10514 /// If true, \c Type should be compared with other expression's types for
10515 /// layout-compatibility.
10516 unsigned LayoutCompatible : 1;
10517 unsigned MustBeNull : 1;
10518 };
10519
10520 /// A pair of ArgumentKind identifier and magic value. This uniquely
10521 /// identifies the magic value.
10522 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
10523
10524private:
10525 /// \brief A map from magic value to type information.
10526 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
10527 TypeTagForDatatypeMagicValues;
10528
10529 /// \brief Peform checks on a call of a function with argument_with_type_tag
10530 /// or pointer_with_type_tag attributes.
10531 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
10532 const ArrayRef<const Expr *> ExprArgs,
10533 SourceLocation CallSiteLoc);
10534
10535 /// \brief Check if we are taking the address of a packed field
10536 /// as this may be a problem if the pointer value is dereferenced.
10537 void CheckAddressOfPackedMember(Expr *rhs);
10538
10539 /// \brief The parser's current scope.
10540 ///
10541 /// The parser maintains this state here.
10542 Scope *CurScope;
10543
10544 mutable IdentifierInfo *Ident_super;
10545 mutable IdentifierInfo *Ident___float128;
10546
10547 /// Nullability type specifiers.
10548 IdentifierInfo *Ident__Nonnull = nullptr;
10549 IdentifierInfo *Ident__Nullable = nullptr;
10550 IdentifierInfo *Ident__Null_unspecified = nullptr;
10551
10552 IdentifierInfo *Ident_NSError = nullptr;
10553
10554 /// \brief The handler for the FileChanged preprocessor events.
10555 ///
10556 /// Used for diagnostics that implement custom semantic analysis for #include
10557 /// directives, like -Wpragma-pack.
10558 sema::SemaPPCallbacks *SemaPPCallbackHandler;
10559
10560protected:
10561 friend class Parser;
10562 friend class InitializationSequence;
10563 friend class ASTReader;
10564 friend class ASTDeclReader;
10565 friend class ASTWriter;
10566
10567public:
10568 /// Retrieve the keyword associated
10569 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
10570
10571 /// The struct behind the CFErrorRef pointer.
10572 RecordDecl *CFError = nullptr;
10573
10574 /// Retrieve the identifier "NSError".
10575 IdentifierInfo *getNSErrorIdent();
10576
10577 /// \brief Retrieve the parser's current scope.
10578 ///
10579 /// This routine must only be used when it is certain that semantic analysis
10580 /// and the parser are in precisely the same context, which is not the case
10581 /// when, e.g., we are performing any kind of template instantiation.
10582 /// Therefore, the only safe places to use this scope are in the parser
10583 /// itself and in routines directly invoked from the parser and *never* from
10584 /// template substitution or instantiation.
10585 Scope *getCurScope() const { return CurScope; }
10586
10587 void incrementMSManglingNumber() const {
10588 return CurScope->incrementMSManglingNumber();
10589 }
10590
10591 IdentifierInfo *getSuperIdentifier() const;
10592 IdentifierInfo *getFloat128Identifier() const;
10593
10594 Decl *getObjCDeclContext() const;
10595
10596 DeclContext *getCurLexicalContext() const {
10597 return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
10598 }
10599
10600 const DeclContext *getCurObjCLexicalContext() const {
10601 const DeclContext *DC = getCurLexicalContext();
10602 // A category implicitly has the attribute of the interface.
10603 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
10604 DC = CatD->getClassInterface();
10605 return DC;
10606 }
10607
10608 /// \brief To be used for checking whether the arguments being passed to
10609 /// function exceeds the number of parameters expected for it.
10610 static bool TooManyArguments(size_t NumParams, size_t NumArgs,
10611 bool PartialOverloading = false) {
10612 // We check whether we're just after a comma in code-completion.
10613 if (NumArgs > 0 && PartialOverloading)
10614 return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
10615 return NumArgs > NumParams;
10616 }
10617
10618 // Emitting members of dllexported classes is delayed until the class
10619 // (including field initializers) is fully parsed.
10620 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
10621
10622private:
10623 class SavePendingParsedClassStateRAII {
10624 public:
10625 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
10626
10627 ~SavePendingParsedClassStateRAII() {
10628 assert(S.DelayedExceptionSpecChecks.empty() &&(static_cast <bool> (S.DelayedExceptionSpecChecks.empty
() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10629, __extension__ __PRETTY_FUNCTION__))
10629 "there shouldn't be any pending delayed exception spec checks")(static_cast <bool> (S.DelayedExceptionSpecChecks.empty
() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10629, __extension__ __PRETTY_FUNCTION__))
;
10630 assert(S.DelayedDefaultedMemberExceptionSpecs.empty() &&(static_cast <bool> (S.DelayedDefaultedMemberExceptionSpecs
.empty() && "there shouldn't be any pending delayed defaulted member "
"exception specs") ? void (0) : __assert_fail ("S.DelayedDefaultedMemberExceptionSpecs.empty() && \"there shouldn't be any pending delayed defaulted member \" \"exception specs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10632, __extension__ __PRETTY_FUNCTION__))
10631 "there shouldn't be any pending delayed defaulted member "(static_cast <bool> (S.DelayedDefaultedMemberExceptionSpecs
.empty() && "there shouldn't be any pending delayed defaulted member "
"exception specs") ? void (0) : __assert_fail ("S.DelayedDefaultedMemberExceptionSpecs.empty() && \"there shouldn't be any pending delayed defaulted member \" \"exception specs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10632, __extension__ __PRETTY_FUNCTION__))
10632 "exception specs")(static_cast <bool> (S.DelayedDefaultedMemberExceptionSpecs
.empty() && "there shouldn't be any pending delayed defaulted member "
"exception specs") ? void (0) : __assert_fail ("S.DelayedDefaultedMemberExceptionSpecs.empty() && \"there shouldn't be any pending delayed defaulted member \" \"exception specs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10632, __extension__ __PRETTY_FUNCTION__))
;
10633 assert(S.DelayedDllExportClasses.empty() &&(static_cast <bool> (S.DelayedDllExportClasses.empty() &&
"there shouldn't be any pending delayed DLL export classes")
? void (0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"there shouldn't be any pending delayed DLL export classes\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10634, __extension__ __PRETTY_FUNCTION__))
10634 "there shouldn't be any pending delayed DLL export classes")(static_cast <bool> (S.DelayedDllExportClasses.empty() &&
"there shouldn't be any pending delayed DLL export classes")
? void (0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"there shouldn't be any pending delayed DLL export classes\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/Sema.h"
, 10634, __extension__ __PRETTY_FUNCTION__))
;
10635 swapSavedState();
10636 }
10637
10638 private:
10639 Sema &S;
10640 decltype(DelayedExceptionSpecChecks) SavedExceptionSpecChecks;
10641 decltype(DelayedDefaultedMemberExceptionSpecs)
10642 SavedDefaultedMemberExceptionSpecs;
10643 decltype(DelayedDllExportClasses) SavedDllExportClasses;
10644
10645 void swapSavedState() {
10646 SavedExceptionSpecChecks.swap(S.DelayedExceptionSpecChecks);
10647 SavedDefaultedMemberExceptionSpecs.swap(
10648 S.DelayedDefaultedMemberExceptionSpecs);
10649 SavedDllExportClasses.swap(S.DelayedDllExportClasses);
10650 }
10651 };
10652
10653 /// \brief Helper class that collects misaligned member designations and
10654 /// their location info for delayed diagnostics.
10655 struct MisalignedMember {
10656 Expr *E;
10657 RecordDecl *RD;
10658 ValueDecl *MD;
10659 CharUnits Alignment;
10660
10661 MisalignedMember() : E(), RD(), MD(), Alignment() {}
10662 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
10663 CharUnits Alignment)
10664 : E(E), RD(RD), MD(MD), Alignment(Alignment) {}
10665 explicit MisalignedMember(Expr *E)
10666 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}
10667
10668 bool operator==(const MisalignedMember &m) { return this->E == m.E; }
10669 };
10670 /// \brief Small set of gathered accesses to potentially misaligned members
10671 /// due to the packed attribute.
10672 SmallVector<MisalignedMember, 4> MisalignedMembers;
10673
10674 /// \brief Adds an expression to the set of gathered misaligned members.
10675 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
10676 CharUnits Alignment);
10677
10678public:
10679 /// \brief Diagnoses the current set of gathered accesses. This typically
10680 /// happens at full expression level. The set is cleared after emitting the
10681 /// diagnostics.
10682 void DiagnoseMisalignedMembers();
10683
10684 /// \brief This function checks if the expression is in the sef of potentially
10685 /// misaligned members and it is converted to some pointer type T with lower
10686 /// or equal alignment requirements. If so it removes it. This is used when
10687 /// we do not want to diagnose such misaligned access (e.g. in conversions to
10688 /// void*).
10689 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
10690
10691 /// \brief This function calls Action when it determines that E designates a
10692 /// misaligned member due to the packed attribute. This is used to emit
10693 /// local diagnostics like in reference binding.
10694 void RefersToMemberWithReducedAlignment(
10695 Expr *E,
10696 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
10697 Action);
10698};
10699
10700/// \brief RAII object that enters a new expression evaluation context.
10701class EnterExpressionEvaluationContext {
10702 Sema &Actions;
10703 bool Entered = true;
10704
10705public:
10706
10707 EnterExpressionEvaluationContext(Sema &Actions,
10708 Sema::ExpressionEvaluationContext NewContext,
10709 Decl *LambdaContextDecl = nullptr,
10710 bool IsDecltype = false,
10711 bool ShouldEnter = true)
10712 : Actions(Actions), Entered(ShouldEnter) {
10713 if (Entered)
10714 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
10715 IsDecltype);
10716 }
10717 EnterExpressionEvaluationContext(Sema &Actions,
10718 Sema::ExpressionEvaluationContext NewContext,
10719 Sema::ReuseLambdaContextDecl_t,
10720 bool IsDecltype = false)
10721 : Actions(Actions) {
10722 Actions.PushExpressionEvaluationContext(NewContext,
10723 Sema::ReuseLambdaContextDecl,
10724 IsDecltype);
10725 }
10726
10727 enum InitListTag { InitList };
10728 EnterExpressionEvaluationContext(Sema &Actions, InitListTag,
10729 bool ShouldEnter = true)
10730 : Actions(Actions), Entered(false) {
10731 // In C++11 onwards, narrowing checks are performed on the contents of
10732 // braced-init-lists, even when they occur within unevaluated operands.
10733 // Therefore we still need to instantiate constexpr functions used in such
10734 // a context.
10735 if (ShouldEnter && Actions.isUnevaluatedContext() &&
10736 Actions.getLangOpts().CPlusPlus11) {
10737 Actions.PushExpressionEvaluationContext(
10738 Sema::ExpressionEvaluationContext::UnevaluatedList, nullptr, false);
10739 Entered = true;
10740 }
10741 }
10742
10743 ~EnterExpressionEvaluationContext() {
10744 if (Entered)
10745 Actions.PopExpressionEvaluationContext();
10746 }
10747};
10748
10749DeductionFailureInfo
10750MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
10751 sema::TemplateDeductionInfo &Info);
10752
10753/// \brief Contains a late templated function.
10754/// Will be parsed at the end of the translation unit, used by Sema & Parser.
10755struct LateParsedTemplate {
10756 CachedTokens Toks;
10757 /// \brief The template function declaration to be late parsed.
10758 Decl *D;
10759};
10760
10761} // end namespace clang
10762
10763namespace llvm {
10764// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
10765// SourceLocation.
10766template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
10767 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
10768 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;
10769
10770 static FunctionDeclAndLoc getEmptyKey() {
10771 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};
10772 }
10773
10774 static FunctionDeclAndLoc getTombstoneKey() {
10775 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};
10776 }
10777
10778 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
10779 return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
10780 FDL.Loc.getRawEncoding());
10781 }
10782
10783 static bool isEqual(const FunctionDeclAndLoc &LHS,
10784 const FunctionDeclAndLoc &RHS) {
10785 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
10786 }
10787};
10788} // namespace llvm
10789
10790#endif