clang  6.0.0
SemaExprCXX.cpp
Go to the documentation of this file.
1 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
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 /// \file
11 /// \brief Implements semantic analysis for C++ expressions.
12 ///
13 //===----------------------------------------------------------------------===//
14 
16 #include "TreeTransform.h"
17 #include "TypeLocBuilder.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTLambda.h"
21 #include "clang/AST/CharUnits.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
26 #include "clang/AST/TypeLoc.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Sema/DeclSpec.h"
33 #include "clang/Sema/Lookup.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
37 #include "clang/Sema/SemaLambda.h"
39 #include "llvm/ADT/APInt.h"
40 #include "llvm/ADT/STLExtras.h"
41 #include "llvm/Support/ErrorHandling.h"
42 using namespace clang;
43 using namespace sema;
44 
45 /// \brief Handle the result of the special case name lookup for inheriting
46 /// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
47 /// constructor names in member using declarations, even if 'X' is not the
48 /// name of the corresponding type.
50  SourceLocation NameLoc,
51  IdentifierInfo &Name) {
52  NestedNameSpecifier *NNS = SS.getScopeRep();
53 
54  // Convert the nested-name-specifier into a type.
55  QualType Type;
56  switch (NNS->getKind()) {
59  Type = QualType(NNS->getAsType(), 0);
60  break;
61 
63  // Strip off the last layer of the nested-name-specifier and build a
64  // typename type for it.
65  assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
66  Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
67  NNS->getAsIdentifier());
68  break;
69 
74  llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
75  }
76 
77  // This reference to the type is located entirely at the location of the
78  // final identifier in the qualified-id.
79  return CreateParsedType(Type,
80  Context.getTrivialTypeSourceInfo(Type, NameLoc));
81 }
82 
84  IdentifierInfo &II,
85  SourceLocation NameLoc,
86  Scope *S, CXXScopeSpec &SS,
87  ParsedType ObjectTypePtr,
88  bool EnteringContext) {
89  // Determine where to perform name lookup.
90 
91  // FIXME: This area of the standard is very messy, and the current
92  // wording is rather unclear about which scopes we search for the
93  // destructor name; see core issues 399 and 555. Issue 399 in
94  // particular shows where the current description of destructor name
95  // lookup is completely out of line with existing practice, e.g.,
96  // this appears to be ill-formed:
97  //
98  // namespace N {
99  // template <typename T> struct S {
100  // ~S();
101  // };
102  // }
103  //
104  // void f(N::S<int>* s) {
105  // s->N::S<int>::~S();
106  // }
107  //
108  // See also PR6358 and PR6359.
109  // For this reason, we're currently only doing the C++03 version of this
110  // code; the C++0x version has to wait until we get a proper spec.
111  QualType SearchType;
112  DeclContext *LookupCtx = nullptr;
113  bool isDependent = false;
114  bool LookInScope = false;
115 
116  if (SS.isInvalid())
117  return nullptr;
118 
119  // If we have an object type, it's because we are in a
120  // pseudo-destructor-expression or a member access expression, and
121  // we know what type we're looking for.
122  if (ObjectTypePtr)
123  SearchType = GetTypeFromParser(ObjectTypePtr);
124 
125  if (SS.isSet()) {
126  NestedNameSpecifier *NNS = SS.getScopeRep();
127 
128  bool AlreadySearched = false;
129  bool LookAtPrefix = true;
130  // C++11 [basic.lookup.qual]p6:
131  // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
132  // the type-names are looked up as types in the scope designated by the
133  // nested-name-specifier. Similarly, in a qualified-id of the form:
134  //
135  // nested-name-specifier[opt] class-name :: ~ class-name
136  //
137  // the second class-name is looked up in the same scope as the first.
138  //
139  // Here, we determine whether the code below is permitted to look at the
140  // prefix of the nested-name-specifier.
141  DeclContext *DC = computeDeclContext(SS, EnteringContext);
142  if (DC && DC->isFileContext()) {
143  AlreadySearched = true;
144  LookupCtx = DC;
145  isDependent = false;
146  } else if (DC && isa<CXXRecordDecl>(DC)) {
147  LookAtPrefix = false;
148  LookInScope = true;
149  }
150 
151  // The second case from the C++03 rules quoted further above.
152  NestedNameSpecifier *Prefix = nullptr;
153  if (AlreadySearched) {
154  // Nothing left to do.
155  } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
156  CXXScopeSpec PrefixSS;
157  PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
158  LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
159  isDependent = isDependentScopeSpecifier(PrefixSS);
160  } else if (ObjectTypePtr) {
161  LookupCtx = computeDeclContext(SearchType);
162  isDependent = SearchType->isDependentType();
163  } else {
164  LookupCtx = computeDeclContext(SS, EnteringContext);
165  isDependent = LookupCtx && LookupCtx->isDependentContext();
166  }
167  } else if (ObjectTypePtr) {
168  // C++ [basic.lookup.classref]p3:
169  // If the unqualified-id is ~type-name, the type-name is looked up
170  // in the context of the entire postfix-expression. If the type T
171  // of the object expression is of a class type C, the type-name is
172  // also looked up in the scope of class C. At least one of the
173  // lookups shall find a name that refers to (possibly
174  // cv-qualified) T.
175  LookupCtx = computeDeclContext(SearchType);
176  isDependent = SearchType->isDependentType();
177  assert((isDependent || !SearchType->isIncompleteType()) &&
178  "Caller should have completed object type");
179 
180  LookInScope = true;
181  } else {
182  // Perform lookup into the current scope (only).
183  LookInScope = true;
184  }
185 
186  TypeDecl *NonMatchingTypeDecl = nullptr;
187  LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
188  for (unsigned Step = 0; Step != 2; ++Step) {
189  // Look for the name first in the computed lookup context (if we
190  // have one) and, if that fails to find a match, in the scope (if
191  // we're allowed to look there).
192  Found.clear();
193  if (Step == 0 && LookupCtx) {
194  if (RequireCompleteDeclContext(SS, LookupCtx))
195  return nullptr;
196  LookupQualifiedName(Found, LookupCtx);
197  } else if (Step == 1 && LookInScope && S) {
198  LookupName(Found, S);
199  } else {
200  continue;
201  }
202 
203  // FIXME: Should we be suppressing ambiguities here?
204  if (Found.isAmbiguous())
205  return nullptr;
206 
207  if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
208  QualType T = Context.getTypeDeclType(Type);
209  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
210 
211  if (SearchType.isNull() || SearchType->isDependentType() ||
212  Context.hasSameUnqualifiedType(T, SearchType)) {
213  // We found our type!
214 
215  return CreateParsedType(T,
216  Context.getTrivialTypeSourceInfo(T, NameLoc));
217  }
218 
219  if (!SearchType.isNull())
220  NonMatchingTypeDecl = Type;
221  }
222 
223  // If the name that we found is a class template name, and it is
224  // the same name as the template name in the last part of the
225  // nested-name-specifier (if present) or the object type, then
226  // this is the destructor for that class.
227  // FIXME: This is a workaround until we get real drafting for core
228  // issue 399, for which there isn't even an obvious direction.
229  if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
230  QualType MemberOfType;
231  if (SS.isSet()) {
232  if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
233  // Figure out the type of the context, if it has one.
234  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
235  MemberOfType = Context.getTypeDeclType(Record);
236  }
237  }
238  if (MemberOfType.isNull())
239  MemberOfType = SearchType;
240 
241  if (MemberOfType.isNull())
242  continue;
243 
244  // We're referring into a class template specialization. If the
245  // class template we found is the same as the template being
246  // specialized, we found what we are looking for.
247  if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
249  = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
250  if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
251  Template->getCanonicalDecl())
252  return CreateParsedType(
253  MemberOfType,
254  Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
255  }
256 
257  continue;
258  }
259 
260  // We're referring to an unresolved class template
261  // specialization. Determine whether we class template we found
262  // is the same as the template being specialized or, if we don't
263  // know which template is being specialized, that it at least
264  // has the same name.
265  if (const TemplateSpecializationType *SpecType
266  = MemberOfType->getAs<TemplateSpecializationType>()) {
267  TemplateName SpecName = SpecType->getTemplateName();
268 
269  // The class template we found is the same template being
270  // specialized.
271  if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
272  if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
273  return CreateParsedType(
274  MemberOfType,
275  Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
276 
277  continue;
278  }
279 
280  // The class template we found has the same name as the
281  // (dependent) template name being specialized.
282  if (DependentTemplateName *DepTemplate
283  = SpecName.getAsDependentTemplateName()) {
284  if (DepTemplate->isIdentifier() &&
285  DepTemplate->getIdentifier() == Template->getIdentifier())
286  return CreateParsedType(
287  MemberOfType,
288  Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
289 
290  continue;
291  }
292  }
293  }
294  }
295 
296  if (isDependent) {
297  // We didn't find our type, but that's okay: it's dependent
298  // anyway.
299 
300  // FIXME: What if we have no nested-name-specifier?
301  QualType T = CheckTypenameType(ETK_None, SourceLocation(),
302  SS.getWithLocInContext(Context),
303  II, NameLoc);
304  return ParsedType::make(T);
305  }
306 
307  if (NonMatchingTypeDecl) {
308  QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
309  Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
310  << T << SearchType;
311  Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
312  << T;
313  } else if (ObjectTypePtr)
314  Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
315  << &II;
316  else {
317  SemaDiagnosticBuilder DtorDiag = Diag(NameLoc,
318  diag::err_destructor_class_name);
319  if (S) {
320  const DeclContext *Ctx = S->getEntity();
321  if (const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
322  DtorDiag << FixItHint::CreateReplacement(SourceRange(NameLoc),
323  Class->getNameAsString());
324  }
325  }
326 
327  return nullptr;
328 }
329 
331  ParsedType ObjectType) {
333  return nullptr;
334 
336  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
337  return nullptr;
338  }
339 
340  assert(DS.getTypeSpecType() == DeclSpec::TST_decltype &&
341  "unexpected type in getDestructorType");
342  QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
343 
344  // If we know the type of the object, check that the correct destructor
345  // type was named now; we can give better diagnostics this way.
346  QualType SearchType = GetTypeFromParser(ObjectType);
347  if (!SearchType.isNull() && !SearchType->isDependentType() &&
348  !Context.hasSameUnqualifiedType(T, SearchType)) {
349  Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
350  << T << SearchType;
351  return nullptr;
352  }
353 
354  return ParsedType::make(T);
355 }
356 
358  const UnqualifiedId &Name) {
360 
361  if (!SS.isValid())
362  return false;
363 
364  switch (SS.getScopeRep()->getKind()) {
368  // Per C++11 [over.literal]p2, literal operators can only be declared at
369  // namespace scope. Therefore, this unqualified-id cannot name anything.
370  // Reject it early, because we have no AST representation for this in the
371  // case where the scope is dependent.
372  Diag(Name.getLocStart(), diag::err_literal_operator_id_outside_namespace)
373  << SS.getScopeRep();
374  return true;
375 
380  return false;
381  }
382 
383  llvm_unreachable("unknown nested name specifier kind");
384 }
385 
386 /// \brief Build a C++ typeid expression with a type operand.
388  SourceLocation TypeidLoc,
389  TypeSourceInfo *Operand,
390  SourceLocation RParenLoc) {
391  // C++ [expr.typeid]p4:
392  // The top-level cv-qualifiers of the lvalue expression or the type-id
393  // that is the operand of typeid are always ignored.
394  // If the type of the type-id is a class type or a reference to a class
395  // type, the class shall be completely-defined.
396  Qualifiers Quals;
397  QualType T
398  = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
399  Quals);
400  if (T->getAs<RecordType>() &&
401  RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
402  return ExprError();
403 
404  if (T->isVariablyModifiedType())
405  return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
406 
407  return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
408  SourceRange(TypeidLoc, RParenLoc));
409 }
410 
411 /// \brief Build a C++ typeid expression with an expression operand.
413  SourceLocation TypeidLoc,
414  Expr *E,
415  SourceLocation RParenLoc) {
416  bool WasEvaluated = false;
417  if (E && !E->isTypeDependent()) {
418  if (E->getType()->isPlaceholderType()) {
419  ExprResult result = CheckPlaceholderExpr(E);
420  if (result.isInvalid()) return ExprError();
421  E = result.get();
422  }
423 
424  QualType T = E->getType();
425  if (const RecordType *RecordT = T->getAs<RecordType>()) {
426  CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
427  // C++ [expr.typeid]p3:
428  // [...] If the type of the expression is a class type, the class
429  // shall be completely-defined.
430  if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
431  return ExprError();
432 
433  // C++ [expr.typeid]p3:
434  // When typeid is applied to an expression other than an glvalue of a
435  // polymorphic class type [...] [the] expression is an unevaluated
436  // operand. [...]
437  if (RecordD->isPolymorphic() && E->isGLValue()) {
438  // The subexpression is potentially evaluated; switch the context
439  // and recheck the subexpression.
440  ExprResult Result = TransformToPotentiallyEvaluated(E);
441  if (Result.isInvalid()) return ExprError();
442  E = Result.get();
443 
444  // We require a vtable to query the type at run time.
445  MarkVTableUsed(TypeidLoc, RecordD);
446  WasEvaluated = true;
447  }
448  }
449 
450  // C++ [expr.typeid]p4:
451  // [...] If the type of the type-id is a reference to a possibly
452  // cv-qualified type, the result of the typeid expression refers to a
453  // std::type_info object representing the cv-unqualified referenced
454  // type.
455  Qualifiers Quals;
456  QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
457  if (!Context.hasSameType(T, UnqualT)) {
458  T = UnqualT;
459  E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();
460  }
461  }
462 
463  if (E->getType()->isVariablyModifiedType())
464  return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)
465  << E->getType());
466  else if (!inTemplateInstantiation() &&
467  E->HasSideEffects(Context, WasEvaluated)) {
468  // The expression operand for typeid is in an unevaluated expression
469  // context, so side effects could result in unintended consequences.
470  Diag(E->getExprLoc(), WasEvaluated
471  ? diag::warn_side_effects_typeid
472  : diag::warn_side_effects_unevaluated_context);
473  }
474 
475  return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,
476  SourceRange(TypeidLoc, RParenLoc));
477 }
478 
479 /// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
482  bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
483  // Find the std::type_info type.
484  if (!getStdNamespace())
485  return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
486 
487  if (!CXXTypeInfoDecl) {
488  IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
489  LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
490  LookupQualifiedName(R, getStdNamespace());
491  CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
492  // Microsoft's typeinfo doesn't have type_info in std but in the global
493  // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
494  if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
495  LookupQualifiedName(R, Context.getTranslationUnitDecl());
496  CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
497  }
498  if (!CXXTypeInfoDecl)
499  return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
500  }
501 
502  if (!getLangOpts().RTTI) {
503  return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
504  }
505 
506  QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
507 
508  if (isType) {
509  // The operand is a type; handle it as such.
510  TypeSourceInfo *TInfo = nullptr;
511  QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
512  &TInfo);
513  if (T.isNull())
514  return ExprError();
515 
516  if (!TInfo)
517  TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
518 
519  return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
520  }
521 
522  // The operand is an expression.
523  return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
524 }
525 
526 /// Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to
527 /// a single GUID.
528 static void
531  // Optionally remove one level of pointer, reference or array indirection.
532  const Type *Ty = QT.getTypePtr();
533  if (QT->isPointerType() || QT->isReferenceType())
534  Ty = QT->getPointeeType().getTypePtr();
535  else if (QT->isArrayType())
536  Ty = Ty->getBaseElementTypeUnsafe();
537 
538  const auto *TD = Ty->getAsTagDecl();
539  if (!TD)
540  return;
541 
542  if (const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
543  UuidAttrs.insert(Uuid);
544  return;
545  }
546 
547  // __uuidof can grab UUIDs from template arguments.
548  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
549  const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
550  for (const TemplateArgument &TA : TAL.asArray()) {
551  const UuidAttr *UuidForTA = nullptr;
552  if (TA.getKind() == TemplateArgument::Type)
553  getUuidAttrOfType(SemaRef, TA.getAsType(), UuidAttrs);
554  else if (TA.getKind() == TemplateArgument::Declaration)
555  getUuidAttrOfType(SemaRef, TA.getAsDecl()->getType(), UuidAttrs);
556 
557  if (UuidForTA)
558  UuidAttrs.insert(UuidForTA);
559  }
560  }
561 }
562 
563 /// \brief Build a Microsoft __uuidof expression with a type operand.
565  SourceLocation TypeidLoc,
566  TypeSourceInfo *Operand,
567  SourceLocation RParenLoc) {
568  StringRef UuidStr;
569  if (!Operand->getType()->isDependentType()) {
571  getUuidAttrOfType(*this, Operand->getType(), UuidAttrs);
572  if (UuidAttrs.empty())
573  return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
574  if (UuidAttrs.size() > 1)
575  return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
576  UuidStr = UuidAttrs.back()->getGuid();
577  }
578 
579  return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), Operand, UuidStr,
580  SourceRange(TypeidLoc, RParenLoc));
581 }
582 
583 /// \brief Build a Microsoft __uuidof expression with an expression operand.
585  SourceLocation TypeidLoc,
586  Expr *E,
587  SourceLocation RParenLoc) {
588  StringRef UuidStr;
589  if (!E->getType()->isDependentType()) {
591  UuidStr = "00000000-0000-0000-0000-000000000000";
592  } else {
594  getUuidAttrOfType(*this, E->getType(), UuidAttrs);
595  if (UuidAttrs.empty())
596  return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
597  if (UuidAttrs.size() > 1)
598  return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
599  UuidStr = UuidAttrs.back()->getGuid();
600  }
601  }
602 
603  return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), E, UuidStr,
604  SourceRange(TypeidLoc, RParenLoc));
605 }
606 
607 /// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
610  bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
611  // If MSVCGuidDecl has not been cached, do the lookup.
612  if (!MSVCGuidDecl) {
613  IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
614  LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
615  LookupQualifiedName(R, Context.getTranslationUnitDecl());
616  MSVCGuidDecl = R.getAsSingle<RecordDecl>();
617  if (!MSVCGuidDecl)
618  return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
619  }
620 
621  QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
622 
623  if (isType) {
624  // The operand is a type; handle it as such.
625  TypeSourceInfo *TInfo = nullptr;
626  QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
627  &TInfo);
628  if (T.isNull())
629  return ExprError();
630 
631  if (!TInfo)
632  TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
633 
634  return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
635  }
636 
637  // The operand is an expression.
638  return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
639 }
640 
641 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
644  assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
645  "Unknown C++ Boolean value!");
646  return new (Context)
647  CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);
648 }
649 
650 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
653  return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
654 }
655 
656 /// ActOnCXXThrow - Parse throw expressions.
659  bool IsThrownVarInScope = false;
660  if (Ex) {
661  // C++0x [class.copymove]p31:
662  // When certain criteria are met, an implementation is allowed to omit the
663  // copy/move construction of a class object [...]
664  //
665  // - in a throw-expression, when the operand is the name of a
666  // non-volatile automatic object (other than a function or catch-
667  // clause parameter) whose scope does not extend beyond the end of the
668  // innermost enclosing try-block (if there is one), the copy/move
669  // operation from the operand to the exception object (15.1) can be
670  // omitted by constructing the automatic object directly into the
671  // exception object
672  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
673  if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
674  if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
675  for( ; S; S = S->getParent()) {
676  if (S->isDeclScope(Var)) {
677  IsThrownVarInScope = true;
678  break;
679  }
680 
681  if (S->getFlags() &
685  break;
686  }
687  }
688  }
689  }
690 
691  return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
692 }
693 
695  bool IsThrownVarInScope) {
696  // Don't report an error if 'throw' is used in system headers.
697  if (!getLangOpts().CXXExceptions &&
698  !getSourceManager().isInSystemHeader(OpLoc))
699  Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
700 
701  // Exceptions aren't allowed in CUDA device code.
702  if (getLangOpts().CUDA)
703  CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
704  << "throw" << CurrentCUDATarget();
705 
706  if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
707  Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
708 
709  if (Ex && !Ex->isTypeDependent()) {
710  QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
711  if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
712  return ExprError();
713 
714  // Initialize the exception result. This implicitly weeds out
715  // abstract types or types with inaccessible copy constructors.
716 
717  // C++0x [class.copymove]p31:
718  // When certain criteria are met, an implementation is allowed to omit the
719  // copy/move construction of a class object [...]
720  //
721  // - in a throw-expression, when the operand is the name of a
722  // non-volatile automatic object (other than a function or
723  // catch-clause
724  // parameter) whose scope does not extend beyond the end of the
725  // innermost enclosing try-block (if there is one), the copy/move
726  // operation from the operand to the exception object (15.1) can be
727  // omitted by constructing the automatic object directly into the
728  // exception object
729  const VarDecl *NRVOVariable = nullptr;
730  if (IsThrownVarInScope)
731  NRVOVariable = getCopyElisionCandidate(QualType(), Ex, false);
732 
734  OpLoc, ExceptionObjectTy,
735  /*NRVO=*/NRVOVariable != nullptr);
736  ExprResult Res = PerformMoveOrCopyInitialization(
737  Entity, NRVOVariable, QualType(), Ex, IsThrownVarInScope);
738  if (Res.isInvalid())
739  return ExprError();
740  Ex = Res.get();
741  }
742 
743  return new (Context)
744  CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);
745 }
746 
747 static void
749  llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
750  llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
751  llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
752  bool ParentIsPublic) {
753  for (const CXXBaseSpecifier &BS : RD->bases()) {
754  CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
755  bool NewSubobject;
756  // Virtual bases constitute the same subobject. Non-virtual bases are
757  // always distinct subobjects.
758  if (BS.isVirtual())
759  NewSubobject = VBases.insert(BaseDecl).second;
760  else
761  NewSubobject = true;
762 
763  if (NewSubobject)
764  ++SubobjectsSeen[BaseDecl];
765 
766  // Only add subobjects which have public access throughout the entire chain.
767  bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;
768  if (PublicPath)
769  PublicSubobjectsSeen.insert(BaseDecl);
770 
771  // Recurse on to each base subobject.
772  collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,
773  PublicPath);
774  }
775 }
776 
779  llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
780  llvm::SmallSet<CXXRecordDecl *, 2> VBases;
781  llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
782  SubobjectsSeen[RD] = 1;
783  PublicSubobjectsSeen.insert(RD);
784  collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,
785  /*ParentIsPublic=*/true);
786 
787  for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
788  // Skip ambiguous objects.
789  if (SubobjectsSeen[PublicSubobject] > 1)
790  continue;
791 
792  Objects.push_back(PublicSubobject);
793  }
794 }
795 
796 /// CheckCXXThrowOperand - Validate the operand of a throw.
798  QualType ExceptionObjectTy, Expr *E) {
799  // If the type of the exception would be an incomplete type or a pointer
800  // to an incomplete type other than (cv) void the program is ill-formed.
801  QualType Ty = ExceptionObjectTy;
802  bool isPointer = false;
803  if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
804  Ty = Ptr->getPointeeType();
805  isPointer = true;
806  }
807  if (!isPointer || !Ty->isVoidType()) {
808  if (RequireCompleteType(ThrowLoc, Ty,
809  isPointer ? diag::err_throw_incomplete_ptr
810  : diag::err_throw_incomplete,
811  E->getSourceRange()))
812  return true;
813 
814  if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
815  diag::err_throw_abstract_type, E))
816  return true;
817  }
818 
819  // If the exception has class type, we need additional handling.
820  CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
821  if (!RD)
822  return false;
823 
824  // If we are throwing a polymorphic class type or pointer thereof,
825  // exception handling will make use of the vtable.
826  MarkVTableUsed(ThrowLoc, RD);
827 
828  // If a pointer is thrown, the referenced object will not be destroyed.
829  if (isPointer)
830  return false;
831 
832  // If the class has a destructor, we must be able to call it.
833  if (!RD->hasIrrelevantDestructor()) {
834  if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
835  MarkFunctionReferenced(E->getExprLoc(), Destructor);
836  CheckDestructorAccess(E->getExprLoc(), Destructor,
837  PDiag(diag::err_access_dtor_exception) << Ty);
838  if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
839  return true;
840  }
841  }
842 
843  // The MSVC ABI creates a list of all types which can catch the exception
844  // object. This list also references the appropriate copy constructor to call
845  // if the object is caught by value and has a non-trivial copy constructor.
846  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
847  // We are only interested in the public, unambiguous bases contained within
848  // the exception object. Bases which are ambiguous or otherwise
849  // inaccessible are not catchable types.
850  llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;
851  getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);
852 
853  for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
854  // Attempt to lookup the copy constructor. Various pieces of machinery
855  // will spring into action, like template instantiation, which means this
856  // cannot be a simple walk of the class's decls. Instead, we must perform
857  // lookup and overload resolution.
858  CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);
859  if (!CD)
860  continue;
861 
862  // Mark the constructor referenced as it is used by this throw expression.
863  MarkFunctionReferenced(E->getExprLoc(), CD);
864 
865  // Skip this copy constructor if it is trivial, we don't need to record it
866  // in the catchable type data.
867  if (CD->isTrivial())
868  continue;
869 
870  // The copy constructor is non-trivial, create a mapping from this class
871  // type to this constructor.
872  // N.B. The selection of copy constructor is not sensitive to this
873  // particular throw-site. Lookup will be performed at the catch-site to
874  // ensure that the copy constructor is, in fact, accessible (via
875  // friendship or any other means).
876  Context.addCopyConstructorForExceptionObject(Subobject, CD);
877 
878  // We don't keep the instantiated default argument expressions around so
879  // we must rebuild them here.
880  for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
881  if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)))
882  return true;
883  }
884  }
885  }
886 
887  return false;
888 }
889 
891  ArrayRef<FunctionScopeInfo *> FunctionScopes, QualType ThisTy,
892  DeclContext *CurSemaContext, ASTContext &ASTCtx) {
893 
894  QualType ClassType = ThisTy->getPointeeType();
895  LambdaScopeInfo *CurLSI = nullptr;
896  DeclContext *CurDC = CurSemaContext;
897 
898  // Iterate through the stack of lambdas starting from the innermost lambda to
899  // the outermost lambda, checking if '*this' is ever captured by copy - since
900  // that could change the cv-qualifiers of the '*this' object.
901  // The object referred to by '*this' starts out with the cv-qualifiers of its
902  // member function. We then start with the innermost lambda and iterate
903  // outward checking to see if any lambda performs a by-copy capture of '*this'
904  // - and if so, any nested lambda must respect the 'constness' of that
905  // capturing lamdbda's call operator.
906  //
907 
908  // Since the FunctionScopeInfo stack is representative of the lexical
909  // nesting of the lambda expressions during initial parsing (and is the best
910  // place for querying information about captures about lambdas that are
911  // partially processed) and perhaps during instantiation of function templates
912  // that contain lambda expressions that need to be transformed BUT not
913  // necessarily during instantiation of a nested generic lambda's function call
914  // operator (which might even be instantiated at the end of the TU) - at which
915  // time the DeclContext tree is mature enough to query capture information
916  // reliably - we use a two pronged approach to walk through all the lexically
917  // enclosing lambda expressions:
918  //
919  // 1) Climb down the FunctionScopeInfo stack as long as each item represents
920  // a Lambda (i.e. LambdaScopeInfo) AND each LSI's 'closure-type' is lexically
921  // enclosed by the call-operator of the LSI below it on the stack (while
922  // tracking the enclosing DC for step 2 if needed). Note the topmost LSI on
923  // the stack represents the innermost lambda.
924  //
925  // 2) If we run out of enclosing LSI's, check if the enclosing DeclContext
926  // represents a lambda's call operator. If it does, we must be instantiating
927  // a generic lambda's call operator (represented by the Current LSI, and
928  // should be the only scenario where an inconsistency between the LSI and the
929  // DeclContext should occur), so climb out the DeclContexts if they
930  // represent lambdas, while querying the corresponding closure types
931  // regarding capture information.
932 
933  // 1) Climb down the function scope info stack.
934  for (int I = FunctionScopes.size();
935  I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
936  (!CurLSI || !CurLSI->Lambda || CurLSI->Lambda->getDeclContext() ==
937  cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
938  CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
939  CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
940 
941  if (!CurLSI->isCXXThisCaptured())
942  continue;
943 
944  auto C = CurLSI->getCXXThisCapture();
945 
946  if (C.isCopyCapture()) {
948  if (CurLSI->CallOperator->isConst())
949  ClassType.addConst();
950  return ASTCtx.getPointerType(ClassType);
951  }
952  }
953 
954  // 2) We've run out of ScopeInfos but check if CurDC is a lambda (which can
955  // happen during instantiation of its nested generic lambda call operator)
956  if (isLambdaCallOperator(CurDC)) {
957  assert(CurLSI && "While computing 'this' capture-type for a generic "
958  "lambda, we must have a corresponding LambdaScopeInfo");
960  "While computing 'this' capture-type for a generic lambda, when we "
961  "run out of enclosing LSI's, yet the enclosing DC is a "
962  "lambda-call-operator we must be (i.e. Current LSI) in a generic "
963  "lambda call oeprator");
964  assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator));
965 
966  auto IsThisCaptured =
967  [](CXXRecordDecl *Closure, bool &IsByCopy, bool &IsConst) {
968  IsConst = false;
969  IsByCopy = false;
970  for (auto &&C : Closure->captures()) {
971  if (C.capturesThis()) {
972  if (C.getCaptureKind() == LCK_StarThis)
973  IsByCopy = true;
974  if (Closure->getLambdaCallOperator()->isConst())
975  IsConst = true;
976  return true;
977  }
978  }
979  return false;
980  };
981 
982  bool IsByCopyCapture = false;
983  bool IsConstCapture = false;
984  CXXRecordDecl *Closure = cast<CXXRecordDecl>(CurDC->getParent());
985  while (Closure &&
986  IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
987  if (IsByCopyCapture) {
989  if (IsConstCapture)
990  ClassType.addConst();
991  return ASTCtx.getPointerType(ClassType);
992  }
993  Closure = isLambdaCallOperator(Closure->getParent())
994  ? cast<CXXRecordDecl>(Closure->getParent()->getParent())
995  : nullptr;
996  }
997  }
998  return ASTCtx.getPointerType(ClassType);
999 }
1000 
1002  DeclContext *DC = getFunctionLevelDeclContext();
1003  QualType ThisTy = CXXThisTypeOverride;
1004 
1005  if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
1006  if (method && method->isInstance())
1007  ThisTy = method->getThisType(Context);
1008  }
1009 
1010  if (ThisTy.isNull() && isLambdaCallOperator(CurContext) &&
1011  inTemplateInstantiation()) {
1012 
1013  assert(isa<CXXRecordDecl>(DC) &&
1014  "Trying to get 'this' type from static method?");
1015 
1016  // This is a lambda call operator that is being instantiated as a default
1017  // initializer. DC must point to the enclosing class type, so we can recover
1018  // the 'this' type from it.
1019 
1020  QualType ClassTy = Context.getTypeDeclType(cast<CXXRecordDecl>(DC));
1021  // There are no cv-qualifiers for 'this' within default initializers,
1022  // per [expr.prim.general]p4.
1023  ThisTy = Context.getPointerType(ClassTy);
1024  }
1025 
1026  // If we are within a lambda's call operator, the cv-qualifiers of 'this'
1027  // might need to be adjusted if the lambda or any of its enclosing lambda's
1028  // captures '*this' by copy.
1029  if (!ThisTy.isNull() && isLambdaCallOperator(CurContext))
1030  return adjustCVQualifiersForCXXThisWithinLambda(FunctionScopes, ThisTy,
1031  CurContext, Context);
1032  return ThisTy;
1033 }
1034 
1036  Decl *ContextDecl,
1037  unsigned CXXThisTypeQuals,
1038  bool Enabled)
1039  : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
1040 {
1041  if (!Enabled || !ContextDecl)
1042  return;
1043 
1044  CXXRecordDecl *Record = nullptr;
1045  if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
1046  Record = Template->getTemplatedDecl();
1047  else
1048  Record = cast<CXXRecordDecl>(ContextDecl);
1049 
1050  // We care only for CVR qualifiers here, so cut everything else.
1051  CXXThisTypeQuals &= Qualifiers::FastMask;
1053  = S.Context.getPointerType(
1054  S.Context.getRecordType(Record).withCVRQualifiers(CXXThisTypeQuals));
1055 
1056  this->Enabled = true;
1057 }
1058 
1059 
1061  if (Enabled) {
1062  S.CXXThisTypeOverride = OldCXXThisTypeOverride;
1063  }
1064 }
1065 
1067  QualType ThisTy, SourceLocation Loc,
1068  const bool ByCopy) {
1069 
1070  QualType AdjustedThisTy = ThisTy;
1071  // The type of the corresponding data member (not a 'this' pointer if 'by
1072  // copy').
1073  QualType CaptureThisFieldTy = ThisTy;
1074  if (ByCopy) {
1075  // If we are capturing the object referred to by '*this' by copy, ignore any
1076  // cv qualifiers inherited from the type of the member function for the type
1077  // of the closure-type's corresponding data member and any use of 'this'.
1078  CaptureThisFieldTy = ThisTy->getPointeeType();
1079  CaptureThisFieldTy.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1080  AdjustedThisTy = Context.getPointerType(CaptureThisFieldTy);
1081  }
1082 
1083  FieldDecl *Field = FieldDecl::Create(
1084  Context, RD, Loc, Loc, nullptr, CaptureThisFieldTy,
1085  Context.getTrivialTypeSourceInfo(CaptureThisFieldTy, Loc), nullptr, false,
1086  ICIS_NoInit);
1087 
1088  Field->setImplicit(true);
1089  Field->setAccess(AS_private);
1090  RD->addDecl(Field);
1091  Expr *This =
1092  new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/ true);
1093  if (ByCopy) {
1094  Expr *StarThis = S.CreateBuiltinUnaryOp(Loc,
1095  UO_Deref,
1096  This).get();
1098  nullptr, CaptureThisFieldTy, Loc);
1099  InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
1100  InitializationSequence Init(S, Entity, InitKind, StarThis);
1101  ExprResult ER = Init.Perform(S, Entity, InitKind, StarThis);
1102  if (ER.isInvalid()) return nullptr;
1103  return ER.get();
1104  }
1105  return This;
1106 }
1107 
1108 bool Sema::CheckCXXThisCapture(SourceLocation Loc, const bool Explicit,
1109  bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt,
1110  const bool ByCopy) {
1111  // We don't need to capture this in an unevaluated context.
1112  if (isUnevaluatedContext() && !Explicit)
1113  return true;
1114 
1115  assert((!ByCopy || Explicit) && "cannot implicitly capture *this by value");
1116 
1117  const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt ?
1118  *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
1119 
1120  // Check that we can capture the *enclosing object* (referred to by '*this')
1121  // by the capturing-entity/closure (lambda/block/etc) at
1122  // MaxFunctionScopesIndex-deep on the FunctionScopes stack.
1123 
1124  // Note: The *enclosing object* can only be captured by-value by a
1125  // closure that is a lambda, using the explicit notation:
1126  // [*this] { ... }.
1127  // Every other capture of the *enclosing object* results in its by-reference
1128  // capture.
1129 
1130  // For a closure 'L' (at MaxFunctionScopesIndex in the FunctionScopes
1131  // stack), we can capture the *enclosing object* only if:
1132  // - 'L' has an explicit byref or byval capture of the *enclosing object*
1133  // - or, 'L' has an implicit capture.
1134  // AND
1135  // -- there is no enclosing closure
1136  // -- or, there is some enclosing closure 'E' that has already captured the
1137  // *enclosing object*, and every intervening closure (if any) between 'E'
1138  // and 'L' can implicitly capture the *enclosing object*.
1139  // -- or, every enclosing closure can implicitly capture the
1140  // *enclosing object*
1141 
1142 
1143  unsigned NumCapturingClosures = 0;
1144  for (unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {
1145  if (CapturingScopeInfo *CSI =
1146  dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
1147  if (CSI->CXXThisCaptureIndex != 0) {
1148  // 'this' is already being captured; there isn't anything more to do.
1149  CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1150  break;
1151  }
1152  LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
1154  // This context can't implicitly capture 'this'; fail out.
1155  if (BuildAndDiagnose)
1156  Diag(Loc, diag::err_this_capture)
1157  << (Explicit && idx == MaxFunctionScopesIndex);
1158  return true;
1159  }
1160  if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
1161  CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
1162  CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
1163  CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
1164  (Explicit && idx == MaxFunctionScopesIndex)) {
1165  // Regarding (Explicit && idx == MaxFunctionScopesIndex): only the first
1166  // iteration through can be an explicit capture, all enclosing closures,
1167  // if any, must perform implicit captures.
1168 
1169  // This closure can capture 'this'; continue looking upwards.
1170  NumCapturingClosures++;
1171  continue;
1172  }
1173  // This context can't implicitly capture 'this'; fail out.
1174  if (BuildAndDiagnose)
1175  Diag(Loc, diag::err_this_capture)
1176  << (Explicit && idx == MaxFunctionScopesIndex);
1177  return true;
1178  }
1179  break;
1180  }
1181  if (!BuildAndDiagnose) return false;
1182 
1183  // If we got here, then the closure at MaxFunctionScopesIndex on the
1184  // FunctionScopes stack, can capture the *enclosing object*, so capture it
1185  // (including implicit by-reference captures in any enclosing closures).
1186 
1187  // In the loop below, respect the ByCopy flag only for the closure requesting
1188  // the capture (i.e. first iteration through the loop below). Ignore it for
1189  // all enclosing closure's up to NumCapturingClosures (since they must be
1190  // implicitly capturing the *enclosing object* by reference (see loop
1191  // above)).
1192  assert((!ByCopy ||
1193  dyn_cast<LambdaScopeInfo>(FunctionScopes[MaxFunctionScopesIndex])) &&
1194  "Only a lambda can capture the enclosing object (referred to by "
1195  "*this) by copy");
1196  // FIXME: We need to delay this marking in PotentiallyPotentiallyEvaluated
1197  // contexts.
1198  QualType ThisTy = getCurrentThisType();
1199  for (unsigned idx = MaxFunctionScopesIndex; NumCapturingClosures;
1200  --idx, --NumCapturingClosures) {
1201  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
1202  Expr *ThisExpr = nullptr;
1203 
1204  if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI)) {
1205  // For lambda expressions, build a field and an initializing expression,
1206  // and capture the *enclosing object* by copy only if this is the first
1207  // iteration.
1208  ThisExpr = captureThis(*this, Context, LSI->Lambda, ThisTy, Loc,
1209  ByCopy && idx == MaxFunctionScopesIndex);
1210 
1211  } else if (CapturedRegionScopeInfo *RSI
1212  = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
1213  ThisExpr =
1214  captureThis(*this, Context, RSI->TheRecordDecl, ThisTy, Loc,
1215  false/*ByCopy*/);
1216 
1217  bool isNested = NumCapturingClosures > 1;
1218  CSI->addThisCapture(isNested, Loc, ThisExpr, ByCopy);
1219  }
1220  return false;
1221 }
1222 
1224  /// C++ 9.3.2: In the body of a non-static member function, the keyword this
1225  /// is a non-lvalue expression whose value is the address of the object for
1226  /// which the function is called.
1227 
1228  QualType ThisTy = getCurrentThisType();
1229  if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
1230 
1231  CheckCXXThisCapture(Loc);
1232  return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false);
1233 }
1234 
1236  // If we're outside the body of a member function, then we'll have a specified
1237  // type for 'this'.
1239  return false;
1240 
1241  // Determine whether we're looking into a class that's currently being
1242  // defined.
1243  CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl();
1244  return Class && Class->isBeingDefined();
1245 }
1246 
1247 ExprResult
1249  SourceLocation LParenLoc,
1250  MultiExprArg exprs,
1251  SourceLocation RParenLoc) {
1252  if (!TypeRep)
1253  return ExprError();
1254 
1255  TypeSourceInfo *TInfo;
1256  QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
1257  if (!TInfo)
1259 
1260  auto Result = BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
1261  // Avoid creating a non-type-dependent expression that contains typos.
1262  // Non-type-dependent expressions are liable to be discarded without
1263  // checking for embedded typos.
1264  if (!Result.isInvalid() && Result.get()->isInstantiationDependent() &&
1265  !Result.get()->isTypeDependent())
1267  return Result;
1268 }
1269 
1270 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1271 /// Can be interpreted either as function-style casting ("int(x)")
1272 /// or class type construction ("ClassType(x,y,z)")
1273 /// or creation of a value-initialized type ("int()").
1274 ExprResult
1276  SourceLocation LParenLoc,
1277  MultiExprArg Exprs,
1278  SourceLocation RParenLoc) {
1279  QualType Ty = TInfo->getType();
1280  SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
1281 
1283  return CXXUnresolvedConstructExpr::Create(Context, TInfo, LParenLoc, Exprs,
1284  RParenLoc);
1285  }
1286 
1287  bool ListInitialization = LParenLoc.isInvalid();
1288  assert((!ListInitialization ||
1289  (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1290  "List initialization must have initializer list as expression.");
1291  SourceRange FullRange = SourceRange(TyBeginLoc,
1292  ListInitialization ? Exprs[0]->getSourceRange().getEnd() : RParenLoc);
1293 
1296  Exprs.size()
1297  ? ListInitialization
1299  : InitializationKind::CreateDirect(TyBeginLoc, LParenLoc,
1300  RParenLoc)
1301  : InitializationKind::CreateValue(TyBeginLoc, LParenLoc, RParenLoc);
1302 
1303  // C++1z [expr.type.conv]p1:
1304  // If the type is a placeholder for a deduced class type, [...perform class
1305  // template argument deduction...]
1306  DeducedType *Deduced = Ty->getContainedDeducedType();
1307  if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1309  Kind, Exprs);
1310  if (Ty.isNull())
1311  return ExprError();
1312  Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
1313  }
1314 
1315  // C++ [expr.type.conv]p1:
1316  // If the expression list is a parenthesized single expression, the type
1317  // conversion expression is equivalent (in definedness, and if defined in
1318  // meaning) to the corresponding cast expression.
1319  if (Exprs.size() == 1 && !ListInitialization &&
1320  !isa<InitListExpr>(Exprs[0])) {
1321  Expr *Arg = Exprs[0];
1322  return BuildCXXFunctionalCastExpr(TInfo, Ty, LParenLoc, Arg, RParenLoc);
1323  }
1324 
1325  // For an expression of the form T(), T shall not be an array type.
1326  QualType ElemTy = Ty;
1327  if (Ty->isArrayType()) {
1328  if (!ListInitialization)
1329  return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1330  << FullRange);
1331  ElemTy = Context.getBaseElementType(Ty);
1332  }
1333 
1334  // There doesn't seem to be an explicit rule against this but sanity demands
1335  // we only construct objects with object types.
1336  if (Ty->isFunctionType())
1337  return ExprError(Diag(TyBeginLoc, diag::err_init_for_function_type)
1338  << Ty << FullRange);
1339 
1340  // C++17 [expr.type.conv]p2:
1341  // If the type is cv void and the initializer is (), the expression is a
1342  // prvalue of the specified type that performs no initialization.
1343  if (!Ty->isVoidType() &&
1344  RequireCompleteType(TyBeginLoc, ElemTy,
1345  diag::err_invalid_incomplete_type_use, FullRange))
1346  return ExprError();
1347 
1348  // Otherwise, the expression is a prvalue of the specified type whose
1349  // result object is direct-initialized (11.6) with the initializer.
1350  InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
1351  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
1352 
1353  if (Result.isInvalid())
1354  return Result;
1355 
1356  Expr *Inner = Result.get();
1357  if (CXXBindTemporaryExpr *BTE = dyn_cast_or_null<CXXBindTemporaryExpr>(Inner))
1358  Inner = BTE->getSubExpr();
1359  if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1360  !isa<CXXScalarValueInitExpr>(Inner)) {
1361  // If we created a CXXTemporaryObjectExpr, that node also represents the
1362  // functional cast. Otherwise, create an explicit cast to represent
1363  // the syntactic form of a functional-style cast that was used here.
1364  //
1365  // FIXME: Creating a CXXFunctionalCastExpr around a CXXConstructExpr
1366  // would give a more consistent AST representation than using a
1367  // CXXTemporaryObjectExpr. It's also weird that the functional cast
1368  // is sometimes handled by initialization and sometimes not.
1369  QualType ResultType = Result.get()->getType();
1371  Context, ResultType, Expr::getValueKindForType(Ty), TInfo,
1372  CK_NoOp, Result.get(), /*Path=*/nullptr, LParenLoc, RParenLoc);
1373  }
1374 
1375  return Result;
1376 }
1377 
1378 /// \brief Determine whether the given function is a non-placement
1379 /// deallocation function.
1381  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1382  return Method->isUsualDeallocationFunction();
1383 
1384  if (FD->getOverloadedOperator() != OO_Delete &&
1385  FD->getOverloadedOperator() != OO_Array_Delete)
1386  return false;
1387 
1388  unsigned UsualParams = 1;
1389 
1390  if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
1392  FD->getParamDecl(UsualParams)->getType(),
1393  S.Context.getSizeType()))
1394  ++UsualParams;
1395 
1396  if (S.getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
1398  FD->getParamDecl(UsualParams)->getType(),
1400  ++UsualParams;
1401 
1402  return UsualParams == FD->getNumParams();
1403 }
1404 
1405 namespace {
1406  struct UsualDeallocFnInfo {
1407  UsualDeallocFnInfo() : Found(), FD(nullptr) {}
1408  UsualDeallocFnInfo(Sema &S, DeclAccessPair Found)
1409  : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())),
1410  Destroying(false), HasSizeT(false), HasAlignValT(false),
1411  CUDAPref(Sema::CFP_Native) {
1412  // A function template declaration is never a usual deallocation function.
1413  if (!FD)
1414  return;
1415  unsigned NumBaseParams = 1;
1416  if (FD->isDestroyingOperatorDelete()) {
1417  Destroying = true;
1418  ++NumBaseParams;
1419  }
1420  if (FD->getNumParams() == NumBaseParams + 2)
1421  HasAlignValT = HasSizeT = true;
1422  else if (FD->getNumParams() == NumBaseParams + 1) {
1423  HasSizeT = FD->getParamDecl(NumBaseParams)->getType()->isIntegerType();
1424  HasAlignValT = !HasSizeT;
1425  }
1426 
1427  // In CUDA, determine how much we'd like / dislike to call this.
1428  if (S.getLangOpts().CUDA)
1429  if (auto *Caller = dyn_cast<FunctionDecl>(S.CurContext))
1430  CUDAPref = S.IdentifyCUDAPreference(Caller, FD);
1431  }
1432 
1433  operator bool() const { return FD; }
1434 
1435  bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize,
1436  bool WantAlign) const {
1437  // C++ P0722:
1438  // A destroying operator delete is preferred over a non-destroying
1439  // operator delete.
1440  if (Destroying != Other.Destroying)
1441  return Destroying;
1442 
1443  // C++17 [expr.delete]p10:
1444  // If the type has new-extended alignment, a function with a parameter
1445  // of type std::align_val_t is preferred; otherwise a function without
1446  // such a parameter is preferred
1447  if (HasAlignValT != Other.HasAlignValT)
1448  return HasAlignValT == WantAlign;
1449 
1450  if (HasSizeT != Other.HasSizeT)
1451  return HasSizeT == WantSize;
1452 
1453  // Use CUDA call preference as a tiebreaker.
1454  return CUDAPref > Other.CUDAPref;
1455  }
1456 
1457  DeclAccessPair Found;
1458  FunctionDecl *FD;
1459  bool Destroying, HasSizeT, HasAlignValT;
1461  };
1462 }
1463 
1464 /// Determine whether a type has new-extended alignment. This may be called when
1465 /// the type is incomplete (for a delete-expression with an incomplete pointee
1466 /// type), in which case it will conservatively return false if the alignment is
1467 /// not known.
1468 static bool hasNewExtendedAlignment(Sema &S, QualType AllocType) {
1469  return S.getLangOpts().AlignedAllocation &&
1470  S.getASTContext().getTypeAlignIfKnown(AllocType) >
1472 }
1473 
1474 /// Select the correct "usual" deallocation function to use from a selection of
1475 /// deallocation functions (either global or class-scope).
1476 static UsualDeallocFnInfo resolveDeallocationOverload(
1477  Sema &S, LookupResult &R, bool WantSize, bool WantAlign,
1478  llvm::SmallVectorImpl<UsualDeallocFnInfo> *BestFns = nullptr) {
1479  UsualDeallocFnInfo Best;
1480 
1481  for (auto I = R.begin(), E = R.end(); I != E; ++I) {
1482  UsualDeallocFnInfo Info(S, I.getPair());
1483  if (!Info || !isNonPlacementDeallocationFunction(S, Info.FD) ||
1484  Info.CUDAPref == Sema::CFP_Never)
1485  continue;
1486 
1487  if (!Best) {
1488  Best = Info;
1489  if (BestFns)
1490  BestFns->push_back(Info);
1491  continue;
1492  }
1493 
1494  if (Best.isBetterThan(Info, WantSize, WantAlign))
1495  continue;
1496 
1497  // If more than one preferred function is found, all non-preferred
1498  // functions are eliminated from further consideration.
1499  if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1500  BestFns->clear();
1501 
1502  Best = Info;
1503  if (BestFns)
1504  BestFns->push_back(Info);
1505  }
1506 
1507  return Best;
1508 }
1509 
1510 /// Determine whether a given type is a class for which 'delete[]' would call
1511 /// a member 'operator delete[]' with a 'size_t' parameter. This implies that
1512 /// we need to store the array size (even if the type is
1513 /// trivially-destructible).
1515  QualType allocType) {
1516  const RecordType *record =
1517  allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
1518  if (!record) return false;
1519 
1520  // Try to find an operator delete[] in class scope.
1521 
1522  DeclarationName deleteName =
1523  S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
1524  LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
1525  S.LookupQualifiedName(ops, record->getDecl());
1526 
1527  // We're just doing this for information.
1528  ops.suppressDiagnostics();
1529 
1530  // Very likely: there's no operator delete[].
1531  if (ops.empty()) return false;
1532 
1533  // If it's ambiguous, it should be illegal to call operator delete[]
1534  // on this thing, so it doesn't matter if we allocate extra space or not.
1535  if (ops.isAmbiguous()) return false;
1536 
1537  // C++17 [expr.delete]p10:
1538  // If the deallocation functions have class scope, the one without a
1539  // parameter of type std::size_t is selected.
1540  auto Best = resolveDeallocationOverload(
1541  S, ops, /*WantSize*/false,
1542  /*WantAlign*/hasNewExtendedAlignment(S, allocType));
1543  return Best && Best.HasSizeT;
1544 }
1545 
1546 /// \brief Parsed a C++ 'new' expression (C++ 5.3.4).
1547 ///
1548 /// E.g.:
1549 /// @code new (memory) int[size][4] @endcode
1550 /// or
1551 /// @code ::new Foo(23, "hello") @endcode
1552 ///
1553 /// \param StartLoc The first location of the expression.
1554 /// \param UseGlobal True if 'new' was prefixed with '::'.
1555 /// \param PlacementLParen Opening paren of the placement arguments.
1556 /// \param PlacementArgs Placement new arguments.
1557 /// \param PlacementRParen Closing paren of the placement arguments.
1558 /// \param TypeIdParens If the type is in parens, the source range.
1559 /// \param D The type to be allocated, as well as array dimensions.
1560 /// \param Initializer The initializing expression or initializer-list, or null
1561 /// if there is none.
1562 ExprResult
1563 Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1564  SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
1565  SourceLocation PlacementRParen, SourceRange TypeIdParens,
1566  Declarator &D, Expr *Initializer) {
1567  Expr *ArraySize = nullptr;
1568  // If the specified type is an array, unwrap it and save the expression.
1569  if (D.getNumTypeObjects() > 0 &&
1571  DeclaratorChunk &Chunk = D.getTypeObject(0);
1572  if (D.getDeclSpec().hasAutoTypeSpec())
1573  return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
1574  << D.getSourceRange());
1575  if (Chunk.Arr.hasStatic)
1576  return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
1577  << D.getSourceRange());
1578  if (!Chunk.Arr.NumElts)
1579  return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
1580  << D.getSourceRange());
1581 
1582  ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
1583  D.DropFirstTypeObject();
1584  }
1585 
1586  // Every dimension shall be of constant size.
1587  if (ArraySize) {
1588  for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
1590  break;
1591 
1593  if (Expr *NumElts = (Expr *)Array.NumElts) {
1594  if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1595  if (getLangOpts().CPlusPlus14) {
1596  // C++1y [expr.new]p6: Every constant-expression in a noptr-new-declarator
1597  // shall be a converted constant expression (5.19) of type std::size_t
1598  // and shall evaluate to a strictly positive value.
1599  unsigned IntWidth = Context.getTargetInfo().getIntWidth();
1600  assert(IntWidth && "Builtin type of size 0?");
1601  llvm::APSInt Value(IntWidth);
1602  Array.NumElts
1604  CCEK_NewExpr)
1605  .get();
1606  } else {
1607  Array.NumElts
1608  = VerifyIntegerConstantExpression(NumElts, nullptr,
1609  diag::err_new_array_nonconst)
1610  .get();
1611  }
1612  if (!Array.NumElts)
1613  return ExprError();
1614  }
1615  }
1616  }
1617  }
1618 
1619  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/nullptr);
1620  QualType AllocType = TInfo->getType();
1621  if (D.isInvalidType())
1622  return ExprError();
1623 
1624  SourceRange DirectInitRange;
1625  if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1626  DirectInitRange = List->getSourceRange();
1627 
1628  return BuildCXXNew(SourceRange(StartLoc, D.getLocEnd()), UseGlobal,
1629  PlacementLParen,
1630  PlacementArgs,
1631  PlacementRParen,
1632  TypeIdParens,
1633  AllocType,
1634  TInfo,
1635  ArraySize,
1636  DirectInitRange,
1637  Initializer);
1638 }
1639 
1641  Expr *Init) {
1642  if (!Init)
1643  return true;
1644  if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
1645  return PLE->getNumExprs() == 0;
1646  if (isa<ImplicitValueInitExpr>(Init))
1647  return true;
1648  else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
1649  return !CCE->isListInitialization() &&
1650  CCE->getConstructor()->isDefaultConstructor();
1651  else if (Style == CXXNewExpr::ListInit) {
1652  assert(isa<InitListExpr>(Init) &&
1653  "Shouldn't create list CXXConstructExprs for arrays.");
1654  return true;
1655  }
1656  return false;
1657 }
1658 
1659 // Emit a diagnostic if an aligned allocation/deallocation function that is not
1660 // implemented in the standard library is selected.
1662  SourceLocation Loc, bool IsDelete,
1663  Sema &S) {
1664  if (!S.getLangOpts().AlignedAllocationUnavailable)
1665  return;
1666 
1667  // Return if there is a definition.
1668  if (FD.isDefined())
1669  return;
1670 
1671  bool IsAligned = false;
1672  if (FD.isReplaceableGlobalAllocationFunction(&IsAligned) && IsAligned) {
1673  const llvm::Triple &T = S.getASTContext().getTargetInfo().getTriple();
1674  StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1676 
1677  S.Diag(Loc, diag::warn_aligned_allocation_unavailable)
1678  << IsDelete << FD.getType().getAsString() << OSName
1679  << alignedAllocMinVersion(T.getOS()).getAsString();
1680  S.Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
1681  }
1682 }
1683 
1684 ExprResult
1685 Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
1686  SourceLocation PlacementLParen,
1687  MultiExprArg PlacementArgs,
1688  SourceLocation PlacementRParen,
1689  SourceRange TypeIdParens,
1690  QualType AllocType,
1691  TypeSourceInfo *AllocTypeInfo,
1692  Expr *ArraySize,
1693  SourceRange DirectInitRange,
1694  Expr *Initializer) {
1695  SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
1696  SourceLocation StartLoc = Range.getBegin();
1697 
1699  if (DirectInitRange.isValid()) {
1700  assert(Initializer && "Have parens but no initializer.");
1701  initStyle = CXXNewExpr::CallInit;
1702  } else if (Initializer && isa<InitListExpr>(Initializer))
1703  initStyle = CXXNewExpr::ListInit;
1704  else {
1705  assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1706  isa<CXXConstructExpr>(Initializer)) &&
1707  "Initializer expression that cannot have been implicitly created.");
1708  initStyle = CXXNewExpr::NoInit;
1709  }
1710 
1711  Expr **Inits = &Initializer;
1712  unsigned NumInits = Initializer ? 1 : 0;
1713  if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1714  assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
1715  Inits = List->getExprs();
1716  NumInits = List->getNumExprs();
1717  }
1718 
1719  // C++11 [expr.new]p15:
1720  // A new-expression that creates an object of type T initializes that
1721  // object as follows:
1723  // - If the new-initializer is omitted, the object is default-
1724  // initialized (8.5); if no initialization is performed,
1725  // the object has indeterminate value
1726  = initStyle == CXXNewExpr::NoInit
1728  // - Otherwise, the new-initializer is interpreted according to the
1729  // initialization rules of 8.5 for direct-initialization.
1730  : initStyle == CXXNewExpr::ListInit
1733  DirectInitRange.getBegin(),
1734  DirectInitRange.getEnd());
1735 
1736  // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
1737  auto *Deduced = AllocType->getContainedDeducedType();
1738  if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1739  if (ArraySize)
1740  return ExprError(Diag(ArraySize->getExprLoc(),
1741  diag::err_deduced_class_template_compound_type)
1742  << /*array*/ 2 << ArraySize->getSourceRange());
1743 
1744  InitializedEntity Entity
1745  = InitializedEntity::InitializeNew(StartLoc, AllocType);
1747  AllocTypeInfo, Entity, Kind, MultiExprArg(Inits, NumInits));
1748  if (AllocType.isNull())
1749  return ExprError();
1750  } else if (Deduced) {
1751  bool Braced = (initStyle == CXXNewExpr::ListInit);
1752  if (NumInits == 1) {
1753  if (auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1754  Inits = p->getInits();
1755  NumInits = p->getNumInits();
1756  Braced = true;
1757  }
1758  }
1759 
1760  if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
1761  return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1762  << AllocType << TypeRange);
1763  if (NumInits > 1) {
1764  Expr *FirstBad = Inits[1];
1765  return ExprError(Diag(FirstBad->getLocStart(),
1766  diag::err_auto_new_ctor_multiple_expressions)
1767  << AllocType << TypeRange);
1768  }
1769  if (Braced && !getLangOpts().CPlusPlus17)
1770  Diag(Initializer->getLocStart(), diag::ext_auto_new_list_init)
1771  << AllocType << TypeRange;
1772  Expr *Deduce = Inits[0];
1774  if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
1775  return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
1776  << AllocType << Deduce->getType()
1777  << TypeRange << Deduce->getSourceRange());
1778  if (DeducedType.isNull())
1779  return ExprError();
1780  AllocType = DeducedType;
1781  }
1782 
1783  // Per C++0x [expr.new]p5, the type being constructed may be a
1784  // typedef of an array type.
1785  if (!ArraySize) {
1786  if (const ConstantArrayType *Array
1787  = Context.getAsConstantArrayType(AllocType)) {
1788  ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
1789  Context.getSizeType(),
1790  TypeRange.getEnd());
1791  AllocType = Array->getElementType();
1792  }
1793  }
1794 
1795  if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
1796  return ExprError();
1797 
1798  if (initStyle == CXXNewExpr::ListInit &&
1799  isStdInitializerList(AllocType, nullptr)) {
1800  Diag(AllocTypeInfo->getTypeLoc().getBeginLoc(),
1801  diag::warn_dangling_std_initializer_list)
1802  << /*at end of FE*/0 << Inits[0]->getSourceRange();
1803  }
1804 
1805  // In ARC, infer 'retaining' for the allocated
1806  if (getLangOpts().ObjCAutoRefCount &&
1807  AllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1808  AllocType->isObjCLifetimeType()) {
1809  AllocType = Context.getLifetimeQualifiedType(AllocType,
1810  AllocType->getObjCARCImplicitLifetime());
1811  }
1812 
1813  QualType ResultType = Context.getPointerType(AllocType);
1814 
1815  if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) {
1816  ExprResult result = CheckPlaceholderExpr(ArraySize);
1817  if (result.isInvalid()) return ExprError();
1818  ArraySize = result.get();
1819  }
1820  // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have
1821  // integral or enumeration type with a non-negative value."
1822  // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped
1823  // enumeration type, or a class type for which a single non-explicit
1824  // conversion function to integral or unscoped enumeration type exists.
1825  // C++1y [expr.new]p6: The expression [...] is implicitly converted to
1826  // std::size_t.
1827  llvm::Optional<uint64_t> KnownArraySize;
1828  if (ArraySize && !ArraySize->isTypeDependent()) {
1829  ExprResult ConvertedSize;
1830  if (getLangOpts().CPlusPlus14) {
1831  assert(Context.getTargetInfo().getIntWidth() && "Builtin type of size 0?");
1832 
1833  ConvertedSize = PerformImplicitConversion(ArraySize, Context.getSizeType(),
1834  AA_Converting);
1835 
1836  if (!ConvertedSize.isInvalid() &&
1837  ArraySize->getType()->getAs<RecordType>())
1838  // Diagnose the compatibility of this conversion.
1839  Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1840  << ArraySize->getType() << 0 << "'size_t'";
1841  } else {
1842  class SizeConvertDiagnoser : public ICEConvertDiagnoser {
1843  protected:
1844  Expr *ArraySize;
1845 
1846  public:
1847  SizeConvertDiagnoser(Expr *ArraySize)
1848  : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, false, false),
1849  ArraySize(ArraySize) {}
1850 
1851  SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1852  QualType T) override {
1853  return S.Diag(Loc, diag::err_array_size_not_integral)
1854  << S.getLangOpts().CPlusPlus11 << T;
1855  }
1856 
1857  SemaDiagnosticBuilder diagnoseIncomplete(
1858  Sema &S, SourceLocation Loc, QualType T) override {
1859  return S.Diag(Loc, diag::err_array_size_incomplete_type)
1860  << T << ArraySize->getSourceRange();
1861  }
1862 
1863  SemaDiagnosticBuilder diagnoseExplicitConv(
1864  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
1865  return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1866  }
1867 
1868  SemaDiagnosticBuilder noteExplicitConv(
1869  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1870  return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1871  << ConvTy->isEnumeralType() << ConvTy;
1872  }
1873 
1874  SemaDiagnosticBuilder diagnoseAmbiguous(
1875  Sema &S, SourceLocation Loc, QualType T) override {
1876  return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1877  }
1878 
1879  SemaDiagnosticBuilder noteAmbiguous(
1880  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1881  return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1882  << ConvTy->isEnumeralType() << ConvTy;
1883  }
1884 
1885  SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1886  QualType T,
1887  QualType ConvTy) override {
1888  return S.Diag(Loc,
1889  S.getLangOpts().CPlusPlus11
1890  ? diag::warn_cxx98_compat_array_size_conversion
1891  : diag::ext_array_size_conversion)
1892  << T << ConvTy->isEnumeralType() << ConvTy;
1893  }
1894  } SizeDiagnoser(ArraySize);
1895 
1896  ConvertedSize = PerformContextualImplicitConversion(StartLoc, ArraySize,
1897  SizeDiagnoser);
1898  }
1899  if (ConvertedSize.isInvalid())
1900  return ExprError();
1901 
1902  ArraySize = ConvertedSize.get();
1903  QualType SizeType = ArraySize->getType();
1904 
1905  if (!SizeType->isIntegralOrUnscopedEnumerationType())
1906  return ExprError();
1907 
1908  // C++98 [expr.new]p7:
1909  // The expression in a direct-new-declarator shall have integral type
1910  // with a non-negative value.
1911  //
1912  // Let's see if this is a constant < 0. If so, we reject it out of hand,
1913  // per CWG1464. Otherwise, if it's not a constant, we must have an
1914  // unparenthesized array type.
1915  if (!ArraySize->isValueDependent()) {
1916  llvm::APSInt Value;
1917  // We've already performed any required implicit conversion to integer or
1918  // unscoped enumeration type.
1919  // FIXME: Per CWG1464, we are required to check the value prior to
1920  // converting to size_t. This will never find a negative array size in
1921  // C++14 onwards, because Value is always unsigned here!
1922  if (ArraySize->isIntegerConstantExpr(Value, Context)) {
1923  if (Value.isSigned() && Value.isNegative()) {
1924  return ExprError(Diag(ArraySize->getLocStart(),
1925  diag::err_typecheck_negative_array_size)
1926  << ArraySize->getSourceRange());
1927  }
1928 
1929  if (!AllocType->isDependentType()) {
1930  unsigned ActiveSizeBits =
1932  if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context))
1933  return ExprError(Diag(ArraySize->getLocStart(),
1934  diag::err_array_too_large)
1935  << Value.toString(10)
1936  << ArraySize->getSourceRange());
1937  }
1938 
1939  KnownArraySize = Value.getZExtValue();
1940  } else if (TypeIdParens.isValid()) {
1941  // Can't have dynamic array size when the type-id is in parentheses.
1942  Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
1943  << ArraySize->getSourceRange()
1944  << FixItHint::CreateRemoval(TypeIdParens.getBegin())
1945  << FixItHint::CreateRemoval(TypeIdParens.getEnd());
1946 
1947  TypeIdParens = SourceRange();
1948  }
1949  }
1950 
1951  // Note that we do *not* convert the argument in any way. It can
1952  // be signed, larger than size_t, whatever.
1953  }
1954 
1955  FunctionDecl *OperatorNew = nullptr;
1956  FunctionDecl *OperatorDelete = nullptr;
1957  unsigned Alignment =
1958  AllocType->isDependentType() ? 0 : Context.getTypeAlign(AllocType);
1959  unsigned NewAlignment = Context.getTargetInfo().getNewAlign();
1960  bool PassAlignment = getLangOpts().AlignedAllocation &&
1961  Alignment > NewAlignment;
1962 
1963  if (!AllocType->isDependentType() &&
1964  !Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
1965  FindAllocationFunctions(StartLoc,
1966  SourceRange(PlacementLParen, PlacementRParen),
1967  UseGlobal, AllocType, ArraySize, PassAlignment,
1968  PlacementArgs, OperatorNew, OperatorDelete))
1969  return ExprError();
1970 
1971  // If this is an array allocation, compute whether the usual array
1972  // deallocation function for the type has a size_t parameter.
1973  bool UsualArrayDeleteWantsSize = false;
1974  if (ArraySize && !AllocType->isDependentType())
1975  UsualArrayDeleteWantsSize =
1976  doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
1977 
1978  SmallVector<Expr *, 8> AllPlaceArgs;
1979  if (OperatorNew) {
1980  const FunctionProtoType *Proto =
1981  OperatorNew->getType()->getAs<FunctionProtoType>();
1982  VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction
1984 
1985  // We've already converted the placement args, just fill in any default
1986  // arguments. Skip the first parameter because we don't have a corresponding
1987  // argument. Skip the second parameter too if we're passing in the
1988  // alignment; we've already filled it in.
1989  if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto,
1990  PassAlignment ? 2 : 1, PlacementArgs,
1991  AllPlaceArgs, CallType))
1992  return ExprError();
1993 
1994  if (!AllPlaceArgs.empty())
1995  PlacementArgs = AllPlaceArgs;
1996 
1997  // FIXME: This is wrong: PlacementArgs misses out the first (size) argument.
1998  DiagnoseSentinelCalls(OperatorNew, PlacementLParen, PlacementArgs);
1999 
2000  // FIXME: Missing call to CheckFunctionCall or equivalent
2001 
2002  // Warn if the type is over-aligned and is being allocated by (unaligned)
2003  // global operator new.
2004  if (PlacementArgs.empty() && !PassAlignment &&
2005  (OperatorNew->isImplicit() ||
2006  (OperatorNew->getLocStart().isValid() &&
2007  getSourceManager().isInSystemHeader(OperatorNew->getLocStart())))) {
2008  if (Alignment > NewAlignment)
2009  Diag(StartLoc, diag::warn_overaligned_type)
2010  << AllocType
2011  << unsigned(Alignment / Context.getCharWidth())
2012  << unsigned(NewAlignment / Context.getCharWidth());
2013  }
2014  }
2015 
2016  // Array 'new' can't have any initializers except empty parentheses.
2017  // Initializer lists are also allowed, in C++11. Rely on the parser for the
2018  // dialect distinction.
2019  if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) {
2020  SourceRange InitRange(Inits[0]->getLocStart(),
2021  Inits[NumInits - 1]->getLocEnd());
2022  Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2023  return ExprError();
2024  }
2025 
2026  // If we can perform the initialization, and we've not already done so,
2027  // do it now.
2028  if (!AllocType->isDependentType() &&
2030  llvm::makeArrayRef(Inits, NumInits))) {
2031  // The type we initialize is the complete type, including the array bound.
2032  QualType InitType;
2033  if (KnownArraySize)
2034  InitType = Context.getConstantArrayType(
2035  AllocType, llvm::APInt(Context.getTypeSize(Context.getSizeType()),
2036  *KnownArraySize),
2037  ArrayType::Normal, 0);
2038  else if (ArraySize)
2039  InitType =
2041  else
2042  InitType = AllocType;
2043 
2044  InitializedEntity Entity
2045  = InitializedEntity::InitializeNew(StartLoc, InitType);
2046  InitializationSequence InitSeq(*this, Entity, Kind,
2047  MultiExprArg(Inits, NumInits));
2048  ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
2049  MultiExprArg(Inits, NumInits));
2050  if (FullInit.isInvalid())
2051  return ExprError();
2052 
2053  // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
2054  // we don't want the initialized object to be destructed.
2055  // FIXME: We should not create these in the first place.
2056  if (CXXBindTemporaryExpr *Binder =
2057  dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))
2058  FullInit = Binder->getSubExpr();
2059 
2060  Initializer = FullInit.get();
2061  }
2062 
2063  // Mark the new and delete operators as referenced.
2064  if (OperatorNew) {
2065  if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
2066  return ExprError();
2067  MarkFunctionReferenced(StartLoc, OperatorNew);
2068  diagnoseUnavailableAlignedAllocation(*OperatorNew, StartLoc, false, *this);
2069  }
2070  if (OperatorDelete) {
2071  if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
2072  return ExprError();
2073  MarkFunctionReferenced(StartLoc, OperatorDelete);
2074  diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true, *this);
2075  }
2076 
2077  // C++0x [expr.new]p17:
2078  // If the new expression creates an array of objects of class type,
2079  // access and ambiguity control are done for the destructor.
2080  QualType BaseAllocType = Context.getBaseElementType(AllocType);
2081  if (ArraySize && !BaseAllocType->isDependentType()) {
2082  if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
2083  if (CXXDestructorDecl *dtor = LookupDestructor(
2084  cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
2085  MarkFunctionReferenced(StartLoc, dtor);
2086  CheckDestructorAccess(StartLoc, dtor,
2087  PDiag(diag::err_access_dtor)
2088  << BaseAllocType);
2089  if (DiagnoseUseOfDecl(dtor, StartLoc))
2090  return ExprError();
2091  }
2092  }
2093  }
2094 
2095  return new (Context)
2096  CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete, PassAlignment,
2097  UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
2098  ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
2099  Range, DirectInitRange);
2100 }
2101 
2102 /// \brief Checks that a type is suitable as the allocated type
2103 /// in a new-expression.
2105  SourceRange R) {
2106  // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
2107  // abstract class type or array thereof.
2108  if (AllocType->isFunctionType())
2109  return Diag(Loc, diag::err_bad_new_type)
2110  << AllocType << 0 << R;
2111  else if (AllocType->isReferenceType())
2112  return Diag(Loc, diag::err_bad_new_type)
2113  << AllocType << 1 << R;
2114  else if (!AllocType->isDependentType() &&
2115  RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
2116  return true;
2117  else if (RequireNonAbstractType(Loc, AllocType,
2118  diag::err_allocation_of_abstract_type))
2119  return true;
2120  else if (AllocType->isVariablyModifiedType())
2121  return Diag(Loc, diag::err_variably_modified_new_type)
2122  << AllocType;
2123  else if (AllocType.getAddressSpace() != LangAS::Default)
2124  return Diag(Loc, diag::err_address_space_qualified_new)
2125  << AllocType.getUnqualifiedType()
2127  else if (getLangOpts().ObjCAutoRefCount) {
2128  if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {
2129  QualType BaseAllocType = Context.getBaseElementType(AT);
2130  if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None &&
2131  BaseAllocType->isObjCLifetimeType())
2132  return Diag(Loc, diag::err_arc_new_array_without_ownership)
2133  << BaseAllocType;
2134  }
2135  }
2136 
2137  return false;
2138 }
2139 
2140 static bool
2142  SmallVectorImpl<Expr *> &Args, bool &PassAlignment,
2143  FunctionDecl *&Operator,
2144  OverloadCandidateSet *AlignedCandidates = nullptr,
2145  Expr *AlignArg = nullptr) {
2146  OverloadCandidateSet Candidates(R.getNameLoc(),
2148  for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
2149  Alloc != AllocEnd; ++Alloc) {
2150  // Even member operator new/delete are implicitly treated as
2151  // static, so don't use AddMemberCandidate.
2152  NamedDecl *D = (*Alloc)->getUnderlyingDecl();
2153 
2154  if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
2155  S.AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
2156  /*ExplicitTemplateArgs=*/nullptr, Args,
2157  Candidates,
2158  /*SuppressUserConversions=*/false);
2159  continue;
2160  }
2161 
2162  FunctionDecl *Fn = cast<FunctionDecl>(D);
2163  S.AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
2164  /*SuppressUserConversions=*/false);
2165  }
2166 
2167  // Do the resolution.
2169  switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
2170  case OR_Success: {
2171  // Got one!
2172  FunctionDecl *FnDecl = Best->Function;
2173  if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(),
2174  Best->FoundDecl) == Sema::AR_inaccessible)
2175  return true;
2176 
2177  Operator = FnDecl;
2178  return false;
2179  }
2180 
2181  case OR_No_Viable_Function:
2182  // C++17 [expr.new]p13:
2183  // If no matching function is found and the allocated object type has
2184  // new-extended alignment, the alignment argument is removed from the
2185  // argument list, and overload resolution is performed again.
2186  if (PassAlignment) {
2187  PassAlignment = false;
2188  AlignArg = Args[1];
2189  Args.erase(Args.begin() + 1);
2190  return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
2191  Operator, &Candidates, AlignArg);
2192  }
2193 
2194  // MSVC will fall back on trying to find a matching global operator new
2195  // if operator new[] cannot be found. Also, MSVC will leak by not
2196  // generating a call to operator delete or operator delete[], but we
2197  // will not replicate that bug.
2198  // FIXME: Find out how this interacts with the std::align_val_t fallback
2199  // once MSVC implements it.
2200  if (R.getLookupName().getCXXOverloadedOperator() == OO_Array_New &&
2201  S.Context.getLangOpts().MSVCCompat) {
2202  R.clear();
2205  // FIXME: This will give bad diagnostics pointing at the wrong functions.
2206  return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
2207  Operator, nullptr);
2208  }
2209 
2210  S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
2211  << R.getLookupName() << Range;
2212 
2213  // If we have aligned candidates, only note the align_val_t candidates
2214  // from AlignedCandidates and the non-align_val_t candidates from
2215  // Candidates.
2216  if (AlignedCandidates) {
2217  auto IsAligned = [](OverloadCandidate &C) {
2218  return C.Function->getNumParams() > 1 &&
2219  C.Function->getParamDecl(1)->getType()->isAlignValT();
2220  };
2221  auto IsUnaligned = [&](OverloadCandidate &C) { return !IsAligned(C); };
2222 
2223  // This was an overaligned allocation, so list the aligned candidates
2224  // first.
2225  Args.insert(Args.begin() + 1, AlignArg);
2226  AlignedCandidates->NoteCandidates(S, OCD_AllCandidates, Args, "",
2227  R.getNameLoc(), IsAligned);
2228  Args.erase(Args.begin() + 1);
2229  Candidates.NoteCandidates(S, OCD_AllCandidates, Args, "", R.getNameLoc(),
2230  IsUnaligned);
2231  } else {
2232  Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
2233  }
2234  return true;
2235 
2236  case OR_Ambiguous:
2237  S.Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
2238  << R.getLookupName() << Range;
2239  Candidates.NoteCandidates(S, OCD_ViableCandidates, Args);
2240  return true;
2241 
2242  case OR_Deleted: {
2243  S.Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
2244  << Best->Function->isDeleted()
2245  << R.getLookupName()
2246  << S.getDeletedOrUnavailableSuffix(Best->Function)
2247  << Range;
2248  Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
2249  return true;
2250  }
2251  }
2252  llvm_unreachable("Unreachable, bad result from BestViableFunction");
2253 }
2254 
2255 
2256 /// FindAllocationFunctions - Finds the overloads of operator new and delete
2257 /// that are appropriate for the allocation.
2259  bool UseGlobal, QualType AllocType,
2260  bool IsArray, bool &PassAlignment,
2261  MultiExprArg PlaceArgs,
2262  FunctionDecl *&OperatorNew,
2263  FunctionDecl *&OperatorDelete) {
2264  // --- Choosing an allocation function ---
2265  // C++ 5.3.4p8 - 14 & 18
2266  // 1) If UseGlobal is true, only look in the global scope. Else, also look
2267  // in the scope of the allocated class.
2268  // 2) If an array size is given, look for operator new[], else look for
2269  // operator new.
2270  // 3) The first argument is always size_t. Append the arguments from the
2271  // placement form.
2272 
2273  SmallVector<Expr*, 8> AllocArgs;
2274  AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2275 
2276  // We don't care about the actual value of these arguments.
2277  // FIXME: Should the Sema create the expression and embed it in the syntax
2278  // tree? Or should the consumer just recalculate the value?
2279  // FIXME: Using a dummy value will interact poorly with attribute enable_if.
2280  IntegerLiteral Size(Context, llvm::APInt::getNullValue(
2282  Context.getSizeType(),
2283  SourceLocation());
2284  AllocArgs.push_back(&Size);
2285 
2286  QualType AlignValT = Context.VoidTy;
2287  if (PassAlignment) {
2289  AlignValT = Context.getTypeDeclType(getStdAlignValT());
2290  }
2291  CXXScalarValueInitExpr Align(AlignValT, nullptr, SourceLocation());
2292  if (PassAlignment)
2293  AllocArgs.push_back(&Align);
2294 
2295  AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2296 
2297  // C++ [expr.new]p8:
2298  // If the allocated type is a non-array type, the allocation
2299  // function's name is operator new and the deallocation function's
2300  // name is operator delete. If the allocated type is an array
2301  // type, the allocation function's name is operator new[] and the
2302  // deallocation function's name is operator delete[].
2304  IsArray ? OO_Array_New : OO_New);
2305 
2306  QualType AllocElemType = Context.getBaseElementType(AllocType);
2307 
2308  // Find the allocation function.
2309  {
2310  LookupResult R(*this, NewName, StartLoc, LookupOrdinaryName);
2311 
2312  // C++1z [expr.new]p9:
2313  // If the new-expression begins with a unary :: operator, the allocation
2314  // function's name is looked up in the global scope. Otherwise, if the
2315  // allocated type is a class type T or array thereof, the allocation
2316  // function's name is looked up in the scope of T.
2317  if (AllocElemType->isRecordType() && !UseGlobal)
2318  LookupQualifiedName(R, AllocElemType->getAsCXXRecordDecl());
2319 
2320  // We can see ambiguity here if the allocation function is found in
2321  // multiple base classes.
2322  if (R.isAmbiguous())
2323  return true;
2324 
2325  // If this lookup fails to find the name, or if the allocated type is not
2326  // a class type, the allocation function's name is looked up in the
2327  // global scope.
2328  if (R.empty())
2330 
2331  assert(!R.empty() && "implicitly declared allocation functions not found");
2332  assert(!R.isAmbiguous() && "global allocation functions are ambiguous");
2333 
2334  // We do our own custom access checks below.
2335  R.suppressDiagnostics();
2336 
2337  if (resolveAllocationOverload(*this, R, Range, AllocArgs, PassAlignment,
2338  OperatorNew))
2339  return true;
2340  }
2341 
2342  // We don't need an operator delete if we're running under -fno-exceptions.
2343  if (!getLangOpts().Exceptions) {
2344  OperatorDelete = nullptr;
2345  return false;
2346  }
2347 
2348  // Note, the name of OperatorNew might have been changed from array to
2349  // non-array by resolveAllocationOverload.
2351  OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New
2352  ? OO_Array_Delete
2353  : OO_Delete);
2354 
2355  // C++ [expr.new]p19:
2356  //
2357  // If the new-expression begins with a unary :: operator, the
2358  // deallocation function's name is looked up in the global
2359  // scope. Otherwise, if the allocated type is a class type T or an
2360  // array thereof, the deallocation function's name is looked up in
2361  // the scope of T. If this lookup fails to find the name, or if
2362  // the allocated type is not a class type or array thereof, the
2363  // deallocation function's name is looked up in the global scope.
2364  LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
2365  if (AllocElemType->isRecordType() && !UseGlobal) {
2366  CXXRecordDecl *RD
2367  = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
2368  LookupQualifiedName(FoundDelete, RD);
2369  }
2370  if (FoundDelete.isAmbiguous())
2371  return true; // FIXME: clean up expressions?
2372 
2373  bool FoundGlobalDelete = FoundDelete.empty();
2374  if (FoundDelete.empty()) {
2377  }
2378 
2379  FoundDelete.suppressDiagnostics();
2380 
2382 
2383  // Whether we're looking for a placement operator delete is dictated
2384  // by whether we selected a placement operator new, not by whether
2385  // we had explicit placement arguments. This matters for things like
2386  // struct A { void *operator new(size_t, int = 0); ... };
2387  // A *a = new A()
2388  //
2389  // We don't have any definition for what a "placement allocation function"
2390  // is, but we assume it's any allocation function whose
2391  // parameter-declaration-clause is anything other than (size_t).
2392  //
2393  // FIXME: Should (size_t, std::align_val_t) also be considered non-placement?
2394  // This affects whether an exception from the constructor of an overaligned
2395  // type uses the sized or non-sized form of aligned operator delete.
2396  bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->param_size() != 1 ||
2397  OperatorNew->isVariadic();
2398 
2399  if (isPlacementNew) {
2400  // C++ [expr.new]p20:
2401  // A declaration of a placement deallocation function matches the
2402  // declaration of a placement allocation function if it has the
2403  // same number of parameters and, after parameter transformations
2404  // (8.3.5), all parameter types except the first are
2405  // identical. [...]
2406  //
2407  // To perform this comparison, we compute the function type that
2408  // the deallocation function should have, and use that type both
2409  // for template argument deduction and for comparison purposes.
2410  QualType ExpectedFunctionType;
2411  {
2412  const FunctionProtoType *Proto
2413  = OperatorNew->getType()->getAs<FunctionProtoType>();
2414 
2415  SmallVector<QualType, 4> ArgTypes;
2416  ArgTypes.push_back(Context.VoidPtrTy);
2417  for (unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
2418  ArgTypes.push_back(Proto->getParamType(I));
2419 
2421  // FIXME: This is not part of the standard's rule.
2422  EPI.Variadic = Proto->isVariadic();
2423 
2424  ExpectedFunctionType
2425  = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
2426  }
2427 
2428  for (LookupResult::iterator D = FoundDelete.begin(),
2429  DEnd = FoundDelete.end();
2430  D != DEnd; ++D) {
2431  FunctionDecl *Fn = nullptr;
2432  if (FunctionTemplateDecl *FnTmpl =
2433  dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2434  // Perform template argument deduction to try to match the
2435  // expected function type.
2436  TemplateDeductionInfo Info(StartLoc);
2437  if (DeduceTemplateArguments(FnTmpl, nullptr, ExpectedFunctionType, Fn,
2438  Info))
2439  continue;
2440  } else
2441  Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2442 
2444  ExpectedFunctionType,
2445  /*AdjustExcpetionSpec*/true),
2446  ExpectedFunctionType))
2447  Matches.push_back(std::make_pair(D.getPair(), Fn));
2448  }
2449 
2450  if (getLangOpts().CUDA)
2451  EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2452  } else {
2453  // C++1y [expr.new]p22:
2454  // For a non-placement allocation function, the normal deallocation
2455  // function lookup is used
2456  //
2457  // Per [expr.delete]p10, this lookup prefers a member operator delete
2458  // without a size_t argument, but prefers a non-member operator delete
2459  // with a size_t where possible (which it always is in this case).
2461  UsualDeallocFnInfo Selected = resolveDeallocationOverload(
2462  *this, FoundDelete, /*WantSize*/ FoundGlobalDelete,
2463  /*WantAlign*/ hasNewExtendedAlignment(*this, AllocElemType),
2464  &BestDeallocFns);
2465  if (Selected)
2466  Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2467  else {
2468  // If we failed to select an operator, all remaining functions are viable
2469  // but ambiguous.
2470  for (auto Fn : BestDeallocFns)
2471  Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2472  }
2473  }
2474 
2475  // C++ [expr.new]p20:
2476  // [...] If the lookup finds a single matching deallocation
2477  // function, that function will be called; otherwise, no
2478  // deallocation function will be called.
2479  if (Matches.size() == 1) {
2480  OperatorDelete = Matches[0].second;
2481 
2482  // C++1z [expr.new]p23:
2483  // If the lookup finds a usual deallocation function (3.7.4.2)
2484  // with a parameter of type std::size_t and that function, considered
2485  // as a placement deallocation function, would have been
2486  // selected as a match for the allocation function, the program
2487  // is ill-formed.
2488  if (getLangOpts().CPlusPlus11 && isPlacementNew &&
2489  isNonPlacementDeallocationFunction(*this, OperatorDelete)) {
2490  UsualDeallocFnInfo Info(*this,
2491  DeclAccessPair::make(OperatorDelete, AS_public));
2492  // Core issue, per mail to core reflector, 2016-10-09:
2493  // If this is a member operator delete, and there is a corresponding
2494  // non-sized member operator delete, this isn't /really/ a sized
2495  // deallocation function, it just happens to have a size_t parameter.
2496  bool IsSizedDelete = Info.HasSizeT;
2497  if (IsSizedDelete && !FoundGlobalDelete) {
2498  auto NonSizedDelete =
2499  resolveDeallocationOverload(*this, FoundDelete, /*WantSize*/false,
2500  /*WantAlign*/Info.HasAlignValT);
2501  if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2502  NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2503  IsSizedDelete = false;
2504  }
2505 
2506  if (IsSizedDelete) {
2507  SourceRange R = PlaceArgs.empty()
2508  ? SourceRange()
2509  : SourceRange(PlaceArgs.front()->getLocStart(),
2510  PlaceArgs.back()->getLocEnd());
2511  Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2512  if (!OperatorDelete->isImplicit())
2513  Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
2514  << DeleteName;
2515  }
2516  }
2517 
2518  CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
2519  Matches[0].first);
2520  } else if (!Matches.empty()) {
2521  // We found multiple suitable operators. Per [expr.new]p20, that means we
2522  // call no 'operator delete' function, but we should at least warn the user.
2523  // FIXME: Suppress this warning if the construction cannot throw.
2524  Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2525  << DeleteName << AllocElemType;
2526 
2527  for (auto &Match : Matches)
2528  Diag(Match.second->getLocation(),
2529  diag::note_member_declared_here) << DeleteName;
2530  }
2531 
2532  return false;
2533 }
2534 
2535 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
2536 /// delete. These are:
2537 /// @code
2538 /// // C++03:
2539 /// void* operator new(std::size_t) throw(std::bad_alloc);
2540 /// void* operator new[](std::size_t) throw(std::bad_alloc);
2541 /// void operator delete(void *) throw();
2542 /// void operator delete[](void *) throw();
2543 /// // C++11:
2544 /// void* operator new(std::size_t);
2545 /// void* operator new[](std::size_t);
2546 /// void operator delete(void *) noexcept;
2547 /// void operator delete[](void *) noexcept;
2548 /// // C++1y:
2549 /// void* operator new(std::size_t);
2550 /// void* operator new[](std::size_t);
2551 /// void operator delete(void *) noexcept;
2552 /// void operator delete[](void *) noexcept;
2553 /// void operator delete(void *, std::size_t) noexcept;
2554 /// void operator delete[](void *, std::size_t) noexcept;
2555 /// @endcode
2556 /// Note that the placement and nothrow forms of new are *not* implicitly
2557 /// declared. Their use requires including <new>.
2560  return;
2561 
2562  // C++ [basic.std.dynamic]p2:
2563  // [...] The following allocation and deallocation functions (18.4) are
2564  // implicitly declared in global scope in each translation unit of a
2565  // program
2566  //
2567  // C++03:
2568  // void* operator new(std::size_t) throw(std::bad_alloc);
2569  // void* operator new[](std::size_t) throw(std::bad_alloc);
2570  // void operator delete(void*) throw();
2571  // void operator delete[](void*) throw();
2572  // C++11:
2573  // void* operator new(std::size_t);
2574  // void* operator new[](std::size_t);
2575  // void operator delete(void*) noexcept;
2576  // void operator delete[](void*) noexcept;
2577  // C++1y:
2578  // void* operator new(std::size_t);
2579  // void* operator new[](std::size_t);
2580  // void operator delete(void*) noexcept;
2581  // void operator delete[](void*) noexcept;
2582  // void operator delete(void*, std::size_t) noexcept;
2583  // void operator delete[](void*, std::size_t) noexcept;
2584  //
2585  // These implicit declarations introduce only the function names operator
2586  // new, operator new[], operator delete, operator delete[].
2587  //
2588  // Here, we need to refer to std::bad_alloc, so we will implicitly declare
2589  // "std" or "bad_alloc" as necessary to form the exception specification.
2590  // However, we do not make these implicit declarations visible to name
2591  // lookup.
2592  if (!StdBadAlloc && !getLangOpts().CPlusPlus11) {
2593  // The "std::bad_alloc" class has not yet been declared, so build it
2594  // implicitly.
2598  &PP.getIdentifierTable().get("bad_alloc"),
2599  nullptr);
2600  getStdBadAlloc()->setImplicit(true);
2601  }
2602  if (!StdAlignValT && getLangOpts().AlignedAllocation) {
2603  // The "std::align_val_t" enum class has not yet been declared, so build it
2604  // implicitly.
2605  auto *AlignValT = EnumDecl::Create(
2607  &PP.getIdentifierTable().get("align_val_t"), nullptr, true, true, true);
2608  AlignValT->setIntegerType(Context.getSizeType());
2609  AlignValT->setPromotionType(Context.getSizeType());
2610  AlignValT->setImplicit(true);
2611  StdAlignValT = AlignValT;
2612  }
2613 
2614  GlobalNewDeleteDeclared = true;
2615 
2617  QualType SizeT = Context.getSizeType();
2618 
2619  auto DeclareGlobalAllocationFunctions = [&](OverloadedOperatorKind Kind,
2620  QualType Return, QualType Param) {
2622  Params.push_back(Param);
2623 
2624  // Create up to four variants of the function (sized/aligned).
2625  bool HasSizedVariant = getLangOpts().SizedDeallocation &&
2626  (Kind == OO_Delete || Kind == OO_Array_Delete);
2627  bool HasAlignedVariant = getLangOpts().AlignedAllocation;
2628 
2629  int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2630  int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2631  for (int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2632  if (Sized)
2633  Params.push_back(SizeT);
2634 
2635  for (int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2636  if (Aligned)
2637  Params.push_back(Context.getTypeDeclType(getStdAlignValT()));
2638 
2640  Context.DeclarationNames.getCXXOperatorName(Kind), Return, Params);
2641 
2642  if (Aligned)
2643  Params.pop_back();
2644  }
2645  }
2646  };
2647 
2648  DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2649  DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2650  DeclareGlobalAllocationFunctions(OO_Delete, Context.VoidTy, VoidPtr);
2651  DeclareGlobalAllocationFunctions(OO_Array_Delete, Context.VoidTy, VoidPtr);
2652 }
2653 
2654 /// DeclareGlobalAllocationFunction - Declares a single implicit global
2655 /// allocation function if it doesn't already exist.
2657  QualType Return,
2658  ArrayRef<QualType> Params) {
2660 
2661  // Check if this function is already declared.
2662  DeclContext::lookup_result R = GlobalCtx->lookup(Name);
2663  for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end();
2664  Alloc != AllocEnd; ++Alloc) {
2665  // Only look at non-template functions, as it is the predefined,
2666  // non-templated allocation function we are trying to declare here.
2667  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2668  if (Func->getNumParams() == Params.size()) {
2669  llvm::SmallVector<QualType, 3> FuncParams;
2670  for (auto *P : Func->parameters())
2671  FuncParams.push_back(
2672  Context.getCanonicalType(P->getType().getUnqualifiedType()));
2673  if (llvm::makeArrayRef(FuncParams) == Params) {
2674  // Make the function visible to name lookup, even if we found it in
2675  // an unimported module. It either is an implicitly-declared global
2676  // allocation function, or is suppressing that function.
2677  Func->setVisibleDespiteOwningModule();
2678  return;
2679  }
2680  }
2681  }
2682  }
2683 
2685 
2686  QualType BadAllocType;
2687  bool HasBadAllocExceptionSpec
2688  = (Name.getCXXOverloadedOperator() == OO_New ||
2689  Name.getCXXOverloadedOperator() == OO_Array_New);
2690  if (HasBadAllocExceptionSpec) {
2691  if (!getLangOpts().CPlusPlus11) {
2692  BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
2693  assert(StdBadAlloc && "Must have std::bad_alloc declared");
2695  EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType);
2696  }
2697  } else {
2698  EPI.ExceptionSpec =
2699  getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
2700  }
2701 
2702  auto CreateAllocationFunctionDecl = [&](Attr *ExtraAttr) {
2703  QualType FnType = Context.getFunctionType(Return, Params, EPI);
2705  Context, GlobalCtx, SourceLocation(), SourceLocation(), Name,
2706  FnType, /*TInfo=*/nullptr, SC_None, false, true);
2707  Alloc->setImplicit();
2708  // Global allocation functions should always be visible.
2710 
2711  // Implicit sized deallocation functions always have default visibility.
2712  Alloc->addAttr(
2713  VisibilityAttr::CreateImplicit(Context, VisibilityAttr::Default));
2714 
2716  for (QualType T : Params) {
2717  ParamDecls.push_back(ParmVarDecl::Create(
2718  Context, Alloc, SourceLocation(), SourceLocation(), nullptr, T,
2719  /*TInfo=*/nullptr, SC_None, nullptr));
2720  ParamDecls.back()->setImplicit();
2721  }
2722  Alloc->setParams(ParamDecls);
2723  if (ExtraAttr)
2724  Alloc->addAttr(ExtraAttr);
2726  IdResolver.tryAddTopLevelDecl(Alloc, Name);
2727  };
2728 
2729  if (!LangOpts.CUDA)
2730  CreateAllocationFunctionDecl(nullptr);
2731  else {
2732  // Host and device get their own declaration so each can be
2733  // defined or re-declared independently.
2734  CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(Context));
2735  CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(Context));
2736  }
2737 }
2738 
2740  bool CanProvideSize,
2741  bool Overaligned,
2742  DeclarationName Name) {
2744 
2745  LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
2747 
2748  // FIXME: It's possible for this to result in ambiguity, through a
2749  // user-declared variadic operator delete or the enable_if attribute. We
2750  // should probably not consider those cases to be usual deallocation
2751  // functions. But for now we just make an arbitrary choice in that case.
2752  auto Result = resolveDeallocationOverload(*this, FoundDelete, CanProvideSize,
2753  Overaligned);
2754  assert(Result.FD && "operator delete missing from global scope?");
2755  return Result.FD;
2756 }
2757 
2759  CXXRecordDecl *RD) {
2761 
2762  FunctionDecl *OperatorDelete = nullptr;
2763  if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
2764  return nullptr;
2765  if (OperatorDelete)
2766  return OperatorDelete;
2767 
2768  // If there's no class-specific operator delete, look up the global
2769  // non-array delete.
2771  Loc, true, hasNewExtendedAlignment(*this, Context.getRecordType(RD)),
2772  Name);
2773 }
2774 
2776  DeclarationName Name,
2777  FunctionDecl *&Operator, bool Diagnose) {
2778  LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
2779  // Try to find operator delete/operator delete[] in class scope.
2780  LookupQualifiedName(Found, RD);
2781 
2782  if (Found.isAmbiguous())
2783  return true;
2784 
2785  Found.suppressDiagnostics();
2786 
2787  bool Overaligned = hasNewExtendedAlignment(*this, Context.getRecordType(RD));
2788 
2789  // C++17 [expr.delete]p10:
2790  // If the deallocation functions have class scope, the one without a
2791  // parameter of type std::size_t is selected.
2793  resolveDeallocationOverload(*this, Found, /*WantSize*/ false,
2794  /*WantAlign*/ Overaligned, &Matches);
2795 
2796  // If we could find an overload, use it.
2797  if (Matches.size() == 1) {
2798  Operator = cast<CXXMethodDecl>(Matches[0].FD);
2799 
2800  // FIXME: DiagnoseUseOfDecl?
2801  if (Operator->isDeleted()) {
2802  if (Diagnose) {
2803  Diag(StartLoc, diag::err_deleted_function_use);
2804  NoteDeletedFunction(Operator);
2805  }
2806  return true;
2807  }
2808 
2809  if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
2810  Matches[0].Found, Diagnose) == AR_inaccessible)
2811  return true;
2812 
2813  return false;
2814  }
2815 
2816  // We found multiple suitable operators; complain about the ambiguity.
2817  // FIXME: The standard doesn't say to do this; it appears that the intent
2818  // is that this should never happen.
2819  if (!Matches.empty()) {
2820  if (Diagnose) {
2821  Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2822  << Name << RD;
2823  for (auto &Match : Matches)
2824  Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2825  }
2826  return true;
2827  }
2828 
2829  // We did find operator delete/operator delete[] declarations, but
2830  // none of them were suitable.
2831  if (!Found.empty()) {
2832  if (Diagnose) {
2833  Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2834  << Name << RD;
2835 
2836  for (NamedDecl *D : Found)
2837  Diag(D->getUnderlyingDecl()->getLocation(),
2838  diag::note_member_declared_here) << Name;
2839  }
2840  return true;
2841  }
2842 
2843  Operator = nullptr;
2844  return false;
2845 }
2846 
2847 namespace {
2848 /// \brief Checks whether delete-expression, and new-expression used for
2849 /// initializing deletee have the same array form.
2850 class MismatchingNewDeleteDetector {
2851 public:
2852  enum MismatchResult {
2853  /// Indicates that there is no mismatch or a mismatch cannot be proven.
2854  NoMismatch,
2855  /// Indicates that variable is initialized with mismatching form of \a new.
2856  VarInitMismatches,
2857  /// Indicates that member is initialized with mismatching form of \a new.
2858  MemberInitMismatches,
2859  /// Indicates that 1 or more constructors' definitions could not been
2860  /// analyzed, and they will be checked again at the end of translation unit.
2861  AnalyzeLater
2862  };
2863 
2864  /// \param EndOfTU True, if this is the final analysis at the end of
2865  /// translation unit. False, if this is the initial analysis at the point
2866  /// delete-expression was encountered.
2867  explicit MismatchingNewDeleteDetector(bool EndOfTU)
2868  : Field(nullptr), IsArrayForm(false), EndOfTU(EndOfTU),
2869  HasUndefinedConstructors(false) {}
2870 
2871  /// \brief Checks whether pointee of a delete-expression is initialized with
2872  /// matching form of new-expression.
2873  ///
2874  /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the
2875  /// point where delete-expression is encountered, then a warning will be
2876  /// issued immediately. If return value is \c AnalyzeLater at the point where
2877  /// delete-expression is seen, then member will be analyzed at the end of
2878  /// translation unit. \c AnalyzeLater is returned iff at least one constructor
2879  /// couldn't be analyzed. If at least one constructor initializes the member
2880  /// with matching type of new, the return value is \c NoMismatch.
2881  MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE);
2882  /// \brief Analyzes a class member.
2883  /// \param Field Class member to analyze.
2884  /// \param DeleteWasArrayForm Array form-ness of the delete-expression used
2885  /// for deleting the \p Field.
2886  MismatchResult analyzeField(FieldDecl *Field, bool DeleteWasArrayForm);
2887  FieldDecl *Field;
2888  /// List of mismatching new-expressions used for initialization of the pointee
2890  /// Indicates whether delete-expression was in array form.
2891  bool IsArrayForm;
2892 
2893 private:
2894  const bool EndOfTU;
2895  /// \brief Indicates that there is at least one constructor without body.
2896  bool HasUndefinedConstructors;
2897  /// \brief Returns \c CXXNewExpr from given initialization expression.
2898  /// \param E Expression used for initializing pointee in delete-expression.
2899  /// E can be a single-element \c InitListExpr consisting of new-expression.
2900  const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E);
2901  /// \brief Returns whether member is initialized with mismatching form of
2902  /// \c new either by the member initializer or in-class initialization.
2903  ///
2904  /// If bodies of all constructors are not visible at the end of translation
2905  /// unit or at least one constructor initializes member with the matching
2906  /// form of \c new, mismatch cannot be proven, and this function will return
2907  /// \c NoMismatch.
2908  MismatchResult analyzeMemberExpr(const MemberExpr *ME);
2909  /// \brief Returns whether variable is initialized with mismatching form of
2910  /// \c new.
2911  ///
2912  /// If variable is initialized with matching form of \c new or variable is not
2913  /// initialized with a \c new expression, this function will return true.
2914  /// If variable is initialized with mismatching form of \c new, returns false.
2915  /// \param D Variable to analyze.
2916  bool hasMatchingVarInit(const DeclRefExpr *D);
2917  /// \brief Checks whether the constructor initializes pointee with mismatching
2918  /// form of \c new.
2919  ///
2920  /// Returns true, if member is initialized with matching form of \c new in
2921  /// member initializer list. Returns false, if member is initialized with the
2922  /// matching form of \c new in this constructor's initializer or given
2923  /// constructor isn't defined at the point where delete-expression is seen, or
2924  /// member isn't initialized by the constructor.
2925  bool hasMatchingNewInCtor(const CXXConstructorDecl *CD);
2926  /// \brief Checks whether member is initialized with matching form of
2927  /// \c new in member initializer list.
2928  bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI);
2929  /// Checks whether member is initialized with mismatching form of \c new by
2930  /// in-class initializer.
2931  MismatchResult analyzeInClassInitializer();
2932 };
2933 }
2934 
2935 MismatchingNewDeleteDetector::MismatchResult
2936 MismatchingNewDeleteDetector::analyzeDeleteExpr(const CXXDeleteExpr *DE) {
2937  NewExprs.clear();
2938  assert(DE && "Expected delete-expression");
2939  IsArrayForm = DE->isArrayForm();
2940  const Expr *E = DE->getArgument()->IgnoreParenImpCasts();
2941  if (const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
2942  return analyzeMemberExpr(ME);
2943  } else if (const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
2944  if (!hasMatchingVarInit(D))
2945  return VarInitMismatches;
2946  }
2947  return NoMismatch;
2948 }
2949 
2950 const CXXNewExpr *
2951 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) {
2952  assert(E != nullptr && "Expected a valid initializer expression");
2953  E = E->IgnoreParenImpCasts();
2954  if (const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
2955  if (ILE->getNumInits() == 1)
2956  E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
2957  }
2958 
2959  return dyn_cast_or_null<const CXXNewExpr>(E);
2960 }
2961 
2962 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
2963  const CXXCtorInitializer *CI) {
2964  const CXXNewExpr *NE = nullptr;
2965  if (Field == CI->getMember() &&
2966  (NE = getNewExprFromInitListOrExpr(CI->getInit()))) {
2967  if (NE->isArray() == IsArrayForm)
2968  return true;
2969  else
2970  NewExprs.push_back(NE);
2971  }
2972  return false;
2973 }
2974 
2975 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
2976  const CXXConstructorDecl *CD) {
2977  if (CD->isImplicit())
2978  return false;
2979  const FunctionDecl *Definition = CD;
2980  if (!CD->isThisDeclarationADefinition() && !CD->isDefined(Definition)) {
2981  HasUndefinedConstructors = true;
2982  return EndOfTU;
2983  }
2984  for (const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
2985  if (hasMatchingNewInCtorInit(CI))
2986  return true;
2987  }
2988  return false;
2989 }
2990 
2991 MismatchingNewDeleteDetector::MismatchResult
2992 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
2993  assert(Field != nullptr && "This should be called only for members");
2994  const Expr *InitExpr = Field->getInClassInitializer();
2995  if (!InitExpr)
2996  return EndOfTU ? NoMismatch : AnalyzeLater;
2997  if (const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
2998  if (NE->isArray() != IsArrayForm) {
2999  NewExprs.push_back(NE);
3000  return MemberInitMismatches;
3001  }
3002  }
3003  return NoMismatch;
3004 }
3005 
3006 MismatchingNewDeleteDetector::MismatchResult
3007 MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field,
3008  bool DeleteWasArrayForm) {
3009  assert(Field != nullptr && "Analysis requires a valid class member.");
3010  this->Field = Field;
3011  IsArrayForm = DeleteWasArrayForm;
3012  const CXXRecordDecl *RD = cast<const CXXRecordDecl>(Field->getParent());
3013  for (const auto *CD : RD->ctors()) {
3014  if (hasMatchingNewInCtor(CD))
3015  return NoMismatch;
3016  }
3017  if (HasUndefinedConstructors)
3018  return EndOfTU ? NoMismatch : AnalyzeLater;
3019  if (!NewExprs.empty())
3020  return MemberInitMismatches;
3021  return Field->hasInClassInitializer() ? analyzeInClassInitializer()
3022  : NoMismatch;
3023 }
3024 
3025 MismatchingNewDeleteDetector::MismatchResult
3026 MismatchingNewDeleteDetector::analyzeMemberExpr(const MemberExpr *ME) {
3027  assert(ME != nullptr && "Expected a member expression");
3028  if (FieldDecl *F = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3029  return analyzeField(F, IsArrayForm);
3030  return NoMismatch;
3031 }
3032 
3033 bool MismatchingNewDeleteDetector::hasMatchingVarInit(const DeclRefExpr *D) {
3034  const CXXNewExpr *NE = nullptr;
3035  if (const VarDecl *VD = dyn_cast<const VarDecl>(D->getDecl())) {
3036  if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3037  NE->isArray() != IsArrayForm) {
3038  NewExprs.push_back(NE);
3039  }
3040  }
3041  return NewExprs.empty();
3042 }
3043 
3044 static void
3046  const MismatchingNewDeleteDetector &Detector) {
3047  SourceLocation EndOfDelete = SemaRef.getLocForEndOfToken(DeleteLoc);
3048  FixItHint H;
3049  if (!Detector.IsArrayForm)
3050  H = FixItHint::CreateInsertion(EndOfDelete, "[]");
3051  else {
3053  DeleteLoc, tok::l_square, SemaRef.getSourceManager(),
3054  SemaRef.getLangOpts(), true);
3055  if (RSquare.isValid())
3056  H = FixItHint::CreateRemoval(SourceRange(EndOfDelete, RSquare));
3057  }
3058  SemaRef.Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3059  << Detector.IsArrayForm << H;
3060 
3061  for (const auto *NE : Detector.NewExprs)
3062  SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here)
3063  << Detector.IsArrayForm;
3064 }
3065 
3066 void Sema::AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE) {
3067  if (Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation()))
3068  return;
3069  MismatchingNewDeleteDetector Detector(/*EndOfTU=*/false);
3070  switch (Detector.analyzeDeleteExpr(DE)) {
3071  case MismatchingNewDeleteDetector::VarInitMismatches:
3072  case MismatchingNewDeleteDetector::MemberInitMismatches: {
3073  DiagnoseMismatchedNewDelete(*this, DE->getLocStart(), Detector);
3074  break;
3075  }
3076  case MismatchingNewDeleteDetector::AnalyzeLater: {
3077  DeleteExprs[Detector.Field].push_back(
3078  std::make_pair(DE->getLocStart(), DE->isArrayForm()));
3079  break;
3080  }
3081  case MismatchingNewDeleteDetector::NoMismatch:
3082  break;
3083  }
3084 }
3085 
3086 void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
3087  bool DeleteWasArrayForm) {
3088  MismatchingNewDeleteDetector Detector(/*EndOfTU=*/true);
3089  switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3090  case MismatchingNewDeleteDetector::VarInitMismatches:
3091  llvm_unreachable("This analysis should have been done for class members.");
3092  case MismatchingNewDeleteDetector::AnalyzeLater:
3093  llvm_unreachable("Analysis cannot be postponed any point beyond end of "
3094  "translation unit.");
3095  case MismatchingNewDeleteDetector::MemberInitMismatches:
3096  DiagnoseMismatchedNewDelete(*this, DeleteLoc, Detector);
3097  break;
3098  case MismatchingNewDeleteDetector::NoMismatch:
3099  break;
3100  }
3101 }
3102 
3103 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
3104 /// @code ::delete ptr; @endcode
3105 /// or
3106 /// @code delete [] ptr; @endcode
3107 ExprResult
3108 Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
3109  bool ArrayForm, Expr *ExE) {
3110  // C++ [expr.delete]p1:
3111  // The operand shall have a pointer type, or a class type having a single
3112  // non-explicit conversion function to a pointer type. The result has type
3113  // void.
3114  //
3115  // DR599 amends "pointer type" to "pointer to object type" in both cases.
3116 
3117  ExprResult Ex = ExE;
3118  FunctionDecl *OperatorDelete = nullptr;
3119  bool ArrayFormAsWritten = ArrayForm;
3120  bool UsualArrayDeleteWantsSize = false;
3121 
3122  if (!Ex.get()->isTypeDependent()) {
3123  // Perform lvalue-to-rvalue cast, if needed.
3124  Ex = DefaultLvalueConversion(Ex.get());
3125  if (Ex.isInvalid())
3126  return ExprError();
3127 
3128  QualType Type = Ex.get()->getType();
3129 
3130  class DeleteConverter : public ContextualImplicitConverter {
3131  public:
3132  DeleteConverter() : ContextualImplicitConverter(false, true) {}
3133 
3134  bool match(QualType ConvType) override {
3135  // FIXME: If we have an operator T* and an operator void*, we must pick
3136  // the operator T*.
3137  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
3138  if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3139  return true;
3140  return false;
3141  }
3142 
3143  SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc,
3144  QualType T) override {
3145  return S.Diag(Loc, diag::err_delete_operand) << T;
3146  }
3147 
3148  SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
3149  QualType T) override {
3150  return S.Diag(Loc, diag::err_delete_incomplete_class_type) << T;
3151  }
3152 
3153  SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
3154  QualType T,
3155  QualType ConvTy) override {
3156  return S.Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3157  }
3158 
3159  SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
3160  QualType ConvTy) override {
3161  return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
3162  << ConvTy;
3163  }
3164 
3165  SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
3166  QualType T) override {
3167  return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T;
3168  }
3169 
3170  SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
3171  QualType ConvTy) override {
3172  return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
3173  << ConvTy;
3174  }
3175 
3176  SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
3177  QualType T,
3178  QualType ConvTy) override {
3179  llvm_unreachable("conversion functions are permitted");
3180  }
3181  } Converter;
3182 
3183  Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter);
3184  if (Ex.isInvalid())
3185  return ExprError();
3186  Type = Ex.get()->getType();
3187  if (!Converter.match(Type))
3188  // FIXME: PerformContextualImplicitConversion should return ExprError
3189  // itself in this case.
3190  return ExprError();
3191 
3192  QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
3193  QualType PointeeElem = Context.getBaseElementType(Pointee);
3194 
3195  if (Pointee.getAddressSpace() != LangAS::Default)
3196  return Diag(Ex.get()->getLocStart(),
3197  diag::err_address_space_qualified_delete)
3198  << Pointee.getUnqualifiedType()
3200 
3201  CXXRecordDecl *PointeeRD = nullptr;
3202  if (Pointee->isVoidType() && !isSFINAEContext()) {
3203  // The C++ standard bans deleting a pointer to a non-object type, which
3204  // effectively bans deletion of "void*". However, most compilers support
3205  // this, so we treat it as a warning unless we're in a SFINAE context.
3206  Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3207  << Type << Ex.get()->getSourceRange();
3208  } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
3209  return ExprError(Diag(StartLoc, diag::err_delete_operand)
3210  << Type << Ex.get()->getSourceRange());
3211  } else if (!Pointee->isDependentType()) {
3212  // FIXME: This can result in errors if the definition was imported from a
3213  // module but is hidden.
3214  if (!RequireCompleteType(StartLoc, Pointee,
3215  diag::warn_delete_incomplete, Ex.get())) {
3216  if (const RecordType *RT = PointeeElem->getAs<RecordType>())
3217  PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3218  }
3219  }
3220 
3221  if (Pointee->isArrayType() && !ArrayForm) {
3222  Diag(StartLoc, diag::warn_delete_array_type)
3223  << Type << Ex.get()->getSourceRange()
3224  << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), "[]");
3225  ArrayForm = true;
3226  }
3227 
3229  ArrayForm ? OO_Array_Delete : OO_Delete);
3230 
3231  if (PointeeRD) {
3232  if (!UseGlobal &&
3233  FindDeallocationFunction(StartLoc, PointeeRD, DeleteName,
3234  OperatorDelete))
3235  return ExprError();
3236 
3237  // If we're allocating an array of records, check whether the
3238  // usual operator delete[] has a size_t parameter.
3239  if (ArrayForm) {
3240  // If the user specifically asked to use the global allocator,
3241  // we'll need to do the lookup into the class.
3242  if (UseGlobal)
3243  UsualArrayDeleteWantsSize =
3244  doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
3245 
3246  // Otherwise, the usual operator delete[] should be the
3247  // function we just found.
3248  else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3249  UsualArrayDeleteWantsSize =
3250  UsualDeallocFnInfo(*this,
3251  DeclAccessPair::make(OperatorDelete, AS_public))
3252  .HasSizeT;
3253  }
3254 
3255  if (!PointeeRD->hasIrrelevantDestructor())
3256  if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
3257  MarkFunctionReferenced(StartLoc,
3258  const_cast<CXXDestructorDecl*>(Dtor));
3259  if (DiagnoseUseOfDecl(Dtor, StartLoc))
3260  return ExprError();
3261  }
3262 
3263  CheckVirtualDtorCall(PointeeRD->getDestructor(), StartLoc,
3264  /*IsDelete=*/true, /*CallCanBeVirtual=*/true,
3265  /*WarnOnNonAbstractTypes=*/!ArrayForm,
3266  SourceLocation());
3267  }
3268 
3269  if (!OperatorDelete) {
3270  bool IsComplete = isCompleteType(StartLoc, Pointee);
3271  bool CanProvideSize =
3272  IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3273  Pointee.isDestructedType());
3274  bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
3275 
3276  // Look for a global declaration.
3277  OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
3278  Overaligned, DeleteName);
3279  }
3280 
3281  MarkFunctionReferenced(StartLoc, OperatorDelete);
3282 
3283  // Check access and ambiguity of destructor if we're going to call it.
3284  // Note that this is required even for a virtual delete.
3285  bool IsVirtualDelete = false;
3286  if (PointeeRD) {
3287  if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
3288  CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
3289  PDiag(diag::err_access_dtor) << PointeeElem);
3290  IsVirtualDelete = Dtor->isVirtual();
3291  }
3292  }
3293 
3294  diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true,
3295  *this);
3296 
3297  // Convert the operand to the type of the first parameter of operator
3298  // delete. This is only necessary if we selected a destroying operator
3299  // delete that we are going to call (non-virtually); converting to void*
3300  // is trivial and left to AST consumers to handle.
3301  QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
3302  if (!IsVirtualDelete && !ParamType->getPointeeType()->isVoidType()) {
3303  Qualifiers Qs = Pointee.getQualifiers();
3304  if (Qs.hasCVRQualifiers()) {
3305  // Qualifiers are irrelevant to this conversion; we're only looking
3306  // for access and ambiguity.
3307  Qs.removeCVRQualifiers();
3308  QualType Unqual = Context.getPointerType(
3310  Ex = ImpCastExprToType(Ex.get(), Unqual, CK_NoOp);
3311  }
3312  Ex = PerformImplicitConversion(Ex.get(), ParamType, AA_Passing);
3313  if (Ex.isInvalid())
3314  return ExprError();
3315  }
3316  }
3317 
3319  Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten,
3320  UsualArrayDeleteWantsSize, OperatorDelete, Ex.get(), StartLoc);
3321  AnalyzeDeleteExprMismatch(Result);
3322  return Result;
3323 }
3324 
3326  bool IsDelete, bool CallCanBeVirtual,
3327  bool WarnOnNonAbstractTypes,
3328  SourceLocation DtorLoc) {
3329  if (!dtor || dtor->isVirtual() || !CallCanBeVirtual || isUnevaluatedContext())
3330  return;
3331 
3332  // C++ [expr.delete]p3:
3333  // In the first alternative (delete object), if the static type of the
3334  // object to be deleted is different from its dynamic type, the static
3335  // type shall be a base class of the dynamic type of the object to be
3336  // deleted and the static type shall have a virtual destructor or the
3337  // behavior is undefined.
3338  //
3339  const CXXRecordDecl *PointeeRD = dtor->getParent();
3340  // Note: a final class cannot be derived from, no issue there
3341  if (!PointeeRD->isPolymorphic() || PointeeRD->hasAttr<FinalAttr>())
3342  return;
3343 
3344  // If the superclass is in a system header, there's nothing that can be done.
3345  // The `delete` (where we emit the warning) can be in a system header,
3346  // what matters for this warning is where the deleted type is defined.
3347  if (getSourceManager().isInSystemHeader(PointeeRD->getLocation()))
3348  return;
3349 
3350  QualType ClassType = dtor->getThisType(Context)->getPointeeType();
3351  if (PointeeRD->isAbstract()) {
3352  // If the class is abstract, we warn by default, because we're
3353  // sure the code has undefined behavior.
3354  Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3355  << ClassType;
3356  } else if (WarnOnNonAbstractTypes) {
3357  // Otherwise, if this is not an array delete, it's a bit suspect,
3358  // but not necessarily wrong.
3359  Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3360  << ClassType;
3361  }
3362  if (!IsDelete) {
3363  std::string TypeStr;
3364  ClassType.getAsStringInternal(TypeStr, getPrintingPolicy());
3365  Diag(DtorLoc, diag::note_delete_non_virtual)
3366  << FixItHint::CreateInsertion(DtorLoc, TypeStr + "::");
3367  }
3368 }
3369 
3371  SourceLocation StmtLoc,
3372  ConditionKind CK) {
3373  ExprResult E =
3374  CheckConditionVariable(cast<VarDecl>(ConditionVar), StmtLoc, CK);
3375  if (E.isInvalid())
3376  return ConditionError();
3377  return ConditionResult(*this, ConditionVar, MakeFullExpr(E.get(), StmtLoc),
3379 }
3380 
3381 /// \brief Check the use of the given variable as a C++ condition in an if,
3382 /// while, do-while, or switch statement.
3384  SourceLocation StmtLoc,
3385  ConditionKind CK) {
3386  if (ConditionVar->isInvalidDecl())
3387  return ExprError();
3388 
3389  QualType T = ConditionVar->getType();
3390 
3391  // C++ [stmt.select]p2:
3392  // The declarator shall not specify a function or an array.
3393  if (T->isFunctionType())
3394  return ExprError(Diag(ConditionVar->getLocation(),
3395  diag::err_invalid_use_of_function_type)
3396  << ConditionVar->getSourceRange());
3397  else if (T->isArrayType())
3398  return ExprError(Diag(ConditionVar->getLocation(),
3399  diag::err_invalid_use_of_array_type)
3400  << ConditionVar->getSourceRange());
3401 
3402  ExprResult Condition = DeclRefExpr::Create(
3403  Context, NestedNameSpecifierLoc(), SourceLocation(), ConditionVar,
3404  /*enclosing*/ false, ConditionVar->getLocation(),
3405  ConditionVar->getType().getNonReferenceType(), VK_LValue);
3406 
3407  MarkDeclRefReferenced(cast<DeclRefExpr>(Condition.get()));
3408 
3409  switch (CK) {
3411  return CheckBooleanCondition(StmtLoc, Condition.get());
3412 
3414  return CheckBooleanCondition(StmtLoc, Condition.get(), true);
3415 
3416  case ConditionKind::Switch:
3417  return CheckSwitchCondition(StmtLoc, Condition.get());
3418  }
3419 
3420  llvm_unreachable("unexpected condition kind");
3421 }
3422 
3423 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
3424 ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr) {
3425  // C++ 6.4p4:
3426  // The value of a condition that is an initialized declaration in a statement
3427  // other than a switch statement is the value of the declared variable
3428  // implicitly converted to type bool. If that conversion is ill-formed, the
3429  // program is ill-formed.
3430  // The value of a condition that is an expression is the value of the
3431  // expression, implicitly converted to bool.
3432  //
3433  // FIXME: Return this value to the caller so they don't need to recompute it.
3434  llvm::APSInt Value(/*BitWidth*/1);
3435  return (IsConstexpr && !CondExpr->isValueDependent())
3436  ? CheckConvertedConstantExpression(CondExpr, Context.BoolTy, Value,
3439 }
3440 
3441 /// Helper function to determine whether this is the (deprecated) C++
3442 /// conversion from a string literal to a pointer to non-const char or
3443 /// non-const wchar_t (for narrow and wide string literals,
3444 /// respectively).
3445 bool
3447  // Look inside the implicit cast, if it exists.
3448  if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
3449  From = Cast->getSubExpr();
3450 
3451  // A string literal (2.13.4) that is not a wide string literal can
3452  // be converted to an rvalue of type "pointer to char"; a wide
3453  // string literal can be converted to an rvalue of type "pointer
3454  // to wchar_t" (C++ 4.2p2).
3455  if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
3456  if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
3457  if (const BuiltinType *ToPointeeType
3458  = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
3459  // This conversion is considered only when there is an
3460  // explicit appropriate pointer target type (C++ 4.2p2).
3461  if (!ToPtrType->getPointeeType().hasQualifiers()) {
3462  switch (StrLit->getKind()) {
3463  case StringLiteral::UTF8:
3464  case StringLiteral::UTF16:
3465  case StringLiteral::UTF32:
3466  // We don't allow UTF literals to be implicitly converted
3467  break;
3468  case StringLiteral::Ascii:
3469  return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3470  ToPointeeType->getKind() == BuiltinType::Char_S);
3471  case StringLiteral::Wide:
3473  QualType(ToPointeeType, 0));
3474  }
3475  }
3476  }
3477 
3478  return false;
3479 }
3480 
3482  SourceLocation CastLoc,
3483  QualType Ty,
3484  CastKind Kind,
3485  CXXMethodDecl *Method,
3486  DeclAccessPair FoundDecl,
3487  bool HadMultipleCandidates,
3488  Expr *From) {
3489  switch (Kind) {
3490  default: llvm_unreachable("Unhandled cast kind!");
3491  case CK_ConstructorConversion: {
3492  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
3493  SmallVector<Expr*, 8> ConstructorArgs;
3494 
3495  if (S.RequireNonAbstractType(CastLoc, Ty,
3496  diag::err_allocation_of_abstract_type))
3497  return ExprError();
3498 
3499  if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
3500  return ExprError();
3501 
3502  S.CheckConstructorAccess(CastLoc, Constructor, FoundDecl,
3504  if (S.DiagnoseUseOfDecl(Method, CastLoc))
3505  return ExprError();
3506 
3508  CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3509  ConstructorArgs, HadMultipleCandidates,
3510  /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3512  if (Result.isInvalid())
3513  return ExprError();
3514 
3515  return S.MaybeBindToTemporary(Result.getAs<Expr>());
3516  }
3517 
3518  case CK_UserDefinedConversion: {
3519  assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
3520 
3521  S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl);
3522  if (S.DiagnoseUseOfDecl(Method, CastLoc))
3523  return ExprError();
3524 
3525  // Create an implicit call expr that calls it.
3526  CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
3527  ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
3528  HadMultipleCandidates);
3529  if (Result.isInvalid())
3530  return ExprError();
3531  // Record usage of conversion in an implicit cast.
3532  Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(),
3533  CK_UserDefinedConversion, Result.get(),
3534  nullptr, Result.get()->getValueKind());
3535 
3536  return S.MaybeBindToTemporary(Result.get());
3537  }
3538  }
3539 }
3540 
3541 /// PerformImplicitConversion - Perform an implicit conversion of the
3542 /// expression From to the type ToType using the pre-computed implicit
3543 /// conversion sequence ICS. Returns the converted
3544 /// expression. Action is the kind of conversion we're performing,
3545 /// used in the error message.
3546 ExprResult
3548  const ImplicitConversionSequence &ICS,
3549  AssignmentAction Action,
3550  CheckedConversionKind CCK) {
3551  switch (ICS.getKind()) {
3553  ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
3554  Action, CCK);
3555  if (Res.isInvalid())
3556  return ExprError();
3557  From = Res.get();
3558  break;
3559  }
3560 
3562 
3565  QualType BeforeToType;
3566  assert(FD && "no conversion function for user-defined conversion seq");
3567  if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
3568  CastKind = CK_UserDefinedConversion;
3569 
3570  // If the user-defined conversion is specified by a conversion function,
3571  // the initial standard conversion sequence converts the source type to
3572  // the implicit object parameter of the conversion function.
3573  BeforeToType = Context.getTagDeclType(Conv->getParent());
3574  } else {
3575  const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
3576  CastKind = CK_ConstructorConversion;
3577  // Do no conversion if dealing with ... for the first conversion.
3578  if (!ICS.UserDefined.EllipsisConversion) {
3579  // If the user-defined conversion is specified by a constructor, the
3580  // initial standard conversion sequence converts the source type to
3581  // the type required by the argument of the constructor
3582  BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
3583  }
3584  }
3585  // Watch out for ellipsis conversion.
3586  if (!ICS.UserDefined.EllipsisConversion) {
3587  ExprResult Res =
3588  PerformImplicitConversion(From, BeforeToType,
3590  CCK);
3591  if (Res.isInvalid())
3592  return ExprError();
3593  From = Res.get();
3594  }
3595 
3596  ExprResult CastArg
3597  = BuildCXXCastArgument(*this,
3598  From->getLocStart(),
3599  ToType.getNonReferenceType(),
3600  CastKind, cast<CXXMethodDecl>(FD),
3603  From);
3604 
3605  if (CastArg.isInvalid())
3606  return ExprError();
3607 
3608  From = CastArg.get();
3609 
3610  return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
3611  AA_Converting, CCK);
3612  }
3613 
3615  ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
3616  PDiag(diag::err_typecheck_ambiguous_condition)
3617  << From->getSourceRange());
3618  return ExprError();
3619 
3621  llvm_unreachable("Cannot perform an ellipsis conversion");
3622 
3624  bool Diagnosed =
3626  From->getType(), From, Action);
3627  assert(Diagnosed && "failed to diagnose bad conversion"); (void)Diagnosed;
3628  return ExprError();
3629  }
3630 
3631  // Everything went well.
3632  return From;
3633 }
3634 
3635 /// PerformImplicitConversion - Perform an implicit conversion of the
3636 /// expression From to the type ToType by following the standard
3637 /// conversion sequence SCS. Returns the converted
3638 /// expression. Flavor is the context in which we're performing this
3639 /// conversion, for use in error messages.
3640 ExprResult
3642  const StandardConversionSequence& SCS,
3643  AssignmentAction Action,
3644  CheckedConversionKind CCK) {
3645  bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast);
3646 
3647  // Overall FIXME: we are recomputing too many types here and doing far too
3648  // much extra work. What this means is that we need to keep track of more
3649  // information that is computed when we try the implicit conversion initially,
3650  // so that we don't need to recompute anything here.
3651  QualType FromType = From->getType();
3652 
3653  if (SCS.CopyConstructor) {
3654  // FIXME: When can ToType be a reference type?
3655  assert(!ToType->isReferenceType());
3656  if (SCS.Second == ICK_Derived_To_Base) {
3657  SmallVector<Expr*, 8> ConstructorArgs;
3658  if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
3659  From, /*FIXME:ConstructLoc*/SourceLocation(),
3660  ConstructorArgs))
3661  return ExprError();
3662  return BuildCXXConstructExpr(
3663  /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
3665  ConstructorArgs, /*HadMultipleCandidates*/ false,
3666  /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3668  }
3669  return BuildCXXConstructExpr(
3670  /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
3672  From, /*HadMultipleCandidates*/ false,
3673  /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3675  }
3676 
3677  // Resolve overloaded function references.
3678  if (Context.hasSameType(FromType, Context.OverloadTy)) {
3679  DeclAccessPair Found;
3681  true, Found);
3682  if (!Fn)
3683  return ExprError();
3684 
3685  if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
3686  return ExprError();
3687 
3688  From = FixOverloadedFunctionReference(From, Found, Fn);
3689  FromType = From->getType();
3690  }
3691 
3692  // If we're converting to an atomic type, first convert to the corresponding
3693  // non-atomic type.
3694  QualType ToAtomicType;
3695  if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
3696  ToAtomicType = ToType;
3697  ToType = ToAtomic->getValueType();
3698  }
3699 
3700  QualType InitialFromType = FromType;
3701  // Perform the first implicit conversion.
3702  switch (SCS.First) {
3703  case ICK_Identity:
3704  if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
3705  FromType = FromAtomic->getValueType().getUnqualifiedType();
3706  From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
3707  From, /*BasePath=*/nullptr, VK_RValue);
3708  }
3709  break;
3710 
3711  case ICK_Lvalue_To_Rvalue: {
3712  assert(From->getObjectKind() != OK_ObjCProperty);
3713  ExprResult FromRes = DefaultLvalueConversion(From);
3714  assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
3715  From = FromRes.get();
3716  FromType = From->getType();
3717  break;
3718  }
3719 
3720  case ICK_Array_To_Pointer:
3721  FromType = Context.getArrayDecayedType(FromType);
3722  From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
3723  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3724  break;
3725 
3727  FromType = Context.getPointerType(FromType);
3728  From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
3729  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3730  break;
3731 
3732  default:
3733  llvm_unreachable("Improper first standard conversion");
3734  }
3735 
3736  // Perform the second implicit conversion
3737  switch (SCS.Second) {
3738  case ICK_Identity:
3739  // C++ [except.spec]p5:
3740  // [For] assignment to and initialization of pointers to functions,
3741  // pointers to member functions, and references to functions: the
3742  // target entity shall allow at least the exceptions allowed by the
3743  // source value in the assignment or initialization.
3744  switch (Action) {
3745  case AA_Assigning:
3746  case AA_Initializing:
3747  // Note, function argument passing and returning are initialization.
3748  case AA_Passing:
3749  case AA_Returning:
3750  case AA_Sending:
3751  case AA_Passing_CFAudited:
3752  if (CheckExceptionSpecCompatibility(From, ToType))
3753  return ExprError();
3754  break;
3755 
3756  case AA_Casting:
3757  case AA_Converting:
3758  // Casts and implicit conversions are not initialization, so are not
3759  // checked for exception specification mismatches.
3760  break;
3761  }
3762  // Nothing else to do.
3763  break;
3764 
3767  if (ToType->isBooleanType()) {
3768  assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
3769  SCS.Second == ICK_Integral_Promotion &&
3770  "only enums with fixed underlying type can promote to bool");
3771  From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
3772  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3773  } else {
3774  From = ImpCastExprToType(From, ToType, CK_IntegralCast,
3775  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3776  }
3777  break;
3778 
3781  From = ImpCastExprToType(From, ToType, CK_FloatingCast,
3782  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3783  break;
3784 
3785  case ICK_Complex_Promotion:
3786  case ICK_Complex_Conversion: {
3787  QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
3788  QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
3789  CastKind CK;
3790  if (FromEl->isRealFloatingType()) {
3791  if (ToEl->isRealFloatingType())
3792  CK = CK_FloatingComplexCast;
3793  else
3794  CK = CK_FloatingComplexToIntegralComplex;
3795  } else if (ToEl->isRealFloatingType()) {
3796  CK = CK_IntegralComplexToFloatingComplex;
3797  } else {
3798  CK = CK_IntegralComplexCast;
3799  }
3800  From = ImpCastExprToType(From, ToType, CK,
3801  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3802  break;
3803  }
3804 
3805  case ICK_Floating_Integral:
3806  if (ToType->isRealFloatingType())
3807  From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
3808  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3809  else
3810  From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
3811  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3812  break;
3813 
3815  From = ImpCastExprToType(From, ToType, CK_NoOp,
3816  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3817  break;
3818 
3820  case ICK_Pointer_Conversion: {
3821  if (SCS.IncompatibleObjC && Action != AA_Casting) {
3822  // Diagnose incompatible Objective-C conversions
3823  if (Action == AA_Initializing || Action == AA_Assigning)
3824  Diag(From->getLocStart(),
3825  diag::ext_typecheck_convert_incompatible_pointer)
3826  << ToType << From->getType() << Action
3827  << From->getSourceRange() << 0;
3828  else
3829  Diag(From->getLocStart(),
3830  diag::ext_typecheck_convert_incompatible_pointer)
3831  << From->getType() << ToType << Action
3832  << From->getSourceRange() << 0;
3833 
3834  if (From->getType()->isObjCObjectPointerType() &&
3835  ToType->isObjCObjectPointerType())
3839  From->getType())) {
3840  if (Action == AA_Initializing)
3841  Diag(From->getLocStart(),
3842  diag::err_arc_weak_unavailable_assign);
3843  else
3844  Diag(From->getLocStart(),
3845  diag::err_arc_convesion_of_weak_unavailable)
3846  << (Action == AA_Casting) << From->getType() << ToType
3847  << From->getSourceRange();
3848  }
3849 
3850  CastKind Kind;
3851  CXXCastPath BasePath;
3852  if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
3853  return ExprError();
3854 
3855  // Make sure we extend blocks if necessary.
3856  // FIXME: doing this here is really ugly.
3857  if (Kind == CK_BlockPointerToObjCPointerCast) {
3858  ExprResult E = From;
3860  From = E.get();
3861  }
3862  if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
3863  CheckObjCConversion(SourceRange(), ToType, From, CCK);
3864  From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
3865  .get();
3866  break;
3867  }
3868 
3869  case ICK_Pointer_Member: {
3870  CastKind Kind;
3871  CXXCastPath BasePath;
3872  if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
3873  return ExprError();
3874  if (CheckExceptionSpecCompatibility(From, ToType))
3875  return ExprError();
3876 
3877  // We may not have been able to figure out what this member pointer resolved
3878  // to up until this exact point. Attempt to lock-in it's inheritance model.
3880  (void)isCompleteType(From->getExprLoc(), From->getType());
3881  (void)isCompleteType(From->getExprLoc(), ToType);
3882  }
3883 
3884  From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
3885  .get();
3886  break;
3887  }
3888 
3890  // Perform half-to-boolean conversion via float.
3891  if (From->getType()->isHalfType()) {
3892  From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get();
3893  FromType = Context.FloatTy;
3894  }
3895 
3896  From = ImpCastExprToType(From, Context.BoolTy,
3897  ScalarTypeToBooleanCastKind(FromType),
3898  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3899  break;
3900 
3901  case ICK_Derived_To_Base: {
3902  CXXCastPath BasePath;
3904  ToType.getNonReferenceType(),
3905  From->getLocStart(),
3906  From->getSourceRange(),
3907  &BasePath,
3908  CStyle))
3909  return ExprError();
3910 
3911  From = ImpCastExprToType(From, ToType.getNonReferenceType(),
3912  CK_DerivedToBase, From->getValueKind(),
3913  &BasePath, CCK).get();
3914  break;
3915  }
3916 
3917  case ICK_Vector_Conversion:
3918  From = ImpCastExprToType(From, ToType, CK_BitCast,
3919  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3920  break;
3921 
3922  case ICK_Vector_Splat: {
3923  // Vector splat from any arithmetic type to a vector.
3924  Expr *Elem = prepareVectorSplat(ToType, From).get();
3925  From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_RValue,
3926  /*BasePath=*/nullptr, CCK).get();
3927  break;
3928  }
3929 
3930  case ICK_Complex_Real:
3931  // Case 1. x -> _Complex y
3932  if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
3933  QualType ElType = ToComplex->getElementType();
3934  bool isFloatingComplex = ElType->isRealFloatingType();
3935 
3936  // x -> y
3937  if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
3938  // do nothing
3939  } else if (From->getType()->isRealFloatingType()) {
3940  From = ImpCastExprToType(From, ElType,
3941  isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get();
3942  } else {
3943  assert(From->getType()->isIntegerType());
3944  From = ImpCastExprToType(From, ElType,
3945  isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get();
3946  }
3947  // y -> _Complex y
3948  From = ImpCastExprToType(From, ToType,
3949  isFloatingComplex ? CK_FloatingRealToComplex
3950  : CK_IntegralRealToComplex).get();
3951 
3952  // Case 2. _Complex x -> y
3953  } else {
3954  const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
3955  assert(FromComplex);
3956 
3957  QualType ElType = FromComplex->getElementType();
3958  bool isFloatingComplex = ElType->isRealFloatingType();
3959 
3960  // _Complex x -> x
3961  From = ImpCastExprToType(From, ElType,
3962  isFloatingComplex ? CK_FloatingComplexToReal
3963  : CK_IntegralComplexToReal,
3964  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3965 
3966  // x -> y
3967  if (Context.hasSameUnqualifiedType(ElType, ToType)) {
3968  // do nothing
3969  } else if (ToType->isRealFloatingType()) {
3970  From = ImpCastExprToType(From, ToType,
3971  isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
3972  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3973  } else {
3974  assert(ToType->isIntegerType());
3975  From = ImpCastExprToType(From, ToType,
3976  isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
3977  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3978  }
3979  }
3980  break;
3981 
3983  From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
3984  VK_RValue, /*BasePath=*/nullptr, CCK).get();
3985  break;
3986  }
3987 
3989  ExprResult FromRes = From;
3990  Sema::AssignConvertType ConvTy =
3992  if (FromRes.isInvalid())
3993  return ExprError();
3994  From = FromRes.get();
3995  assert ((ConvTy == Sema::Compatible) &&
3996  "Improper transparent union conversion");
3997  (void)ConvTy;
3998  break;
3999  }
4000 
4002  From = ImpCastExprToType(From, ToType,
4003  CK_ZeroToOCLEvent,
4004  From->getValueKind()).get();
4005  break;
4006 
4008  From = ImpCastExprToType(From, ToType,
4009  CK_ZeroToOCLQueue,
4010  From->getValueKind()).get();
4011  break;
4012 
4013  case ICK_Lvalue_To_Rvalue:
4014  case ICK_Array_To_Pointer:
4017  case ICK_Qualification:
4019  case ICK_C_Only_Conversion:
4021  llvm_unreachable("Improper second standard conversion");
4022  }
4023 
4024  switch (SCS.Third) {
4025  case ICK_Identity:
4026  // Nothing to do.
4027  break;
4028 
4030  // If both sides are functions (or pointers/references to them), there could
4031  // be incompatible exception declarations.
4032  if (CheckExceptionSpecCompatibility(From, ToType))
4033  return ExprError();
4034 
4035  From = ImpCastExprToType(From, ToType, CK_NoOp,
4036  VK_RValue, /*BasePath=*/nullptr, CCK).get();
4037  break;
4038 
4039  case ICK_Qualification: {
4040  // The qualification keeps the category of the inner expression, unless the
4041  // target type isn't a reference.
4042  ExprValueKind VK = ToType->isReferenceType() ?
4043  From->getValueKind() : VK_RValue;
4044  From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
4045  CK_NoOp, VK, /*BasePath=*/nullptr, CCK).get();
4046 
4048  !getLangOpts().WritableStrings) {
4049  Diag(From->getLocStart(), getLangOpts().CPlusPlus11
4050  ? diag::ext_deprecated_string_literal_conversion
4051  : diag::warn_deprecated_string_literal_conversion)
4052  << ToType.getNonReferenceType();
4053  }
4054 
4055  break;
4056  }
4057 
4058  default:
4059  llvm_unreachable("Improper third standard conversion");
4060  }
4061 
4062  // If this conversion sequence involved a scalar -> atomic conversion, perform
4063  // that conversion now.
4064  if (!ToAtomicType.isNull()) {
4065  assert(Context.hasSameType(
4066  ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()));
4067  From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic,
4068  VK_RValue, nullptr, CCK).get();
4069  }
4070 
4071  // If this conversion sequence succeeded and involved implicitly converting a
4072  // _Nullable type to a _Nonnull one, complain.
4073  if (CCK == CCK_ImplicitConversion)
4074  diagnoseNullableToNonnullConversion(ToType, InitialFromType,
4075  From->getLocStart());
4076 
4077  return From;
4078 }
4079 
4080 /// \brief Check the completeness of a type in a unary type trait.
4081 ///
4082 /// If the particular type trait requires a complete type, tries to complete
4083 /// it. If completing the type fails, a diagnostic is emitted and false
4084 /// returned. If completing the type succeeds or no completion was required,
4085 /// returns true.
4087  SourceLocation Loc,
4088  QualType ArgTy) {
4089  // C++0x [meta.unary.prop]p3:
4090  // For all of the class templates X declared in this Clause, instantiating
4091  // that template with a template argument that is a class template
4092  // specialization may result in the implicit instantiation of the template
4093  // argument if and only if the semantics of X require that the argument
4094  // must be a complete type.
4095  // We apply this rule to all the type trait expressions used to implement
4096  // these class templates. We also try to follow any GCC documented behavior
4097  // in these expressions to ensure portability of standard libraries.
4098  switch (UTT) {
4099  default: llvm_unreachable("not a UTT");
4100  // is_complete_type somewhat obviously cannot require a complete type.
4101  case UTT_IsCompleteType:
4102  // Fall-through
4103 
4104  // These traits are modeled on the type predicates in C++0x
4105  // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
4106  // requiring a complete type, as whether or not they return true cannot be
4107  // impacted by the completeness of the type.
4108  case UTT_IsVoid:
4109  case UTT_IsIntegral:
4110  case UTT_IsFloatingPoint:
4111  case UTT_IsArray:
4112  case UTT_IsPointer:
4113  case UTT_IsLvalueReference:
4114  case UTT_IsRvalueReference:
4117  case UTT_IsEnum:
4118  case UTT_IsUnion:
4119  case UTT_IsClass:
4120  case UTT_IsFunction:
4121  case UTT_IsReference:
4122  case UTT_IsArithmetic:
4123  case UTT_IsFundamental:
4124  case UTT_IsObject:
4125  case UTT_IsScalar:
4126  case UTT_IsCompound:
4127  case UTT_IsMemberPointer:
4128  // Fall-through
4129 
4130  // These traits are modeled on type predicates in C++0x [meta.unary.prop]
4131  // which requires some of its traits to have the complete type. However,
4132  // the completeness of the type cannot impact these traits' semantics, and
4133  // so they don't require it. This matches the comments on these traits in
4134  // Table 49.
4135  case UTT_IsConst:
4136  case UTT_IsVolatile:
4137  case UTT_IsSigned:
4138  case UTT_IsUnsigned:
4139 
4140  // This type trait always returns false, checking the type is moot.
4141  case UTT_IsInterfaceClass:
4142  return true;
4143 
4144  // C++14 [meta.unary.prop]:
4145  // If T is a non-union class type, T shall be a complete type.
4146  case UTT_IsEmpty:
4147  case UTT_IsPolymorphic:
4148  case UTT_IsAbstract:
4149  if (const auto *RD = ArgTy->getAsCXXRecordDecl())
4150  if (!RD->isUnion())
4151  return !S.RequireCompleteType(
4152  Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4153  return true;
4154 
4155  // C++14 [meta.unary.prop]:
4156  // If T is a class type, T shall be a complete type.
4157  case UTT_IsFinal:
4158  case UTT_IsSealed:
4159  if (ArgTy->getAsCXXRecordDecl())
4160  return !S.RequireCompleteType(
4161  Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4162  return true;
4163 
4164  // C++1z [meta.unary.prop]:
4165  // remove_all_extents_t<T> shall be a complete type or cv void.
4166  case UTT_IsAggregate:
4167  case UTT_IsTrivial:
4169  case UTT_IsStandardLayout:
4170  case UTT_IsPOD:
4171  case UTT_IsLiteral:
4172  // Per the GCC type traits documentation, T shall be a complete type, cv void,
4173  // or an array of unknown bound. But GCC actually imposes the same constraints
4174  // as above.
4175  case UTT_HasNothrowAssign:
4178  case UTT_HasNothrowCopy:
4179  case UTT_HasTrivialAssign:
4183  case UTT_HasTrivialCopy:
4186  ArgTy = QualType(ArgTy->getBaseElementTypeUnsafe(), 0);
4187  LLVM_FALLTHROUGH;
4188 
4189  // C++1z [meta.unary.prop]:
4190  // T shall be a complete type, cv void, or an array of unknown bound.
4191  case UTT_IsDestructible:
4195  if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
4196  return true;
4197 
4198  return !S.RequireCompleteType(
4199  Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4200  }
4201 }
4202 
4204  Sema &Self, SourceLocation KeyLoc, ASTContext &C,
4205  bool (CXXRecordDecl::*HasTrivial)() const,
4206  bool (CXXRecordDecl::*HasNonTrivial)() const,
4207  bool (CXXMethodDecl::*IsDesiredOp)() const)
4208 {
4209  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
4210  if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4211  return true;
4212 
4214  DeclarationNameInfo NameInfo(Name, KeyLoc);
4215  LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName);
4216  if (Self.LookupQualifiedName(Res, RD)) {
4217  bool FoundOperator = false;
4218  Res.suppressDiagnostics();
4219  for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
4220  Op != OpEnd; ++Op) {
4221  if (isa<FunctionTemplateDecl>(*Op))
4222  continue;
4223 
4224  CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
4225  if((Operator->*IsDesiredOp)()) {
4226  FoundOperator = true;
4227  const FunctionProtoType *CPT =
4228  Operator->getType()->getAs<FunctionProtoType>();
4229  CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4230  if (!CPT || !CPT->isNothrow(C))
4231  return false;
4232  }
4233  }
4234  return FoundOperator;
4235  }
4236  return false;
4237 }
4238 
4239 static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
4240  SourceLocation KeyLoc, QualType T) {
4241  assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
4242 
4243  ASTContext &C = Self.Context;
4244  switch(UTT) {
4245  default: llvm_unreachable("not a UTT");
4246  // Type trait expressions corresponding to the primary type category
4247  // predicates in C++0x [meta.unary.cat].
4248  case UTT_IsVoid:
4249  return T->isVoidType();
4250  case UTT_IsIntegral:
4251  return T->isIntegralType(C);
4252  case UTT_IsFloatingPoint:
4253  return T->isFloatingType();
4254  case UTT_IsArray:
4255  return T->isArrayType();
4256  case UTT_IsPointer:
4257  return T->isPointerType();
4258  case UTT_IsLvalueReference:
4259  return T->isLValueReferenceType();
4260  case UTT_IsRvalueReference:
4261  return T->isRValueReferenceType();
4263  return T->isMemberFunctionPointerType();
4265  return T->isMemberDataPointerType();
4266  case UTT_IsEnum:
4267  return T->isEnumeralType();
4268  case UTT_IsUnion:
4269  return T->isUnionType();
4270  case UTT_IsClass:
4271  return T->isClassType() || T->isStructureType() || T->isInterfaceType();
4272  case UTT_IsFunction:
4273  return T->isFunctionType();
4274 
4275  // Type trait expressions which correspond to the convenient composition
4276  // predicates in C++0x [meta.unary.comp].
4277  case UTT_IsReference:
4278  return T->isReferenceType();
4279  case UTT_IsArithmetic:
4280  return T->isArithmeticType() && !T->isEnumeralType();
4281  case UTT_IsFundamental:
4282  return T->isFundamentalType();
4283  case UTT_IsObject:
4284  return T->isObjectType();
4285  case UTT_IsScalar:
4286  // Note: semantic analysis depends on Objective-C lifetime types to be
4287  // considered scalar types. However, such types do not actually behave
4288  // like scalar types at run time (since they may require retain/release
4289  // operations), so we report them as non-scalar.
4290  if (T->isObjCLifetimeType()) {
4291  switch (T.getObjCLifetime()) {
4292  case Qualifiers::OCL_None:
4294  return true;
4295 
4297  case Qualifiers::OCL_Weak:
4299  return false;
4300  }
4301  }
4302 
4303  return T->isScalarType();
4304  case UTT_IsCompound:
4305  return T->isCompoundType();
4306  case UTT_IsMemberPointer:
4307  return T->isMemberPointerType();
4308 
4309  // Type trait expressions which correspond to the type property predicates
4310  // in C++0x [meta.unary.prop].
4311  case UTT_IsConst:
4312  return T.isConstQualified();
4313  case UTT_IsVolatile:
4314  return T.isVolatileQualified();
4315  case UTT_IsTrivial:
4316  return T.isTrivialType(C);
4318  return T.isTriviallyCopyableType(C);
4319  case UTT_IsStandardLayout:
4320  return T->isStandardLayoutType();
4321  case UTT_IsPOD:
4322  return T.isPODType(C);
4323  case UTT_IsLiteral:
4324  return T->isLiteralType(C);
4325  case UTT_IsEmpty:
4326  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4327  return !RD->isUnion() && RD->isEmpty();
4328  return false;
4329  case UTT_IsPolymorphic:
4330  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4331  return !RD->isUnion() && RD->isPolymorphic();
4332  return false;
4333  case UTT_IsAbstract:
4334  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4335  return !RD->isUnion() && RD->isAbstract();
4336  return false;
4337  case UTT_IsAggregate:
4338  // Report vector extensions and complex types as aggregates because they
4339  // support aggregate initialization. GCC mirrors this behavior for vectors
4340  // but not _Complex.
4341  return T->isAggregateType() || T->isVectorType() || T->isExtVectorType() ||
4342  T->isAnyComplexType();
4343  // __is_interface_class only returns true when CL is invoked in /CLR mode and
4344  // even then only when it is used with the 'interface struct ...' syntax
4345  // Clang doesn't support /CLR which makes this type trait moot.
4346  case UTT_IsInterfaceClass:
4347  return false;
4348  case UTT_IsFinal:
4349  case UTT_IsSealed:
4350  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4351  return RD->hasAttr<FinalAttr>();
4352  return false;
4353  case UTT_IsSigned:
4354  return T->isSignedIntegerType();
4355  case UTT_IsUnsigned:
4356  return T->isUnsignedIntegerType();
4357 
4358  // Type trait expressions which query classes regarding their construction,
4359  // destruction, and copying. Rather than being based directly on the
4360  // related type predicates in the standard, they are specified by both
4361  // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
4362  // specifications.
4363  //
4364  // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
4365  // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4366  //
4367  // Note that these builtins do not behave as documented in g++: if a class
4368  // has both a trivial and a non-trivial special member of a particular kind,
4369  // they return false! For now, we emulate this behavior.
4370  // FIXME: This appears to be a g++ bug: more complex cases reveal that it
4371  // does not correctly compute triviality in the presence of multiple special
4372  // members of the same kind. Revisit this once the g++ bug is fixed.
4374  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4375  // If __is_pod (type) is true then the trait is true, else if type is
4376  // a cv class or union type (or array thereof) with a trivial default
4377  // constructor ([class.ctor]) then the trait is true, else it is false.
4378  if (T.isPODType(C))
4379  return true;
4380  if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4381  return RD->hasTrivialDefaultConstructor() &&
4382  !RD->hasNonTrivialDefaultConstructor();
4383  return false;
4385  // This trait is implemented by MSVC 2012 and needed to parse the
4386  // standard library headers. Specifically this is used as the logic
4387  // behind std::is_trivially_move_constructible (20.9.4.3).
4388  if (T.isPODType(C))
4389  return true;
4390  if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4391  return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4392  return false;
4393  case UTT_HasTrivialCopy:
4394  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4395  // If __is_pod (type) is true or type is a reference type then
4396  // the trait is true, else if type is a cv class or union type
4397  // with a trivial copy constructor ([class.copy]) then the trait
4398  // is true, else it is false.
4399  if (T.isPODType(C) || T->isReferenceType())
4400  return true;
4401  if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4402  return RD->hasTrivialCopyConstructor() &&
4403  !RD->hasNonTrivialCopyConstructor();
4404  return false;
4406  // This trait is implemented by MSVC 2012 and needed to parse the
4407  // standard library headers. Specifically it is used as the logic
4408  // behind std::is_trivially_move_assignable (20.9.4.3)
4409  if (T.isPODType(C))
4410  return true;
4411  if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4412  return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4413  return false;
4414  case UTT_HasTrivialAssign:
4415  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4416  // If type is const qualified or is a reference type then the
4417  // trait is false. Otherwise if __is_pod (type) is true then the
4418  // trait is true, else if type is a cv class or union type with
4419  // a trivial copy assignment ([class.copy]) then the trait is
4420  // true, else it is false.
4421  // Note: the const and reference restrictions are interesting,
4422  // given that const and reference members don't prevent a class
4423  // from having a trivial copy assignment operator (but do cause
4424  // errors if the copy assignment operator is actually used, q.v.
4425  // [class.copy]p12).
4426 
4427  if (T.isConstQualified())
4428  return false;
4429  if (T.isPODType(C))
4430  return true;
4431  if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4432  return RD->hasTrivialCopyAssignment() &&
4433  !RD->hasNonTrivialCopyAssignment();
4434  return false;
4435  case UTT_IsDestructible:
4438  // C++14 [meta.unary.prop]:
4439  // For reference types, is_destructible<T>::value is true.
4440  if (T->isReferenceType())
4441  return true;
4442 
4443  // Objective-C++ ARC: autorelease types don't require destruction.
4444  if (T->isObjCLifetimeType() &&
4446  return true;
4447 
4448  // C++14 [meta.unary.prop]:
4449  // For incomplete types and function types, is_destructible<T>::value is
4450  // false.
4451  if (T->isIncompleteType() || T->isFunctionType())
4452  return false;
4453 
4454  // A type that requires destruction (via a non-trivial destructor or ARC
4455  // lifetime semantics) is not trivially-destructible.
4457  return false;
4458 
4459  // C++14 [meta.unary.prop]:
4460  // For object types and given U equal to remove_all_extents_t<T>, if the
4461  // expression std::declval<U&>().~U() is well-formed when treated as an
4462  // unevaluated operand (Clause 5), then is_destructible<T>::value is true
4463  if (auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4464  CXXDestructorDecl *Destructor = Self.LookupDestructor(RD);
4465  if (!Destructor)
4466  return false;
4467  // C++14 [dcl.fct.def.delete]p2:
4468  // A program that refers to a deleted function implicitly or
4469  // explicitly, other than to declare it, is ill-formed.
4470  if (Destructor->isDeleted())
4471  return false;
4472  if (C.getLangOpts().AccessControl && Destructor->getAccess() != AS_public)
4473  return false;
4474  if (UTT == UTT_IsNothrowDestructible) {
4475  const FunctionProtoType *CPT =
4476  Destructor->getType()->getAs<FunctionProtoType>();
4477  CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4478  if (!CPT || !CPT->isNothrow(C))
4479  return false;
4480  }
4481  }
4482  return true;
4483 
4485  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
4486  // If __is_pod (type) is true or type is a reference type
4487  // then the trait is true, else if type is a cv class or union
4488  // type (or array thereof) with a trivial destructor
4489  // ([class.dtor]) then the trait is true, else it is
4490  // false.
4491  if (T.isPODType(C) || T->isReferenceType())
4492  return true;
4493 
4494  // Objective-C++ ARC: autorelease types don't require destruction.
4495  if (T->isObjCLifetimeType() &&
4497  return true;
4498 
4499  if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4500  return RD->hasTrivialDestructor();
4501  return false;
4502  // TODO: Propagate nothrowness for implicitly declared special members.
4503  case UTT_HasNothrowAssign:
4504  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4505  // If type is const qualified or is a reference type then the
4506  // trait is false. Otherwise if __has_trivial_assign (type)
4507  // is true then the trait is true, else if type is a cv class
4508  // or union type with copy assignment operators that are known
4509  // not to throw an exception then the trait is true, else it is
4510  // false.
4511  if (C.getBaseElementType(T).isConstQualified())
4512  return false;
4513  if (T->isReferenceType())
4514  return false;
4515  if (T.isPODType(C) || T->isObjCLifetimeType())
4516  return true;
4517 
4518  if (const RecordType *RT = T->getAs<RecordType>())
4519  return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
4523  return false;
4525  // This trait is implemented by MSVC 2012 and needed to parse the
4526  // standard library headers. Specifically this is used as the logic
4527  // behind std::is_nothrow_move_assignable (20.9.4.3).
4528  if (T.isPODType(C))
4529  return true;
4530 
4531  if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
4532  return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
4536  return false;
4537  case UTT_HasNothrowCopy:
4538  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4539  // If __has_trivial_copy (type) is true then the trait is true, else
4540  // if type is a cv class or union type with copy constructors that are
4541  // known not to throw an exception then the trait is true, else it is
4542  // false.
4543  if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType())
4544  return true;
4545  if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
4546  if (RD->hasTrivialCopyConstructor() &&
4547  !RD->hasNonTrivialCopyConstructor())
4548  return true;
4549 
4550  bool FoundConstructor = false;
4551  unsigned FoundTQs;
4552  for (const auto *ND : Self.LookupConstructors(RD)) {
4553  // A template constructor is never a copy constructor.
4554  // FIXME: However, it may actually be selected at the actual overload
4555  // resolution point.
4556  if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4557  continue;
4558  // UsingDecl itself is not a constructor
4559  if (isa<UsingDecl>(ND))
4560  continue;
4561  auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4562  if (Constructor->isCopyConstructor(FoundTQs)) {
4563  FoundConstructor = true;
4564  const FunctionProtoType *CPT
4565  = Constructor->getType()->getAs<FunctionProtoType>();
4566  CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4567  if (!CPT)
4568  return false;
4569  // TODO: check whether evaluating default arguments can throw.
4570  // For now, we'll be conservative and assume that they can throw.
4571  if (!CPT->isNothrow(C) || CPT->getNumParams() > 1)
4572  return false;
4573  }
4574  }
4575 
4576  return FoundConstructor;
4577  }
4578  return false;
4580  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
4581  // If __has_trivial_constructor (type) is true then the trait is
4582  // true, else if type is a cv class or union type (or array
4583  // thereof) with a default constructor that is known not to
4584  // throw an exception then the trait is true, else it is false.
4585  if (T.isPODType(C) || T->isObjCLifetimeType())
4586  return true;
4587  if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4588  if (RD->hasTrivialDefaultConstructor() &&
4589  !RD->hasNonTrivialDefaultConstructor())
4590  return true;
4591 
4592  bool FoundConstructor = false;
4593  for (const auto *ND : Self.LookupConstructors(RD)) {
4594  // FIXME: In C++0x, a constructor template can be a default constructor.
4595  if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4596  continue;
4597  // UsingDecl itself is not a constructor
4598  if (isa<UsingDecl>(ND))
4599  continue;
4600  auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4601  if (Constructor->isDefaultConstructor()) {
4602  FoundConstructor = true;
4603  const FunctionProtoType *CPT
4604  = Constructor->getType()->getAs<FunctionProtoType>();
4605  CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4606  if (!CPT)
4607  return false;
4608  // FIXME: check whether evaluating default arguments can throw.
4609  // For now, we'll be conservative and assume that they can throw.
4610  if (!CPT->isNothrow(C) || CPT->getNumParams() > 0)
4611  return false;
4612  }
4613  }
4614  return FoundConstructor;
4615  }
4616  return false;
4618  // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4619  // If type is a class type with a virtual destructor ([class.dtor])
4620  // then the trait is true, else it is false.
4621  if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4622  if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
4623  return Destructor->isVirtual();
4624  return false;
4625 
4626  // These type trait expressions are modeled on the specifications for the
4627  // Embarcadero C++0x type trait functions:
4628  // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4629  case UTT_IsCompleteType:
4630  // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
4631  // Returns True if and only if T is a complete type at the point of the
4632  // function call.
4633  return !T->isIncompleteType();
4635  return C.hasUniqueObjectRepresentations(T);
4636  }
4637 }
4638 
4639 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4640  QualType RhsT, SourceLocation KeyLoc);
4641 
4644  SourceLocation RParenLoc) {
4645  if (Kind <= UTT_Last)
4646  return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
4647 
4648  if (Kind <= BTT_Last)
4649  return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
4650  Args[1]->getType(), RParenLoc);
4651 
4652  switch (Kind) {
4656  // C++11 [meta.unary.prop]:
4657  // is_trivially_constructible is defined as:
4658  //
4659  // is_constructible<T, Args...>::value is true and the variable
4660  // definition for is_constructible, as defined below, is known to call
4661  // no operation that is not trivial.
4662  //
4663  // The predicate condition for a template specialization
4664  // is_constructible<T, Args...> shall be satisfied if and only if the
4665  // following variable definition would be well-formed for some invented
4666  // variable t:
4667  //
4668  // T t(create<Args>()...);
4669  assert(!Args.empty());
4670 
4671  // Precondition: T and all types in the parameter pack Args shall be
4672  // complete types, (possibly cv-qualified) void, or arrays of
4673  // unknown bound.
4674  for (const auto *TSI : Args) {
4675  QualType ArgTy = TSI->getType();
4676  if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
4677  continue;
4678 
4679  if (S.RequireCompleteType(KWLoc, ArgTy,
4680  diag::err_incomplete_type_used_in_type_trait_expr))
4681  return false;
4682  }
4683 
4684  // Make sure the first argument is not incomplete nor a function type.
4685  QualType T = Args[0]->getType();
4686  if (T->isIncompleteType() || T->isFunctionType())
4687  return false;
4688 
4689  // Make sure the first argument is not an abstract type.
4690  CXXRecordDecl *RD = T->getAsCXXRecordDecl();
4691  if (RD && RD->isAbstract())
4692  return false;
4693 
4694  SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
4695  SmallVector<Expr *, 2> ArgExprs;
4696  ArgExprs.reserve(Args.size() - 1);
4697  for (unsigned I = 1, N = Args.size(); I != N; ++I) {
4698  QualType ArgTy = Args[I]->getType();
4699  if (ArgTy->isObjectType() || ArgTy->isFunctionType())
4700  ArgTy = S.Context.getRValueReferenceType(ArgTy);
4701  OpaqueArgExprs.push_back(
4702  OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
4703  ArgTy.getNonLValueExprType(S.Context),
4704  Expr::getValueKindForType(ArgTy)));
4705  }
4706  for (Expr &E : OpaqueArgExprs)
4707  ArgExprs.push_back(&E);
4708 
4709  // Perform the initialization in an unevaluated context within a SFINAE
4710  // trap at translation unit scope.
4713  Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
4717  RParenLoc));
4718  InitializationSequence Init(S, To, InitKind, ArgExprs);
4719  if (Init.Failed())
4720  return false;
4721 
4722  ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
4723  if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4724  return false;
4725 
4726  if (Kind == clang::TT_IsConstructible)
4727  return true;
4728 
4730  return S.canThrow(Result.get()) == CT_Cannot;
4731 
4732  if (Kind == clang::TT_IsTriviallyConstructible) {
4733  // Under Objective-C ARC and Weak, if the destination has non-trivial
4734  // Objective-C lifetime, this is a non-trivial construction.
4736  return false;
4737 
4738  // The initialization succeeded; now make sure there are no non-trivial
4739  // calls.
4740  return !Result.get()->hasNonTrivialCall(S.Context);
4741  }
4742 
4743  llvm_unreachable("unhandled type trait");
4744  return false;
4745  }
4746  default: llvm_unreachable("not a TT");
4747  }
4748 
4749  return false;
4750 }
4751 
4754  SourceLocation RParenLoc) {
4755  QualType ResultType = Context.getLogicalOperationType();
4756 
4758  *this, Kind, KWLoc, Args[0]->getType()))
4759  return ExprError();
4760 
4761  bool Dependent = false;
4762  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4763  if (Args[I]->getType()->isDependentType()) {
4764  Dependent = true;
4765  break;
4766  }
4767  }
4768 
4769  bool Result = false;
4770  if (!Dependent)
4771  Result = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc);
4772 
4773  return TypeTraitExpr::Create(Context, ResultType, KWLoc, Kind, Args,
4774  RParenLoc, Result);
4775 }
4776 
4778  ArrayRef<ParsedType> Args,
4779  SourceLocation RParenLoc) {
4780  SmallVector<TypeSourceInfo *, 4> ConvertedArgs;
4781  ConvertedArgs.reserve(Args.size());
4782 
4783  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4784  TypeSourceInfo *TInfo;
4785  QualType T = GetTypeFromParser(Args[I], &TInfo);
4786  if (!TInfo)
4787  TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc);
4788 
4789  ConvertedArgs.push_back(TInfo);
4790  }
4791 
4792  return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc);
4793 }
4794 
4795 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4796  QualType RhsT, SourceLocation KeyLoc) {
4797  assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
4798  "Cannot evaluate traits of dependent types");
4799 
4800  switch(BTT) {
4801  case BTT_IsBaseOf: {
4802  // C++0x [meta.rel]p2
4803  // Base is a base class of Derived without regard to cv-qualifiers or
4804  // Base and Derived are not unions and name the same class type without
4805  // regard to cv-qualifiers.
4806 
4807  const RecordType *lhsRecord = LhsT->getAs<RecordType>();
4808  const RecordType *rhsRecord = RhsT->getAs<RecordType>();
4809  if (!rhsRecord || !lhsRecord) {
4810  const ObjCObjectType *LHSObjTy = LhsT->getAs<ObjCObjectType>();
4811  const ObjCObjectType *RHSObjTy = RhsT->getAs<ObjCObjectType>();
4812  if (!LHSObjTy || !RHSObjTy)
4813  return false;
4814 
4815  ObjCInterfaceDecl *BaseInterface = LHSObjTy->getInterface();
4816  ObjCInterfaceDecl *DerivedInterface = RHSObjTy->getInterface();
4817  if (!BaseInterface || !DerivedInterface)
4818  return false;
4819 
4820  if (Self.RequireCompleteType(
4821  KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
4822  return false;
4823 
4824  return BaseInterface->isSuperClassOf(DerivedInterface);
4825  }
4826 
4827  assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
4828  == (lhsRecord == rhsRecord));
4829 
4830  if (lhsRecord == rhsRecord)
4831  return !lhsRecord->getDecl()->isUnion();
4832 
4833  // C++0x [meta.rel]p2:
4834  // If Base and Derived are class types and are different types
4835  // (ignoring possible cv-qualifiers) then Derived shall be a
4836  // complete type.
4837  if (Self.RequireCompleteType(KeyLoc, RhsT,
4838  diag::err_incomplete_type_used_in_type_trait_expr))
4839  return false;
4840 
4841  return cast<CXXRecordDecl>(rhsRecord->getDecl())
4842  ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
4843  }
4844  case BTT_IsSame:
4845  return Self.Context.hasSameType(LhsT, RhsT);
4846  case BTT_TypeCompatible: {
4847  // GCC ignores cv-qualifiers on arrays for this builtin.
4848  Qualifiers LhsQuals, RhsQuals;
4849  QualType Lhs = Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);
4850  QualType Rhs = Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);
4851  return Self.Context.typesAreCompatible(Lhs, Rhs);
4852  }
4853  case BTT_IsConvertible:
4854  case BTT_IsConvertibleTo: {
4855  // C++0x [meta.rel]p4:
4856  // Given the following function prototype:
4857  //
4858  // template <class T>
4859  // typename add_rvalue_reference<T>::type create();
4860  //
4861  // the predicate condition for a template specialization
4862  // is_convertible<From, To> shall be satisfied if and only if
4863  // the return expression in the following code would be
4864  // well-formed, including any implicit conversions to the return
4865  // type of the function:
4866  //
4867  // To test() {
4868  // return create<From>();
4869  // }
4870  //
4871  // Access checking is performed as if in a context unrelated to To and
4872  // From. Only the validity of the immediate context of the expression
4873  // of the return-statement (including conversions to the return type)
4874  // is considered.
4875  //
4876  // We model the initialization as a copy-initialization of a temporary
4877  // of the appropriate type, which for this expression is identical to the
4878  // return statement (since NRVO doesn't apply).
4879 
4880  // Functions aren't allowed to return function or array types.
4881  if (RhsT->isFunctionType() || RhsT->isArrayType())
4882  return false;
4883 
4884  // A return statement in a void function must have void type.
4885  if (RhsT->isVoidType())
4886  return LhsT->isVoidType();
4887 
4888  // A function definition requires a complete, non-abstract return type.
4889  if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
4890  return false;
4891 
4892  // Compute the result of add_rvalue_reference.
4893  if (LhsT->isObjectType() || LhsT->isFunctionType())
4894  LhsT = Self.Context.getRValueReferenceType(LhsT);
4895 
4896  // Build a fake source and destination for initialization.
4898  OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
4900  Expr *FromPtr = &From;
4902  SourceLocation()));
4903 
4904  // Perform the initialization in an unevaluated context within a SFINAE
4905  // trap at translation unit scope.
4908  Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4909  Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
4910  InitializationSequence Init(Self, To, Kind, FromPtr);
4911  if (Init.Failed())
4912  return false;
4913 
4914  ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
4915  return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
4916  }
4917 
4918  case BTT_IsAssignable:
4921  // C++11 [meta.unary.prop]p3:
4922  // is_trivially_assignable is defined as:
4923  // is_assignable<T, U>::value is true and the assignment, as defined by
4924  // is_assignable, is known to call no operation that is not trivial
4925  //
4926  // is_assignable is defined as:
4927  // The expression declval<T>() = declval<U>() is well-formed when
4928  // treated as an unevaluated operand (Clause 5).
4929  //
4930  // For both, T and U shall be complete types, (possibly cv-qualified)
4931  // void, or arrays of unknown bound.
4932  if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
4933  Self.RequireCompleteType(KeyLoc, LhsT,
4934  diag::err_incomplete_type_used_in_type_trait_expr))
4935  return false;
4936  if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
4937  Self.RequireCompleteType(KeyLoc, RhsT,
4938  diag::err_incomplete_type_used_in_type_trait_expr))
4939  return false;
4940 
4941  // cv void is never assignable.
4942  if (LhsT->isVoidType() || RhsT->isVoidType())
4943  return false;
4944 
4945  // Build expressions that emulate the effect of declval<T>() and
4946  // declval<U>().
4947  if (LhsT->isObjectType() || LhsT->isFunctionType())
4948  LhsT = Self.Context.getRValueReferenceType(LhsT);
4949  if (RhsT->isObjectType() || RhsT->isFunctionType())
4950  RhsT = Self.Context.getRValueReferenceType(RhsT);
4951  OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
4953  OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context),
4955 
4956  // Attempt the assignment in an unevaluated context within a SFINAE
4957  // trap at translation unit scope.
4960  Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4961  Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
4962  ExprResult Result = Self.BuildBinOp(/*S=*/nullptr, KeyLoc, BO_Assign, &Lhs,
4963  &Rhs);
4964  if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4965  return false;
4966 
4967  if (BTT == BTT_IsAssignable)
4968  return true;
4969 
4970  if (BTT == BTT_IsNothrowAssignable)
4971  return Self.canThrow(Result.get()) == CT_Cannot;
4972 
4973  if (BTT == BTT_IsTriviallyAssignable) {
4974  // Under Objective-C ARC and Weak, if the destination has non-trivial
4975  // Objective-C lifetime, this is a non-trivial assignment.
4977  return false;
4978 
4979  return !Result.get()->hasNonTrivialCall(Self.Context);
4980  }
4981 
4982  llvm_unreachable("unhandled type trait");
4983  return false;
4984  }
4985  default: llvm_unreachable("not a BTT");
4986  }
4987  llvm_unreachable("Unknown type trait or not implemented");
4988 }
4989 
4991  SourceLocation KWLoc,
4992  ParsedType Ty,
4993  Expr* DimExpr,
4994  SourceLocation RParen) {
4995  TypeSourceInfo *TSInfo;
4996  QualType T = GetTypeFromParser(Ty, &TSInfo);
4997  if (!TSInfo)
4998  TSInfo = Context.getTrivialTypeSourceInfo(T);
4999 
5000  return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
5001 }
5002 
5003 static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
5004  QualType T, Expr *DimExpr,
5005  SourceLocation KeyLoc) {
5006  assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
5007 
5008  switch(ATT) {
5009  case ATT_ArrayRank:
5010  if (T->isArrayType()) {
5011  unsigned Dim = 0;
5012  while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
5013  ++Dim;
5014  T = AT->getElementType();
5015  }
5016  return Dim;
5017  }
5018  return 0;
5019 
5020  case ATT_ArrayExtent: {
5021  llvm::APSInt Value;
5022  uint64_t Dim;
5023  if (Self.VerifyIntegerConstantExpression(DimExpr, &Value,
5024  diag::err_dimension_expr_not_constant_integer,
5025  false).isInvalid())
5026  return 0;
5027  if (Value.isSigned() && Value.isNegative()) {
5028  Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5029  << DimExpr->getSourceRange();
5030  return 0;
5031  }
5032  Dim = Value.getLimitedValue();
5033 
5034  if (T->isArrayType()) {
5035  unsigned D = 0;
5036  bool Matched = false;
5037  while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
5038  if (Dim == D) {
5039  Matched = true;
5040  break;
5041  }
5042  ++D;
5043  T = AT->getElementType();
5044  }
5045 
5046  if (Matched && T->isArrayType()) {
5047  if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
5048  return CAT->getSize().getLimitedValue();
5049  }
5050  }
5051  return 0;
5052  }
5053  }
5054  llvm_unreachable("Unknown type trait or not implemented");
5055 }
5056 
5058  SourceLocation KWLoc,
5059  TypeSourceInfo *TSInfo,
5060  Expr* DimExpr,
5061  SourceLocation RParen) {
5062  QualType T = TSInfo->getType();
5063 
5064  // FIXME: This should likely be tracked as an APInt to remove any host
5065  // assumptions about the width of size_t on the target.
5066  uint64_t Value = 0;
5067  if (!T->isDependentType())
5068  Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
5069 
5070  // While the specification for these traits from the Embarcadero C++
5071  // compiler's documentation says the return type is 'unsigned int', Clang
5072  // returns 'size_t'. On Windows, the primary platform for the Embarcadero
5073  // compiler, there is no difference. On several other platforms this is an
5074  // important distinction.
5075  return new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, DimExpr,
5076  RParen, Context.getSizeType());
5077 }
5078 
5080  SourceLocation KWLoc,
5081  Expr *Queried,
5082  SourceLocation RParen) {
5083  // If error parsing the expression, ignore.
5084  if (!Queried)
5085  return ExprError();
5086 
5087  ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
5088 
5089  return Result;
5090 }
5091 
5093  switch (ET) {
5094  case ET_IsLValueExpr: return E->isLValue();
5095  case ET_IsRValueExpr: return E->isRValue();
5096  }
5097  llvm_unreachable("Expression trait not covered by switch");
5098 }
5099 
5101  SourceLocation KWLoc,
5102  Expr *Queried,
5103  SourceLocation RParen) {
5104  if (Queried->isTypeDependent()) {
5105  // Delay type-checking for type-dependent expressions.
5106  } else if (Queried->getType()->isPlaceholderType()) {
5107  ExprResult PE = CheckPlaceholderExpr(Queried);
5108  if (PE.isInvalid()) return ExprError();
5109  return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen);
5110  }
5111 
5112  bool Value = EvaluateExpressionTrait(ET, Queried);
5113 
5114  return new (Context)
5115  ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
5116 }
5117 
5119  ExprValueKind &VK,
5120  SourceLocation Loc,
5121  bool isIndirect) {
5122  assert(!LHS.get()->getType()->isPlaceholderType() &&
5123  !RHS.get()->getType()->isPlaceholderType() &&
5124  "placeholders should have been weeded out by now");
5125 
5126  // The LHS undergoes lvalue conversions if this is ->*, and undergoes the
5127  // temporary materialization conversion otherwise.
5128  if (isIndirect)
5129  LHS = DefaultLvalueConversion(LHS.get());
5130  else if (LHS.get()->isRValue())
5132  if (LHS.isInvalid())
5133  return QualType();
5134 
5135  // The RHS always undergoes lvalue conversions.
5136  RHS = DefaultLvalueConversion(RHS.get());
5137  if (RHS.isInvalid()) return QualType();
5138 
5139  const char *OpSpelling = isIndirect ? "->*" : ".*";
5140  // C++ 5.5p2
5141  // The binary operator .* [p3: ->*] binds its second operand, which shall
5142  // be of type "pointer to member of T" (where T is a completely-defined
5143  // class type) [...]
5144  QualType RHSType = RHS.get()->getType();
5145  const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>();
5146  if (!MemPtr) {
5147  Diag(Loc, diag::err_bad_memptr_rhs)
5148  << OpSpelling << RHSType << RHS.get()->getSourceRange();
5149  return QualType();
5150  }
5151 
5152  QualType Class(MemPtr->getClass(), 0);
5153 
5154  // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
5155  // member pointer points must be completely-defined. However, there is no
5156  // reason for this semantic distinction, and the rule is not enforced by
5157  // other compilers. Therefore, we do not check this property, as it is
5158  // likely to be considered a defect.
5159 
5160  // C++ 5.5p2
5161  // [...] to its first operand, which shall be of class T or of a class of
5162  // which T is an unambiguous and accessible base class. [p3: a pointer to
5163  // such a class]
5164  QualType LHSType = LHS.get()->getType();
5165  if (isIndirect) {
5166  if (const PointerType *Ptr = LHSType->getAs<PointerType>())
5167  LHSType = Ptr->getPointeeType();
5168  else {
5169  Diag(Loc, diag::err_bad_memptr_lhs)
5170  << OpSpelling << 1 << LHSType
5172  return QualType();
5173  }
5174  }
5175 
5176  if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
5177  // If we want to check the hierarchy, we need a complete type.
5178  if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
5179  OpSpelling, (int)isIndirect)) {
5180  return QualType();
5181  }
5182 
5183  if (!IsDerivedFrom(Loc, LHSType, Class)) {
5184  Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5185  << (int)isIndirect << LHS.get()->getType();
5186  return QualType();
5187  }
5188 
5189  CXXCastPath BasePath;
5190  if (CheckDerivedToBaseConversion(LHSType, Class, Loc,
5191  SourceRange(LHS.get()->getLocStart(),
5192  RHS.get()->getLocEnd()),
5193  &BasePath))
5194  return QualType();
5195 
5196  // Cast LHS to type of use.
5197  QualType UseType = Context.getQualifiedType(Class, LHSType.getQualifiers());
5198  if (isIndirect)
5199  UseType = Context.getPointerType(UseType);
5200  ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
5201  LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK,
5202  &BasePath);
5203  }
5204 
5205  if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) {
5206  // Diagnose use of pointer-to-member type which when used as
5207  // the functional cast in a pointer-to-member expression.
5208  Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5209  return QualType();
5210  }
5211 
5212  // C++ 5.5p2
5213  // The result is an object or a function of the type specified by the
5214  // second operand.
5215  // The cv qualifiers are the union of those in the pointer and the left side,
5216  // in accordance with 5.5p5 and 5.2.5.
5217  QualType Result = MemPtr->getPointeeType();
5218  Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
5219 
5220  // C++0x [expr.mptr.oper]p6:
5221  // In a .* expression whose object expression is an rvalue, the program is
5222  // ill-formed if the second operand is a pointer to member function with
5223  // ref-qualifier &. In a ->* expression or in a .* expression whose object
5224  // expression is an lvalue, the program is ill-formed if the second operand
5225  // is a pointer to member function with ref-qualifier &&.
5226  if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
5227  switch (Proto->getRefQualifier()) {
5228  case RQ_None:
5229  // Do nothing
5230  break;
5231 
5232  case RQ_LValue:
5233  if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {
5234  // C++2a allows functions with ref-qualifier & if they are also 'const'.
5235  if (Proto->isConst())
5236  Diag(Loc, getLangOpts().CPlusPlus2a
5237  ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5238  : diag::ext_pointer_to_const_ref_member_on_rvalue);
5239  else
5240  Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5241  << RHSType << 1 << LHS.get()->getSourceRange();
5242  }
5243  break;
5244 
5245  case RQ_RValue:
5246  if (isIndirect || !LHS.get()->Classify(Context).isRValue())
5247  Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5248  << RHSType << 0 << LHS.get()->getSourceRange();
5249  break;
5250  }
5251  }
5252 
5253  // C++ [expr.mptr.oper]p6:
5254  // The result of a .* expression whose second operand is a pointer
5255  // to a data member is of the same value category as its
5256  // first operand. The result of a .* expression whose second
5257  // operand is a pointer to a member function is a prvalue. The
5258  // result of an ->* expression is an lvalue if its second operand
5259  // is a pointer to data member and a prvalue otherwise.
5260  if (Result->isFunctionType()) {
5261  VK = VK_RValue;
5262  return Context.BoundMemberTy;
5263  } else if (isIndirect) {
5264  VK = VK_LValue;
5265  } else {
5266  VK = LHS.get()->getValueKind();
5267  }
5268 
5269  return Result;
5270 }
5271 
5272 /// \brief Try to convert a type to another according to C++11 5.16p3.
5273 ///
5274 /// This is part of the parameter validation for the ? operator. If either
5275 /// value operand is a class type, the two operands are attempted to be
5276 /// converted to each other. This function does the conversion in one direction.
5277 /// It returns true if the program is ill-formed and has already been diagnosed
5278 /// as such.
5279 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
5280  SourceLocation QuestionLoc,
5281  bool &HaveConversion,
5282  QualType &ToType) {
5283  HaveConversion = false;
5284  ToType = To->getType();
5285 
5287  SourceLocation());
5288  // C++11 5.16p3
5289  // The process for determining whether an operand expression E1 of type T1
5290  // can be converted to match an operand expression E2 of type T2 is defined
5291  // as follows:
5292  // -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
5293  // implicitly converted to type "lvalue reference to T2", subject to the
5294  // constraint that in the conversion the reference must bind directly to
5295  // an lvalue.
5296  // -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
5297  // implicitly conveted to the type "rvalue reference to R2", subject to
5298  // the constraint that the reference must bind directly.
5299  if (To->isLValue() || To->isXValue()) {
5300  QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)
5301  : Self.Context.getRValueReferenceType(ToType);
5302 
5304 
5305  InitializationSequence InitSeq(Self, Entity, Kind, From);
5306  if (InitSeq.isDirectReferenceBinding()) {
5307  ToType = T;
5308  HaveConversion = true;
5309  return false;
5310  }
5311 
5312  if (InitSeq.isAmbiguous())
5313  return InitSeq.Diagnose(Self, Entity, Kind, From);
5314  }
5315 
5316  // -- If E2 is an rvalue, or if the conversion above cannot be done:
5317  // -- if E1 and E2 have class type, and the underlying class types are
5318  // the same or one is a base class of the other:
5319  QualType FTy = From->getType();
5320  QualType TTy = To->getType();
5321  const RecordType *FRec = FTy->getAs<RecordType>();
5322  const RecordType *TRec = TTy->getAs<RecordType>();
5323  bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5324  Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
5325  if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5326  Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
5327  // E1 can be converted to match E2 if the class of T2 is the
5328  // same type as, or a base class of, the class of T1, and
5329  // [cv2 > cv1].
5330  if (FRec == TRec || FDerivedFromT) {
5331  if (TTy.isAtLeastAsQualifiedAs(FTy)) {
5333  InitializationSequence InitSeq(Self, Entity, Kind, From);
5334  if (InitSeq) {
5335  HaveConversion = true;
5336  return false;
5337  }
5338 
5339  if (InitSeq.isAmbiguous())
5340  return InitSeq.Diagnose(Self, Entity, Kind, From);
5341  }
5342  }
5343 
5344  return false;
5345  }
5346 
5347  // -- Otherwise: E1 can be converted to match E2 if E1 can be
5348  // implicitly converted to the type that expression E2 would have
5349  // if E2 were converted to an rvalue (or the type it has, if E2 is
5350  // an rvalue).
5351  //
5352  // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
5353  // to the array-to-pointer or function-to-pointer conversions.
5354  TTy = TTy.getNonLValueExprType(Self.Context);
5355 
5357  InitializationSequence InitSeq(Self, Entity, Kind, From);
5358  HaveConversion = !InitSeq.Failed();
5359  ToType = TTy;
5360  if (InitSeq.isAmbiguous())
5361  return InitSeq.Diagnose(Self, Entity, Kind, From);
5362 
5363  return false;
5364 }
5365 
5366 /// \brief Try to find a common type for two according to C++0x 5.16p5.
5367 ///
5368 /// This is part of the parameter validation for the ? operator. If either
5369 /// value operand is a class type, overload resolution is used to find a
5370 /// conversion to a common type.
5371 static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
5372  SourceLocation QuestionLoc) {
5373  Expr *Args[2] = { LHS.get(), RHS.get() };
5374  OverloadCandidateSet CandidateSet(QuestionLoc,
5376  Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
5377  CandidateSet);
5378 
5380  switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
5381  case OR_Success: {
5382  // We found a match. Perform the conversions on the arguments and move on.
5383  ExprResult LHSRes = Self.PerformImplicitConversion(
5384  LHS.get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5386  if (LHSRes.isInvalid())
5387  break;
5388  LHS = LHSRes;
5389 
5390  ExprResult RHSRes = Self.PerformImplicitConversion(
5391  RHS.get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5393  if (RHSRes.isInvalid())
5394  break;
5395  RHS = RHSRes;
5396  if (Best->Function)
5397  Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
5398  return false;
5399  }
5400 
5401  case OR_No_Viable_Function:
5402 
5403  // Emit a better diagnostic if one of the expressions is a null pointer
5404  // constant and the other is a pointer type. In this case, the user most
5405  // likely forgot to take the address of the other expression.
5406  if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
5407  return true;
5408 
5409  Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5410  << LHS.get()->getType() << RHS.get()->getType()
5411  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5412  return true;
5413 
5414  case OR_Ambiguous:
5415  Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5416  << LHS.get()->getType() << RHS.get()->getType()
5417  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5418  // FIXME: Print the possible common types by printing the return types of
5419  // the viable candidates.
5420  break;
5421 
5422  case OR_Deleted:
5423  llvm_unreachable("Conditional operator has only built-in overloads");
5424  }
5425  return true;
5426 }
5427 
5428 /// \brief Perform an "extended" implicit conversion as returned by
5429 /// TryClassUnification.
5433  SourceLocation());
5434  Expr *Arg = E.get();
5435  InitializationSequence InitSeq(Self, Entity, Kind, Arg);
5436  ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg);
5437  if (Result.isInvalid())
5438  return true;
5439 
5440  E = Result;
5441  return false;
5442 }
5443 
5444 /// \brief Check the operands of ?: under C++ semantics.
5445 ///
5446 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
5447 /// extension. In this case, LHS == Cond. (But they're not aliases.)
5449  ExprResult &RHS, ExprValueKind &VK,
5450  ExprObjectKind &OK,
5451  SourceLocation QuestionLoc) {
5452  // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
5453  // interface pointers.
5454 
5455  // C++11 [expr.cond]p1
5456  // The first expression is contextually converted to bool.
5457  //
5458  // FIXME; GCC's vector extension permits the use of a?b:c where the type of
5459  // a is that of a integer vector with the same number of elements and
5460  // size as the vectors of b and c. If one of either b or c is a scalar
5461  // it is implicitly converted to match the type of the vector.
5462  // Otherwise the expression is ill-formed. If both b and c are scalars,
5463  // then b and c are checked and converted to the type of a if possible.
5464  // Unlike the OpenCL ?: operator, the expression is evaluated as
5465  // (a[0] != 0 ? b[0] : c[0], .. , a[n] != 0 ? b[n] : c[n]).
5466  if (!Cond.get()->isTypeDependent()) {
5467  ExprResult CondRes = CheckCXXBooleanCondition(Cond.get());
5468  if (CondRes.isInvalid())
5469  return QualType();
5470  Cond = CondRes;
5471  }
5472 
5473  // Assume r-value.
5474  VK = VK_RValue;
5475  OK = OK_Ordinary;
5476 
5477  // Either of the arguments dependent?
5478  if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
5479  return Context.DependentTy;
5480 
5481  // C++11 [expr.cond]p2
5482  // If either the second or the third operand has type (cv) void, ...
5483  QualType LTy = LHS.get()->getType();
5484  QualType RTy = RHS.get()->getType();
5485  bool LVoid = LTy->isVoidType();
5486  bool RVoid = RTy->isVoidType();
5487  if (LVoid || RVoid) {
5488  // ... one of the following shall hold:
5489  // -- The second or the third operand (but not both) is a (possibly
5490  // parenthesized) throw-expression; the result is of the type
5491  // and value category of the other.
5492  bool LThrow = isa<CXXThrowExpr>(LHS.get()->IgnoreParenImpCasts());
5493  bool RThrow = isa<CXXThrowExpr>(RHS.get()->IgnoreParenImpCasts());
5494  if (LThrow != RThrow) {
5495  Expr *NonThrow = LThrow ? RHS.get() : LHS.get();
5496  VK = NonThrow->getValueKind();
5497  // DR (no number yet): the result is a bit-field if the
5498  // non-throw-expression operand is a bit-field.
5499  OK = NonThrow->getObjectKind();
5500  return NonThrow->getType();
5501  }
5502 
5503  // -- Both the second and third operands have type void; the result is of
5504  // type void and is a prvalue.
5505  if (LVoid && RVoid)
5506  return Context.VoidTy;
5507 
5508  // Neither holds, error.
5509  Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5510  << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5511  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5512  return QualType();
5513  }
5514 
5515  // Neither is void.
5516 
5517  // C++11 [expr.cond]p3
5518  // Otherwise, if the second and third operand have different types, and
5519  // either has (cv) class type [...] an attempt is made to convert each of
5520  // those operands to the type of the other.
5521  if (!Context.hasSameType(LTy, RTy) &&
5522  (LTy->isRecordType() || RTy->isRecordType())) {
5523  // These return true if a single direction is already ambiguous.
5524  QualType L2RType, R2LType;
5525  bool HaveL2R, HaveR2L;
5526  if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
5527  return QualType();
5528  if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
5529  return QualType();
5530 
5531  // If both can be converted, [...] the program is ill-formed.
5532  if (HaveL2R && HaveR2L) {
5533  Diag(QuestionLoc, diag::err_conditional_ambiguous)
5534  << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5535  return QualType();
5536  }
5537 
5538  // If exactly one conversion is possible, that conversion is applied to
5539  // the chosen operand and the converted operands are used in place of the
5540  // original operands for the remainder of this section.
5541  if (HaveL2R) {
5542  if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
5543  return QualType();
5544  LTy = LHS.get()->getType();
5545  } else if (HaveR2L) {
5546  if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
5547  return QualType();
5548  RTy = RHS.get()->getType();
5549  }
5550  }
5551 
5552  // C++11 [expr.cond]p3
5553  // if both are glvalues of the same value category and the same type except
5554  // for cv-qualification, an attempt is made to convert each of those
5555  // operands to the type of the other.
5556  // FIXME:
5557  // Resolving a defect in P0012R1: we extend this to cover all cases where
5558  // one of the operands is reference-compatible with the other, in order
5559  // to support conditionals between functions differing in noexcept.
5560  ExprValueKind LVK = LHS.get()->getValueKind();
5561  ExprValueKind RVK = RHS.get()->getValueKind();
5562  if (!Context.hasSameType(LTy, RTy) &&
5563  LVK == RVK && LVK != VK_RValue) {
5564  // DerivedToBase was already handled by the class-specific case above.
5565  // FIXME: Should we allow ObjC conversions here?
5566  bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5568  QuestionLoc, LTy, RTy, DerivedToBase,
5569  ObjCConversion, ObjCLifetimeConversion) == Ref_Compatible &&
5570  !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5571  // [...] subject to the constraint that the reference must bind
5572  // directly [...]
5573  !RHS.get()->refersToBitField() &&
5574  !RHS.get()->refersToVectorElement()) {
5575  RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK);
5576  RTy = RHS.get()->getType();
5577  } else if (CompareReferenceRelationship(
5578  QuestionLoc, RTy, LTy, DerivedToBase,
5579  ObjCConversion, ObjCLifetimeConversion) == Ref_Compatible &&
5580  !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5581  !LHS.get()->refersToBitField() &&
5582  !LHS.get()->refersToVectorElement()) {
5583  LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK);
5584  LTy = LHS.get()->getType();
5585  }
5586  }
5587 
5588  // C++11 [expr.cond]p4
5589  // If the second and third operands are glvalues of the same value
5590  // category and have the same type, the result is of that type and
5591  // value category and it is a bit-field if the second or the third
5592  // operand is a bit-field, or if both are bit-fields.
5593  // We only extend this to bitfields, not to the crazy other kinds of
5594  // l-values.
5595  bool Same = Context.hasSameType(LTy, RTy);
5596  if (Same && LVK == RVK && LVK != VK_RValue &&
5597  LHS.get()->isOrdinaryOrBitFieldObject() &&
5598  RHS.get()->isOrdinaryOrBitFieldObject()) {
5599  VK = LHS.get()->getValueKind();
5600  if (LHS.get()->getObjectKind() == OK_BitField ||
5601  RHS.get()->getObjectKind() == OK_BitField)
5602  OK = OK_BitField;
5603 
5604  // If we have function pointer types, unify them anyway to unify their
5605  // exception specifications, if any.
5606  if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5607  Qualifiers Qs = LTy.getQualifiers();
5608  LTy = FindCompositePointerType(QuestionLoc, LHS, RHS,
5609  /*ConvertArgs*/false);
5610  LTy = Context.getQualifiedType(LTy, Qs);
5611 
5612  assert(!LTy.isNull() && "failed to find composite pointer type for "
5613  "canonically equivalent function ptr types");
5614  assert(Context.hasSameType(LTy, RTy) && "bad composite pointer type");
5615  }
5616 
5617  return LTy;
5618  }
5619 
5620  // C++11 [expr.cond]p5
5621  // Otherwise, the result is a prvalue. If the second and third operands
5622  // do not have the same type, and either has (cv) class type, ...
5623  if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
5624  // ... overload resolution is used to determine the conversions (if any)
5625  // to be applied to the operands. If the overload resolution fails, the
5626  // program is ill-formed.
5627  if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
5628  return QualType();
5629  }
5630 
5631  // C++11 [expr.cond]p6
5632  // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard
5633  // conversions are performed on the second and third operands.
5635  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
5636  if (LHS.isInvalid() || RHS.isInvalid())
5637  return QualType();
5638  LTy = LHS.get()->getType();
5639  RTy = RHS.get()->getType();
5640 
5641  // After those conversions, one of the following shall hold:
5642  // -- The second and third operands have the same type; the result
5643  // is of that type. If the operands have class type, the result
5644  // is a prvalue temporary of the result type, which is
5645  // copy-initialized from either the second operand or the third
5646  // operand depending on the value of the first operand.
5647  if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
5648  if (LTy->isRecordType()) {
5649  // The operands have class type. Make a temporary copy.
5651 
5652  ExprResult LHSCopy = PerformCopyInitialization(Entity,
5653  SourceLocation(),
5654  LHS);
5655  if (LHSCopy.isInvalid())
5656  return QualType();
5657 
5658  ExprResult RHSCopy = PerformCopyInitialization(Entity,
5659  SourceLocation(),
5660  RHS);
5661  if (RHSCopy.isInvalid())
5662  return QualType();
5663 
5664  LHS = LHSCopy;
5665  RHS = RHSCopy;
5666  }
5667 
5668  // If we have function pointer types, unify them anyway to unify their
5669  // exception specifications, if any.
5670  if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5671  LTy = FindCompositePointerType(QuestionLoc, LHS, RHS);
5672  assert(!LTy.isNull() && "failed to find composite pointer type for "
5673  "canonically equivalent function ptr types");
5674  }
5675 
5676  return LTy;
5677  }
5678 
5679  // Extension: conditional operator involving vector types.
5680  if (LTy->isVectorType() || RTy->isVectorType())
5681  return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
5682  /*AllowBothBool*/true,
5683  /*AllowBoolConversions*/false);
5684 
5685  // -- The second and third operands have arithmetic or enumeration type;
5686  // the usual arithmetic conversions are performed to bring them to a
5687  // common type, and the result is of that type.
5688  if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
5689  QualType ResTy = UsualArithmeticConversions(LHS, RHS);
5690  if (LHS.isInvalid() || RHS.isInvalid())
5691  return QualType();
5692  if (ResTy.isNull()) {
5693  Diag(QuestionLoc,
5694  diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5695  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5696  return QualType();
5697  }
5698 
5699  LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
5700  RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
5701 
5702  return ResTy;
5703  }
5704 
5705  // -- The second and third operands have pointer type, or one has pointer
5706  // type and the other is a null pointer constant, or both are null
5707  // pointer constants, at least one of which is non-integral; pointer
5708  // conversions and qualification conversions are performed to bring them
5709  // to their composite pointer type. The result is of the composite
5710  // pointer type.
5711  // -- The second and third operands have pointer to member type, or one has
5712  // pointer to member type and the other is a null pointer constant;
5713  // pointer to member conversions and qualification conversions are
5714  // performed to bring them to a common type, whose cv-qualification
5715  // shall match the cv-qualification of either the second or the third
5716  // operand. The result is of the common type.
5717  QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS);
5718  if (!Composite.isNull())
5719  return Composite;
5720 
5721  // Similarly, attempt to find composite type of two objective-c pointers.
5722  Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
5723  if (!Composite.isNull())
5724  return Composite;
5725 
5726  // Check if we are using a null with a non-pointer type.
5727  if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
5728  return QualType();
5729 
5730  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5731  << LHS.get()->getType() << RHS.get()->getType()
5732  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5733  return QualType();
5734 }
5735 
5739  SmallVectorImpl<QualType> &ExceptionTypeStorage) {
5740  ExceptionSpecificationType EST1 = ESI1.Type;
5741  ExceptionSpecificationType EST2 = ESI2.Type;
5742 
5743  // If either of them can throw anything, that is the result.
5744  if (EST1 == EST_None) return ESI1;
5745  if (EST2 == EST_None) return ESI2;
5746  if (EST1 == EST_MSAny) return ESI1;
5747  if (EST2 == EST_MSAny) return ESI2;
5748 
5749  // If either of them is non-throwing, the result is the other.
5750  if (EST1 == EST_DynamicNone) return ESI2;
5751  if (EST2 == EST_DynamicNone) return ESI1;
5752  if (EST1 == EST_BasicNoexcept) return ESI2;
5753  if (EST2 == EST_BasicNoexcept) return ESI1;
5754 
5755  // If either of them is a non-value-dependent computed noexcept, that
5756  // determines the result.
5757  if (EST2 == EST_ComputedNoexcept && ESI2.NoexceptExpr &&
5758  !ESI2.NoexceptExpr->isValueDependent())
5759  return !ESI2.NoexceptExpr->EvaluateKnownConstInt(S.Context) ? ESI2 : ESI1;
5760  if (EST1 == EST_ComputedNoexcept && ESI1.NoexceptExpr &&
5761  !ESI1.NoexceptExpr->isValueDependent())
5762  return !ESI1.NoexceptExpr->EvaluateKnownConstInt(S.Context) ? ESI1 : ESI2;
5763  // If we're left with value-dependent computed noexcept expressions, we're
5764  // stuck. Before C++17, we can just drop the exception specification entirely,
5765  // since it's not actually part of the canonical type. And this should never
5766  // happen in C++17, because it would mean we were computing the composite
5767  // pointer type of dependent types, which should never happen.
5768  if (EST1 == EST_ComputedNoexcept || EST2 == EST_ComputedNoexcept) {
5769  assert(!S.getLangOpts().CPlusPlus17 &&
5770  "computing composite pointer type of dependent types");
5772  }
5773 
5774  // Switch over the possibilities so that people adding new values know to
5775  // update this function.
5776  switch (EST1) {
5777  case EST_None:
5778  case EST_DynamicNone:
5779  case EST_MSAny:
5780  case EST_BasicNoexcept:
5781  case EST_ComputedNoexcept:
5782  llvm_unreachable("handled above");
5783 
5784  case EST_Dynamic: {
5785  // This is the fun case: both exception specifications are dynamic. Form
5786  // the union of the two lists.
5787  assert(EST2 == EST_Dynamic && "other cases should already be handled");
5788  llvm::SmallPtrSet<QualType, 8> Found;
5789  for (auto &Exceptions : {ESI1.Exceptions, ESI2.Exceptions})
5790  for (QualType E : Exceptions)
5791  if (Found.insert(S.Context.getCanonicalType(E)).second)
5792  ExceptionTypeStorage.push_back(E);
5793 
5795  Result.Exceptions = ExceptionTypeStorage;
5796  return Result;
5797  }
5798 
5799  case EST_Unevaluated:
5800  case EST_Uninstantiated:
5801  case EST_Unparsed:
5802  llvm_unreachable("shouldn't see unresolved exception specifications here");
5803  }
5804 
5805  llvm_unreachable("invalid ExceptionSpecificationType");
5806 }
5807 
5808 /// \brief Find a merged pointer type and convert the two expressions to it.
5809 ///
5810 /// This finds the composite pointer type (or member pointer type) for @p E1
5811 /// and @p E2 according to C++1z 5p14. It converts both expressions to this
5812 /// type and returns it.
5813 /// It does not emit diagnostics.
5814 ///
5815 /// \param Loc The location of the operator requiring these two expressions to
5816 /// be converted to the composite pointer type.
5817 ///
5818 /// \param ConvertArgs If \c false, do not convert E1 and E2 to the target type.
5820  Expr *&E1, Expr *&E2,
5821  bool ConvertArgs) {
5822  assert(getLangOpts().CPlusPlus && "This function assumes C++");
5823 
5824  // C++1z [expr]p14:
5825  // The composite pointer type of two operands p1 and p2 having types T1
5826  // and T2
5827  QualType T1 = E1->getType(), T2 = E2->getType();
5828 
5829  // where at least one is a pointer or pointer to member type or
5830  // std::nullptr_t is:
5831  bool T1IsPointerLike = T1->isAnyPointerType() || T1->isMemberPointerType() ||
5832  T1->isNullPtrType();
5833  bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
5834  T2->isNullPtrType();
5835  if (!T1IsPointerLike && !T2IsPointerLike)
5836  return QualType();
5837 
5838  // - if both p1 and p2 are null pointer constants, std::nullptr_t;
5839  // This can't actually happen, following the standard, but we also use this
5840  // to implement the end of [expr.conv], which hits this case.
5841  //
5842  // - if either p1 or p2 is a null pointer constant, T2 or T1, respectively;
5843  if (T1IsPointerLike &&
5845  if (ConvertArgs)
5846  E2 = ImpCastExprToType(E2, T1, T1->isMemberPointerType()
5847  ? CK_NullToMemberPointer
5848  : CK_NullToPointer).get();
5849  return T1;
5850  }
5851  if (T2IsPointerLike &&
5853  if (ConvertArgs)
5854  E1 = ImpCastExprToType(E1, T2, T2->isMemberPointerType()
5855  ? CK_NullToMemberPointer
5856  : CK_NullToPointer).get();
5857  return T2;
5858  }
5859 
5860  // Now both have to be pointers or member pointers.
5861  if (!T1IsPointerLike || !T2IsPointerLike)
5862  return QualType();
5863  assert(!T1->isNullPtrType() && !T2->isNullPtrType() &&
5864  "nullptr_t should be a null pointer constant");
5865 
5866  // - if T1 or T2 is "pointer to cv1 void" and the other type is
5867  // "pointer to cv2 T", "pointer to cv12 void", where cv12 is
5868  // the union of cv1 and cv2;
5869  // - if T1 or T2 is "pointer to noexcept function" and the other type is
5870  // "pointer to function", where the function types are otherwise the same,
5871  // "pointer to function";
5872  // FIXME: This rule is defective: it should also permit removing noexcept
5873  // from a pointer to member function. As a Clang extension, we also
5874  // permit removing 'noreturn', so we generalize this rule to;
5875  // - [Clang] If T1 and T2 are both of type "pointer to function" or
5876  // "pointer to member function" and the pointee types can be unified
5877  // by a function pointer conversion, that conversion is applied
5878  // before checking the following rules.
5879  // - if T1 is "pointer to cv1 C1" and T2 is "pointer to cv2 C2", where C1
5880  // is reference-related to C2 or C2 is reference-related to C1 (8.6.3),
5881  // the cv-combined type of T1 and T2 or the cv-combined type of T2 and T1,
5882  // respectively;
5883  // - if T1 is "pointer to member of C1 of type cv1 U1" and T2 is "pointer
5884  // to member of C2 of type cv2 U2" where C1 is reference-related to C2 or
5885  // C2 is reference-related to C1 (8.6.3), the cv-combined type of T2 and
5886  // T1 or the cv-combined type of T1 and T2, respectively;
5887  // - if T1 and T2 are similar types (4.5), the cv-combined type of T1 and
5888  // T2;
5889  //
5890  // If looked at in the right way, these bullets all do the same thing.
5891  // What we do here is, we build the two possible cv-combined types, and try
5892  // the conversions in both directions. If only one works, or if the two
5893  // composite types are the same, we have succeeded.
5894  // FIXME: extended qualifiers?
5895  //
5896  // Note that this will fail to find a composite pointer type for "pointer
5897  // to void" and "pointer to function". We can't actually perform the final
5898  // conversion in this case, even though a composite pointer type formally
5899  // exists.
5900  SmallVector<unsigned, 4> QualifierUnion;
5902  QualType Composite1 = T1;
5903  QualType Composite2 = T2;
5904  unsigned NeedConstBefore = 0;
5905  while (true) {
5906  const PointerType *Ptr1, *Ptr2;
5907  if ((Ptr1 = Composite1->getAs<PointerType>()) &&
5908  (Ptr2 = Composite2->getAs<PointerType>())) {
5909  Composite1 = Ptr1->getPointeeType();
5910  Composite2 = Ptr2->getPointeeType();
5911 
5912  // If we're allowed to create a non-standard composite type, keep track
5913  // of where we need to fill in additional 'const' qualifiers.
5914  if (Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5915  NeedConstBefore = QualifierUnion.size();
5916 
5917  QualifierUnion.push_back(
5918  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
5919  MemberOfClass.push_back(std::make_pair(nullptr, nullptr));
5920  continue;
5921  }
5922 
5923  const MemberPointerType *MemPtr1, *MemPtr2;
5924  if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
5925  (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
5926  Composite1 = MemPtr1->getPointeeType();
5927  Composite2 = MemPtr2->getPointeeType();
5928 
5929  // If we're allowed to create a non-standard composite type, keep track
5930  // of where we need to fill in additional 'const' qualifiers.
5931  if (Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5932  NeedConstBefore = QualifierUnion.size();
5933 
5934  QualifierUnion.push_back(
5935  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
5936  MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
5937  MemPtr2->getClass()));
5938  continue;
5939  }
5940 
5941  // FIXME: block pointer types?
5942 
5943  // Cannot unwrap any more types.
5944  break;
5945  }
5946 
5947  // Apply the function pointer conversion to unify the types. We've already
5948  // unwrapped down to the function types, and we want to merge rather than
5949  // just convert, so do this ourselves rather than calling
5950  // IsFunctionConversion.
5951  //
5952  // FIXME: In order to match the standard wording as closely as possible, we
5953  // currently only do this under a single level of pointers. Ideally, we would
5954  // allow this in general, and set NeedConstBefore to the relevant depth on
5955  // the side(s) where we changed anything.
5956  if (QualifierUnion.size() == 1) {
5957  if (auto *FPT1 = Composite1->getAs<FunctionProtoType>()) {
5958  if (auto *FPT2 = Composite2->getAs<FunctionProtoType>()) {
5959  FunctionProtoType::ExtProtoInfo EPI1 = FPT1->getExtProtoInfo();
5960  FunctionProtoType::ExtProtoInfo EPI2 = FPT2->getExtProtoInfo();
5961 
5962  // The result is noreturn if both operands are.
5963  bool Noreturn =
5964  EPI1.ExtInfo.getNoReturn() && EPI2.ExtInfo.getNoReturn();
5965  EPI1.ExtInfo = EPI1.ExtInfo.withNoReturn(Noreturn);
5966  EPI2.ExtInfo = EPI2.ExtInfo.withNoReturn(Noreturn);
5967 
5968  // The result is nothrow if both operands are.
5969  SmallVector<QualType, 8> ExceptionTypeStorage;
5970  EPI1.ExceptionSpec = EPI2.ExceptionSpec =
5972  ExceptionTypeStorage);
5973 
5974  Composite1 = Context.getFunctionType(FPT1->getReturnType(),
5975  FPT1->getParamTypes(), EPI1);
5976  Composite2 = Context.getFunctionType(FPT2->getReturnType(),
5977  FPT2->getParamTypes(), EPI2);
5978  }
5979  }
5980  }
5981 
5982  if (NeedConstBefore) {
5983  // Extension: Add 'const' to qualifiers that come before the first qualifier
5984  // mismatch, so that our (non-standard!) composite type meets the
5985  // requirements of C++ [conv.qual]p4 bullet 3.
5986  for (unsigned I = 0; I != NeedConstBefore; ++I)
5987  if ((QualifierUnion[I] & Qualifiers::Const) == 0)
5988  QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
5989  }
5990 
5991  // Rewrap the composites as pointers or member pointers with the union CVRs.
5992  auto MOC = MemberOfClass.rbegin();
5993  for (unsigned CVR : llvm::reverse(QualifierUnion)) {
5994  Qualifiers Quals = Qualifiers::fromCVRMask(CVR);
5995  auto Classes = *MOC++;
5996  if (Classes.first && Classes.second) {
5997  // Rebuild member pointer type
5998  Composite1 = Context.getMemberPointerType(
5999  Context.getQualifiedType(Composite1, Quals), Classes.first);
6000  Composite2 = Context.getMemberPointerType(
6001  Context.getQualifiedType(Composite2, Quals), Classes.second);
6002  } else {
6003  // Rebuild pointer type
6004  Composite1 =
6005  Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
6006  Composite2 =
6007  Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
6008  }
6009  }
6010 
6011  struct Conversion {
6012  Sema &S;
6013  Expr *&E1, *&E2;
6014  QualType Composite;
6015  InitializedEntity Entity;
6017  InitializationSequence E1ToC, E2ToC;
6018  bool Viable;
6019 
6020  Conversion(Sema &S, SourceLocation Loc, Expr *&E1, Expr *&E2,
6021  QualType Composite)
6022  : S(S), E1(E1), E2(E2), Composite(Composite),
6023  Entity(InitializedEntity::InitializeTemporary(Composite)),
6025  E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6026  Viable(E1ToC && E2ToC) {}
6027 
6028  bool perform() {
6029  ExprResult E1Result = E1ToC.Perform(S, Entity, Kind, E1);
6030  if (E1Result.isInvalid())
6031  return true;
6032  E1 = E1Result.getAs<Expr>();
6033 
6034  ExprResult E2Result = E2ToC.Perform(S, Entity, Kind, E2);
6035  if (E2Result.isInvalid())
6036  return true;
6037  E2 = E2Result.getAs<Expr>();
6038 
6039  return false;
6040  }
6041  };
6042 
6043  // Try to convert to each composite pointer type.
6044  Conversion C1(*this, Loc, E1, E2, Composite1);
6045  if (C1.Viable && Context.hasSameType(Composite1, Composite2)) {
6046  if (ConvertArgs && C1.perform())
6047  return QualType();
6048  return C1.Composite;
6049  }
6050  Conversion C2(*this, Loc, E1, E2, Composite2);
6051 
6052  if (C1.Viable == C2.Viable) {
6053  // Either Composite1 and Composite2 are viable and are different, or
6054  // neither is viable.
6055  // FIXME: How both be viable and different?
6056  return QualType();
6057  }
6058 
6059  // Convert to the chosen type.
6060  if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6061  return QualType();
6062 
6063  return C1.Viable ? C1.Composite : C2.Composite;
6064 }
6065 
6067  if (!E)
6068  return ExprError();
6069 
6070  assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
6071 
6072  // If the result is a glvalue, we shouldn't bind it.
6073  if (!E->isRValue())
6074  return E;
6075 
6076  // In ARC, calls that return a retainable type can return retained,
6077  // in which case we have to insert a consuming cast.
6078  if (getLangOpts().ObjCAutoRefCount &&
6079  E->getType()->isObjCRetainableType()) {
6080 
6081  bool ReturnsRetained;
6082 
6083  // For actual calls, we compute this by examining the type of the
6084  // called value.
6085  if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
6086  Expr *Callee = Call->getCallee()->IgnoreParens();
6087  QualType T = Callee->getType();
6088 
6089  if (T == Context.BoundMemberTy) {
6090  // Handle pointer-to-members.
6091  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee))
6092  T = BinOp->getRHS()->getType();
6093  else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6094  T = Mem->getMemberDecl()->getType();
6095  }
6096 
6097  if (const PointerType *Ptr = T->getAs<PointerType>())
6098  T = Ptr->getPointeeType();
6099  else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>())
6100  T = Ptr->getPointeeType();
6101  else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>())
6102  T = MemPtr->getPointeeType();
6103 
6104  const FunctionType *FTy = T->getAs<FunctionType>();
6105  assert(FTy && "call to value not of function type?");
6106  ReturnsRetained = FTy->getExtInfo().getProducesResult();
6107 
6108  // ActOnStmtExpr arranges things so that StmtExprs of retainable
6109  // type always produce a +1 object.
6110  } else if (isa<StmtExpr>(E)) {
6111  ReturnsRetained = true;
6112 
6113  // We hit this case with the lambda conversion-to-block optimization;
6114  // we don't want any extra casts here.
6115  } else if (isa<CastExpr>(E) &&
6116  isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6117  return E;
6118 
6119  // For message sends and property references, we try to find an
6120  // actual method. FIXME: we should infer retention by selector in
6121  // cases where we don't have an actual method.
6122  } else {
6123  ObjCMethodDecl *D = nullptr;
6124  if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) {
6125  D = Send->getMethodDecl();
6126  } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6127  D = BoxedExpr->getBoxingMethod();
6128  } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) {
6129  // Don't do reclaims if we're using the zero-element array
6130  // constant.
6131  if (ArrayLit->getNumElements() == 0 &&
6133  return E;
6134 
6135  D = ArrayLit->getArrayWithObjectsMethod();
6136  } else if (ObjCDictionaryLiteral *DictLit
6137  = dyn_cast<ObjCDictionaryLiteral>(E)) {
6138  // Don't do reclaims if we're using the zero-element dictionary
6139  // constant.
6140  if (DictLit->getNumElements() == 0 &&
6142  return E;
6143 
6144  D = DictLit->getDictWithObjectsMethod();
6145  }
6146 
6147  ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>());
6148 
6149  // Don't do reclaims on performSelector calls; despite their
6150  // return type, the invoked method doesn't necessarily actually
6151  // return an object.
6152  if (!ReturnsRetained &&
6153  D && D->getMethodFamily() == OMF_performSelector)
6154  return E;
6155  }
6156 
6157  // Don't reclaim an object of Class type.
6158  if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
6159  return E;
6160 
6162 
6163  CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6164  : CK_ARCReclaimReturnedObject);
6165  return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
6166  VK_RValue);
6167  }
6168 
6169  if (!getLangOpts().CPlusPlus)
6170  return E;
6171 
6172  // Search for the base element type (cf. ASTContext::getBaseElementType) with
6173  // a fast path for the common case that the type is directly a RecordType.
6174  const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
6175  const RecordType *RT = nullptr;
6176  while (!RT) {
6177  switch (T->getTypeClass()) {
6178  case Type::Record:
6179  RT = cast<RecordType>(T);
6180  break;
6181  case Type::ConstantArray:
6182  case Type::IncompleteArray:
6183  case Type::VariableArray:
6184  case Type::DependentSizedArray:
6185  T = cast<ArrayType>(T)->getElementType().getTypePtr();
6186  break;
6187  default:
6188  return E;
6189  }
6190  }
6191 
6192  // That should be enough to guarantee that this type is complete, if we're
6193  // not processing a decltype expression.
6194  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
6195  if (RD->isInvalidDecl() || RD->isDependentContext())
6196  return E;
6197 
6198  bool IsDecltype = ExprEvalContexts.back().IsDecltype;
6199  CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD);
6200 
6201  if (Destructor) {
6202  MarkFunctionReferenced(E->getExprLoc(), Destructor);
6203  CheckDestructorAccess(E->getExprLoc(), Destructor,
6204  PDiag(diag::err_access_dtor_temp)
6205  << E->getType());
6206  if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
6207  return ExprError();
6208 
6209  // If destructor is trivial, we can avoid the extra copy.
6210  if (Destructor->isTrivial())
6211  return E;
6212 
6213  // We need a cleanup, but we don't need to remember the temporary.
6215  }
6216 
6217  CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor);
6219 
6220  if (IsDecltype)
6221  ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind);
6222 
6223  return Bind;
6224 }
6225 
6226 ExprResult
6228  if (SubExpr.isInvalid())
6229  return ExprError();
6230 
6231  return MaybeCreateExprWithCleanups(SubExpr.get());
6232 }
6233 
6235  assert(SubExpr && "subexpression can't be null!");
6236 
6238 
6239  unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects;
6240  assert(ExprCleanupObjects.size() >= FirstCleanup);
6241  assert(Cleanup.exprNeedsCleanups() ||
6242  ExprCleanupObjects.size() == FirstCleanup);
6243  if (!Cleanup.exprNeedsCleanups())
6244  return SubExpr;
6245 
6246  auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
6247  ExprCleanupObjects.size() - FirstCleanup);
6248 
6249  auto *E = ExprWithCleanups::Create(
6250  Context, SubExpr, Cleanup.cleanupsHaveSideEffects(), Cleanups);
6252 
6253  return E;
6254 }
6255 
6257  assert(SubStmt && "sub-statement can't be null!");
6258 
6260 
6261  if (!Cleanup.exprNeedsCleanups())
6262  return SubStmt;
6263 
6264  // FIXME: In order to attach the temporaries, wrap the statement into
6265  // a StmtExpr; currently this is only used for asm statements.
6266  // This is hacky, either create a new CXXStmtWithTemporaries statement or
6267  // a new AsmStmtWithTemporaries.
6268  CompoundStmt *CompStmt = CompoundStmt::Create(
6269  Context, SubStmt, SourceLocation(), SourceLocation());
6270  Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
6271  SourceLocation());
6272  return MaybeCreateExprWithCleanups(E);
6273 }
6274 
6275 /// Process the expression contained within a decltype. For such expressions,
6276 /// certain semantic checks on temporaries are delayed until this point, and
6277 /// are omitted for the 'topmost' call in the decltype expression. If the
6278 /// topmost call bound a temporary, strip that temporary off the expression.
6280  assert(ExprEvalContexts.back().IsDecltype && "not in a decltype expression");
6281 
6282  // C++11 [expr.call]p11:
6283  // If a function call is a prvalue of object type,
6284  // -- if the function call is either
6285  // -- the operand of a decltype-specifier, or
6286  // -- the right operand of a comma operator that is the operand of a
6287  // decltype-specifier,
6288  // a temporary object is not introduced for the prvalue.
6289 
6290  // Recursively rebuild ParenExprs and comma expressions to strip out the
6291  // outermost CXXBindTemporaryExpr, if any.
6292  if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6293  ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr());
6294  if (SubExpr.isInvalid())
6295  return ExprError();
6296  if (SubExpr.get() == PE->getSubExpr())
6297  return E;
6298  return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
6299  }
6300  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
6301  if (BO->getOpcode() == BO_Comma) {
6302  ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
6303  if (RHS.isInvalid())
6304  return ExprError();
6305  if (RHS.get() == BO->getRHS())
6306  return E;
6307  return new (Context) BinaryOperator(
6308  BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(),
6309  BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6310  }
6311  }
6312 
6313  CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
6314  CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
6315  : nullptr;
6316  if (TopCall)
6317  E = TopCall;
6318  else
6319  TopBind = nullptr;
6320 
6321  // Disable the special decltype handling now.
6322  ExprEvalContexts.back().IsDecltype = false;
6323 
6324  // In MS mode, don't perform any extra checking of call return types within a
6325  // decltype expression.
6326  if (getLangOpts().MSVCCompat)
6327  return E;
6328 
6329  // Perform the semantic checks we delayed until this point.
6330  for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size();
6331  I != N; ++I) {
6332  CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
6333  if (Call == TopCall)
6334  continue;
6335 
6337  Call->getLocStart(),
6338  Call, Call->getDirectCallee()))
6339  return ExprError();
6340  }
6341 
6342  // Now all relevant types are complete, check the destructors are accessible
6343  // and non-deleted, and annotate them on the temporaries.
6344  for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size();
6345  I != N; ++I) {
6346  CXXBindTemporaryExpr *Bind =
6347  ExprEvalContexts.back().DelayedDecltypeBinds[I];
6348  if (Bind == TopBind)
6349  continue;
6350 
6351  CXXTemporary *Temp = Bind->getTemporary();
6352 
6353  CXXRecordDecl *RD =
6355  CXXDestructorDecl *Destructor = LookupDestructor(RD);
6356  Temp->setDestructor(Destructor);
6357 
6358  MarkFunctionReferenced(Bind->getExprLoc(), Destructor);
6359  CheckDestructorAccess(Bind->getExprLoc(), Destructor,
6360  PDiag(diag::err_access_dtor_temp)
6361  << Bind->getType());
6362  if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc()))
6363  return ExprError();
6364 
6365  // We need a cleanup, but we don't need to remember the temporary.
6367  }
6368 
6369  // Possibly strip off the top CXXBindTemporaryExpr.
6370  return E;
6371 }
6372 
6373 /// Note a set of 'operator->' functions that were used for a member access.
6374 static void noteOperatorArrows(Sema &S,
6375  ArrayRef<FunctionDecl *> OperatorArrows) {
6376  unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6377  // FIXME: Make this configurable?
6378  unsigned Limit = 9;
6379  if (OperatorArrows.size() > Limit) {
6380  // Produce Limit-1 normal notes and one 'skipping' note.
6381  SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6382  SkipCount = OperatorArrows.size() - (Limit - 1);
6383  }
6384 
6385  for (unsigned I = 0; I < OperatorArrows.size(); /**/) {
6386  if (I == SkipStart) {
6387  S.Diag(OperatorArrows[I]->getLocation(),
6388  diag::note_operator_arrows_suppressed)
6389  << SkipCount;
6390  I += SkipCount;
6391  } else {
6392  S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6393  << OperatorArrows[I]->getCallResultType();
6394  ++I;
6395  }
6396  }
6397 }
6398 
6400  SourceLocation OpLoc,
6401  tok::TokenKind OpKind,
6402  ParsedType &ObjectType,
6403  bool &MayBePseudoDestructor) {
6404  // Since this might be a postfix expression, get rid of ParenListExprs.
6406  if (Result.isInvalid()) return ExprError();
6407  Base = Result.get();
6408 
6409  Result = CheckPlaceholderExpr(Base);
6410  if (Result.isInvalid()) return ExprError();
6411  Base = Result.get();
6412 
6413  QualType BaseType = Base->getType();
6414  MayBePseudoDestructor = false;
6415  if (BaseType->isDependentType()) {
6416  // If we have a pointer to a dependent type and are using the -> operator,
6417  // the object type is the type that the pointer points to. We might still
6418  // have enough information about that type to do something useful.
6419  if (OpKind == tok::arrow)
6420  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
6421  BaseType = Ptr->getPointeeType();
6422 
6423  ObjectType = ParsedType::make(BaseType);
6424  MayBePseudoDestructor = true;
6425  return Base;
6426  }
6427 
6428  // C++ [over.match.oper]p8:
6429  // [...] When operator->returns, the operator-> is applied to the value
6430  // returned, with the original second operand.
6431  if (OpKind == tok::arrow) {
6432  QualType StartingType = BaseType;
6433  bool NoArrowOperatorFound = false;
6434  bool FirstIteration = true;
6435  FunctionDecl *CurFD = dyn_cast<FunctionDecl>(CurContext);
6436  // The set of types we've considered so far.
6437  llvm::SmallPtrSet<CanQualType,8> CTypes;
6438  SmallVector<FunctionDecl*, 8> OperatorArrows;
6439  CTypes.insert(Context.getCanonicalType(BaseType));
6440 
6441  while (BaseType->isRecordType()) {
6442  if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {
6443  Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6444  << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();
6445  noteOperatorArrows(*this, OperatorArrows);
6446  Diag(OpLoc, diag::note_operator_arrow_depth)
6447  << getLangOpts().ArrowDepth;
6448  return ExprError();
6449  }
6450 
6451  Result = BuildOverloadedArrowExpr(
6452  S, Base, OpLoc,
6453  // When in a template specialization and on the first loop iteration,
6454  // potentially give the default diagnostic (with the fixit in a
6455  // separate note) instead of having the error reported back to here
6456  // and giving a diagnostic with a fixit attached to the error itself.
6457  (FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization())
6458  ? nullptr
6459  : &NoArrowOperatorFound);
6460  if (Result.isInvalid()) {
6461  if (NoArrowOperatorFound) {
6462  if (FirstIteration) {
6463  Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6464  << BaseType << 1 << Base->getSourceRange()
6465  << FixItHint::CreateReplacement(OpLoc, ".");
6466  OpKind = tok::period;
6467  break;
6468  }
6469  Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6470  << BaseType << Base->getSourceRange();
6471  CallExpr *CE = dyn_cast<CallExpr>(Base);
6472  if (Decl *CD = (CE ? CE->getCalleeDecl() : nullptr)) {
6473  Diag(CD->getLocStart(),
6474  diag::note_member_reference_arrow_from_operator_arrow);
6475  }
6476  }
6477  return ExprError();
6478  }
6479  Base = Result.get();
6480  if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
6481  OperatorArrows.push_back(OpCall->getDirectCallee());
6482  BaseType = Base->getType();
6483  CanQualType CBaseType = Context.getCanonicalType(BaseType);
6484  if (!CTypes.insert(CBaseType).second) {
6485  Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6486  noteOperatorArrows(*this, OperatorArrows);
6487  return ExprError();
6488  }
6489  FirstIteration = false;
6490  }
6491 
6492  if (OpKind == tok::arrow &&
6493  (BaseType->isPointerType() || BaseType->isObjCObjectPointerType()))
6494  BaseType = BaseType->getPointeeType();
6495  }
6496 
6497  // Objective-C properties allow "." access on Objective-C pointer types,
6498  // so adjust the base type to the object type itself.
6499  if (BaseType->isObjCObjectPointerType())
6500  BaseType = BaseType->getPointeeType();
6501 
6502  // C++ [basic.lookup.classref]p2:
6503  // [...] If the type of the object expression is of pointer to scalar
6504  // type, the unqualified-id is looked up in the context of the complete
6505  // postfix-expression.
6506  //
6507  // This also indicates that we could be parsing a pseudo-destructor-name.
6508  // Note that Objective-C class and object types can be pseudo-destructor
6509  // expressions or normal member (ivar or property) access expressions, and
6510  // it's legal for the type to be incomplete if this is a pseudo-destructor
6511  // call. We'll do more incomplete-type checks later in the lookup process,
6512  // so just skip this check for ObjC types.
6513  if (BaseType->isObjCObjectOrInterfaceType()) {
6514  ObjectType = ParsedType::make(BaseType);
6515  MayBePseudoDestructor = true;
6516  return Base;
6517  } else if (!BaseType->isRecordType()) {
6518  ObjectType = nullptr;
6519  MayBePseudoDestructor = true;
6520  return Base;
6521  }
6522 
6523  // The object type must be complete (or dependent), or
6524  // C++11 [expr.prim.general]p3:
6525  // Unlike the object expression in other contexts, *this is not required to
6526  // be of complete type for purposes of class member access (5.2.5) outside
6527  // the member function body.
6528  if (!BaseType->isDependentType() &&
6529  !isThisOutsideMemberFunctionBody(BaseType) &&
6530  RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
6531  return ExprError();
6532 
6533  // C++ [basic.lookup.classref]p2:
6534  // If the id-expression in a class member access (5.2.5) is an
6535  // unqualified-id, and the type of the object expression is of a class
6536  // type C (or of pointer to a class type C), the unqualified-id is looked
6537  // up in the scope of class C. [...]
6538  ObjectType = ParsedType::make(BaseType);
6539  return Base;
6540 }
6541 
6542 static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
6543  tok::TokenKind& OpKind, SourceLocation OpLoc) {
6544  if (Base->hasPlaceholderType()) {
6545  ExprResult result = S.CheckPlaceholderExpr(Base);
6546  if (result.isInvalid()) return true;
6547  Base = result.get();
6548  }
6549  ObjectType = Base->getType();
6550 
6551  // C++ [expr.pseudo]p2:
6552  // The left-hand side of the dot operator shall be of scalar type. The
6553  // left-hand side of the arrow operator shall be of pointer to scalar type.
6554  // This scalar type is the object type.
6555  // Note that this is rather different from the normal handling for the
6556  // arrow operator.
6557  if (OpKind == tok::arrow) {
6558  if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
6559  ObjectType = Ptr->getPointeeType();
6560  } else if (!Base->isTypeDependent()) {
6561  // The user wrote "p->" when they probably meant "p."; fix it.
6562  S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6563  << ObjectType << true
6564  << FixItHint::CreateReplacement(OpLoc, ".");
6565  if (S.isSFINAEContext())
6566  return true;
6567 
6568  OpKind = tok::period;
6569  }
6570  }
6571 
6572  return false;
6573 }
6574 
6575 /// \brief Check if it's ok to try and recover dot pseudo destructor calls on
6576 /// pointer objects.
6577 static bool
6579  QualType DestructedType) {
6580  // If this is a record type, check if its destructor is callable.
6581  if (auto *RD = DestructedType->getAsCXXRecordDecl()) {
6582  if (CXXDestructorDecl *D = SemaRef.LookupDestructor(RD))
6583  return SemaRef.CanUseDecl(D, /*TreatUnavailableAsInvalid=*/false);
6584  return false;
6585  }
6586 
6587  // Otherwise, check if it's a type for which it's valid to use a pseudo-dtor.
6588  return DestructedType->isDependentType() || DestructedType->isScalarType() ||
6589  DestructedType->isVectorType();
6590 }
6591 
6593  SourceLocation OpLoc,
6594  tok::TokenKind OpKind,
6595  const CXXScopeSpec &SS,
6596  TypeSourceInfo *ScopeTypeInfo,
6597  SourceLocation CCLoc,
6598  SourceLocation TildeLoc,
6599  PseudoDestructorTypeStorage Destructed) {
6600  TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
6601 
6602  QualType ObjectType;
6603  if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6604  return ExprError();
6605 
6606  if (!ObjectType->isDependentType() && !ObjectType->isScalarType() &&
6607  !ObjectType->isVectorType()) {
6608  if (getLangOpts().MSVCCompat && ObjectType->isVoidType())
6609  Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange();
6610  else {
6611  Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6612  << ObjectType << Base->getSourceRange();
6613  return ExprError();
6614  }
6615  }
6616 
6617  // C++ [expr.pseudo]p2:
6618  // [...] The cv-unqualified versions of the object type and of the type
6619  // designated by the pseudo-destructor-name shall be the same type.
6620  if (DestructedTypeInfo) {
6621  QualType DestructedType = DestructedTypeInfo->getType();
6622  SourceLocation DestructedTypeStart
6623  = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
6624  if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {
6625  if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
6626  // Detect dot pseudo destructor calls on pointer objects, e.g.:
6627  // Foo *foo;
6628  // foo.~Foo();
6629  if (OpKind == tok::period && ObjectType->isPointerType() &&
6630  Context.hasSameUnqualifiedType(DestructedType,
6631  ObjectType->getPointeeType())) {
6632  auto Diagnostic =
6633  Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6634  << ObjectType << /*IsArrow=*/0 << Base->getSourceRange();
6635 
6636  // Issue a fixit only when the destructor is valid.
6638  *this, DestructedType))
6639  Diagnostic << FixItHint::CreateReplacement(OpLoc, "->");
6640 
6641  // Recover by setting the object type to the destructed type and the
6642  // operator to '->'.
6643  ObjectType = DestructedType;
6644  OpKind = tok::arrow;
6645  } else {
6646  Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6647  << ObjectType << DestructedType << Base->getSourceRange()
6648  << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
6649 
6650  // Recover by setting the destructed type to the object type.
6651  DestructedType = ObjectType;
6652  DestructedTypeInfo =
6653  Context.getTrivialTypeSourceInfo(ObjectType, DestructedTypeStart);
6654  Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
6655  }
6656  } else if (DestructedType.getObjCLifetime() !=
6657  ObjectType.getObjCLifetime()) {
6658 
6659  if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {
6660  // Okay: just pretend that the user provided the correctly-qualified
6661  // type.
6662  } else {
6663  Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6664  << ObjectType << DestructedType << Base->getSourceRange()
6665  << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
6666  }
6667 
6668  // Recover by setting the destructed type to the object type.
6669  DestructedType = ObjectType;
6670  DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
6671  DestructedTypeStart);
6672  Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
6673  }
6674  }
6675  }
6676 
6677  // C++ [expr.pseudo]p2:
6678  // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
6679  // form
6680  //
6681  // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
6682  //
6683  // shall designate the same scalar type.
6684  if (ScopeTypeInfo) {
6685  QualType ScopeType = ScopeTypeInfo->getType();
6686  if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
6687  !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
6688 
6689  Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
6690  diag::err_pseudo_dtor_type_mismatch)
6691  << ObjectType << ScopeType << Base->getSourceRange()
6692  << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
6693 
6694  ScopeType = QualType();
6695  ScopeTypeInfo = nullptr;
6696  }
6697  }
6698 
6699  Expr *Result
6700  = new (Context) CXXPseudoDestructorExpr(Context, Base,
6701  OpKind == tok::arrow, OpLoc,
6703  ScopeTypeInfo,
6704  CCLoc,
6705  TildeLoc,
6706  Destructed);
6707 
6708  return Result;
6709 }
6710 
6712  SourceLocation OpLoc,
6713  tok::TokenKind OpKind,
6714  CXXScopeSpec &SS,
6715  UnqualifiedId &FirstTypeName,
6716  SourceLocation CCLoc,
6717  SourceLocation TildeLoc,
6718  UnqualifiedId &SecondTypeName) {
6719  assert((FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
6720  FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
6721  "Invalid first type name in pseudo-destructor");
6722  assert((SecondTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
6723  SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
6724  "Invalid second type name in pseudo-destructor");
6725 
6726  QualType ObjectType;
6727  if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6728  return ExprError();
6729 
6730  // Compute the object type that we should use for name lookup purposes. Only
6731  // record types and dependent types matter.
6732  ParsedType ObjectTypePtrForLookup;
6733  if (!SS.isSet()) {
6734  if (ObjectType->isRecordType())
6735  ObjectTypePtrForLookup = ParsedType::make(ObjectType);
6736  else if (ObjectType->isDependentType())
6737  ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
6738  }
6739 
6740  // Convert the name of the type being destructed (following the ~) into a
6741  // type (with source-location information).
6742  QualType DestructedType;
6743  TypeSourceInfo *DestructedTypeInfo = nullptr;
6744  PseudoDestructorTypeStorage Destructed;
6745  if (SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
6746  ParsedType T = getTypeName(*SecondTypeName.Identifier,
6747  SecondTypeName.StartLocation,
6748  S, &SS, true, false, ObjectTypePtrForLookup,
6749  /*IsCtorOrDtorName*/true);
6750  if (!T &&
6751  ((SS.isSet() && !computeDeclContext(SS, false)) ||
6752  (!SS.isSet() && ObjectType->isDependentType()))) {
6753  // The name of the type being destroyed is a dependent name, and we
6754  // couldn't find anything useful in scope. Just store the identifier and
6755  // it's location, and we'll perform (qualified) name lookup again at
6756  // template instantiation time.
6757  Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
6758  SecondTypeName.StartLocation);
6759  } else if (!T) {
6760  Diag(SecondTypeName.StartLocation,
6761  diag::err_pseudo_dtor_destructor_non_type)
6762  << SecondTypeName.Identifier << ObjectType;
6763  if (isSFINAEContext())
6764  return ExprError();
6765 
6766  // Recover by assuming we had the right type all along.
6767  DestructedType = ObjectType;
6768  } else
6769  DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
6770  } else {
6771  // Resolve the template-id to a type.
6772  TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
6773  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
6774  TemplateId->NumArgs);
6775  TypeResult T = ActOnTemplateIdType(TemplateId->SS,
6776  TemplateId->TemplateKWLoc,
6777  TemplateId->Template,
6778  TemplateId->Name,
6779  TemplateId->TemplateNameLoc,
6780  TemplateId->LAngleLoc,
6781  TemplateArgsPtr,
6782  TemplateId->RAngleLoc,
6783  /*IsCtorOrDtorName*/true);
6784  if (T.isInvalid() || !T.get()) {
6785  // Recover by assuming we had the right type all along.
6786  DestructedType = ObjectType;
6787  } else
6788  DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
6789  }
6790 
6791  // If we've performed some kind of recovery, (re-)build the type source
6792  // information.
6793  if (!DestructedType.isNull()) {
6794  if (!DestructedTypeInfo)
6795  DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
6796  SecondTypeName.StartLocation);
6797  Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
6798  }
6799 
6800  // Convert the name of the scope type (the type prior to '::') into a type.
6801  TypeSourceInfo *ScopeTypeInfo = nullptr;
6802  QualType ScopeType;
6803  if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
6804  FirstTypeName.Identifier) {
6805  if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
6806  ParsedType T = getTypeName(*FirstTypeName.Identifier,
6807  FirstTypeName.StartLocation,
6808  S, &SS, true, false, ObjectTypePtrForLookup,
6809  /*IsCtorOrDtorName*/true);
6810  if (!T) {
6811  Diag(FirstTypeName.StartLocation,
6812  diag::err_pseudo_dtor_destructor_non_type)
6813  << FirstTypeName.Identifier << ObjectType;
6814 
6815  if (isSFINAEContext())
6816  return ExprError();
6817 
6818  // Just drop this type. It's unnecessary anyway.
6819  ScopeType = QualType();
6820  } else
6821  ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
6822  } else {
6823  // Resolve the template-id to a type.
6824  TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
6825  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
6826  TemplateId->NumArgs);
6827  TypeResult T = ActOnTemplateIdType(TemplateId->SS,
6828  TemplateId->TemplateKWLoc,
6829  TemplateId->Template,
6830  TemplateId->Name,
6831  TemplateId->TemplateNameLoc,
6832  TemplateId->LAngleLoc,
6833  TemplateArgsPtr,
6834  TemplateId->RAngleLoc,
6835  /*IsCtorOrDtorName*/true);
6836  if (T.isInvalid() || !T.get()) {
6837  // Recover by dropping this type.
6838  ScopeType = QualType();
6839  } else
6840  ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
6841  }
6842  }
6843 
6844  if (!ScopeType.isNull() && !ScopeTypeInfo)
6845  ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
6846  FirstTypeName.StartLocation);
6847 
6848 
6849  return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
6850  ScopeTypeInfo, CCLoc, TildeLoc,
6851  Destructed);
6852 }
6853 
6855  SourceLocation OpLoc,
6856  tok::TokenKind OpKind,
6857  SourceLocation TildeLoc,
6858  const DeclSpec& DS) {
6859  QualType ObjectType;
6860  if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6861  return ExprError();
6862 
6864  false);
6865 
6866  TypeLocBuilder TLB;
6867  DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
6868  DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
6869  TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
6870  PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
6871 
6872  return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),
6873  nullptr, SourceLocation(), TildeLoc,
6874  Destructed);
6875 }
6876 
6878  CXXConversionDecl *Method,
6879  bool HadMultipleCandidates) {
6880  if (Method->getParent()->isLambda() &&
6881  Method->getConversionType()->isBlockPointerType()) {
6882  // This is a lambda coversion to block pointer; check if the argument
6883  // is a LambdaExpr.
6884  Expr *SubE = E;
6885  CastExpr *CE = dyn_cast<CastExpr>(SubE);
6886  if (CE && CE->getCastKind() == CK_NoOp)
6887  SubE = CE->getSubExpr();
6888  SubE = SubE->IgnoreParens();
6889  if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
6890  SubE = BE->getSubExpr();
6891  if (isa<LambdaExpr>(SubE)) {
6892  // For the conversion to block pointer on a lambda expression, we
6893  // construct a special BlockLiteral instead; this doesn't really make
6894  // a difference in ARC, but outside of ARC the resulting block literal
6895  // follows the normal lifetime rules for block literals instead of being
6896  // autoreleased.
6897  DiagnosticErrorTrap Trap(Diags);
6901  E->getExprLoc(),
6902  Method, E);
6904 
6905  if (Exp.isInvalid())
6906  Diag(E->getExprLoc(), diag::note_lambda_to_block_conv);
6907  return Exp;
6908  }
6909  }
6910 
6911  ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/nullptr,
6912  FoundDecl, Method);
6913  if (Exp.isInvalid())
6914  return true;
6915 
6916  MemberExpr *ME = new (Context) MemberExpr(
6917  Exp.get(), /*IsArrow=*/false, SourceLocation(), Method, SourceLocation(),
6919  if (HadMultipleCandidates)
6920  ME->setHadMultipleCandidates(true);
6922 
6923  QualType ResultType = Method->getReturnType();
6924  ExprValueKind VK = Expr::getValueKindForType(ResultType);
6925  ResultType = ResultType.getNonLValueExprType(Context);
6926 
6927  CXXMemberCallExpr *CE =
6928  new (Context) CXXMemberCallExpr(Context, ME, None, ResultType, VK,
6929  Exp.get()->getLocEnd());
6930 
6931  if (CheckFunctionCall(Method, CE,
6932  Method->getType()->castAs<FunctionProtoType>()))
6933  return ExprError();
6934 
6935  return CE;
6936 }
6937 
6939  SourceLocation RParen) {
6940  // If the operand is an unresolved lookup expression, the expression is ill-
6941  // formed per [over.over]p1, because overloaded function names cannot be used
6942  // without arguments except in explicit contexts.
6943  ExprResult R = CheckPlaceholderExpr(Operand);
6944  if (R.isInvalid())
6945  return R;
6946 
6947  // The operand may have been modified when checking the placeholder type.
6948  Operand = R.get();
6949 
6950  if (!inTemplateInstantiation() && Operand->HasSideEffects(Context, false)) {
6951  // The expression operand for noexcept is in an unevaluated expression
6952  // context, so side effects could result in unintended consequences.
6953  Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
6954  }
6955 
6956  CanThrowResult CanThrow = canThrow(Operand);
6957  return new (Context)
6958  CXXNoexceptExpr(Context.BoolTy, Operand, CanThrow, KeyLoc, RParen);
6959 }
6960 
6962  Expr *Operand, SourceLocation RParen) {
6963  return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
6964 }
6965 
6967  // In C++11, discarded-value expressions of a certain form are special,
6968  // according to [expr]p10:
6969  // The lvalue-to-rvalue conversion (4.1) is applied only if the
6970  // expression is an lvalue of volatile-qualified type and it has
6971  // one of the following forms:
6972  E = E->IgnoreParens();
6973 
6974  // - id-expression (5.1.1),
6975  if (isa<DeclRefExpr>(E))
6976  return true;
6977 
6978  // - subscripting (5.2.1),
6979  if (isa<ArraySubscriptExpr>(E))
6980  return true;
6981 
6982  // - class member access (5.2.5),
6983  if (isa<MemberExpr>(E))
6984  return true;
6985 
6986  // - indirection (5.3.1),
6987  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
6988  if (UO->getOpcode() == UO_Deref)
6989  return true;
6990 
6991  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
6992  // - pointer-to-member operation (5.5),
6993  if (BO->isPtrMemOp())
6994  return true;
6995 
6996  // - comma expression (5.18) where the right operand is one of the above.
6997  if (BO->getOpcode() == BO_Comma)
6998  return IsSpecialDiscardedValue(BO->getRHS());
6999  }
7000 
7001  // - conditional expression (5.16) where both the second and the third
7002  // operands are one of the above, or
7003  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
7004  return IsSpecialDiscardedValue(CO->getTrueExpr()) &&
7005  IsSpecialDiscardedValue(CO->getFalseExpr());
7006  // The related edge case of "*x ?: *x".
7007  if (BinaryConditionalOperator *BCO =
7008  dyn_cast<BinaryConditionalOperator>(E)) {
7009  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7010  return IsSpecialDiscardedValue(OVE->getSourceExpr()) &&
7011  IsSpecialDiscardedValue(BCO->getFalseExpr());
7012  }
7013 
7014  // Objective-C++ extensions to the rule.
7015  if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7016  return true;
7017 
7018  return false;
7019 }
7020 
7021 /// Perform the conversions required for an expression used in a
7022 /// context that ignores the result.
7024  if (E->hasPlaceholderType()) {
7025  ExprResult result = CheckPlaceholderExpr(E);
7026  if (result.isInvalid()) return E;
7027  E = result.get();
7028  }
7029 
7030  // C99 6.3.2.1:
7031  // [Except in specific positions,] an lvalue that does not have
7032  // array type is converted to the value stored in the
7033  // designated object (and is no longer an lvalue).
7034  if (E->isRValue()) {
7035  // In C, function designators (i.e. expressions of function type)
7036  // are r-values, but we still want to do function-to-pointer decay
7037  // on them. This is both technically correct and convenient for
7038  // some clients.
7039  if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType())
7041 
7042  return E;
7043  }
7044 
7045  if (getLangOpts().CPlusPlus) {
7046  // The C++11 standard defines the notion of a discarded-value expression;
7047  // normally, we don't need to do anything to handle it, but if it is a
7048  // volatile lvalue with a special form, we perform an lvalue-to-rvalue
7049  // conversion.
7050  if (getLangOpts().CPlusPlus11 && E->isGLValue() &&
7051  E->getType().isVolatileQualified() &&
7054  if (Res.isInvalid())
7055  return E;
7056  E = Res.get();
7057  }
7058 
7059  // C++1z:
7060  // If the expression is a prvalue after this optional conversion, the
7061  // temporary materialization conversion is applied.
7062  //
7063  // We skip this step: IR generation is able to synthesize the storage for
7064  // itself in the aggregate case, and adding the extra node to the AST is
7065  // just clutter.
7066  // FIXME: We don't emit lifetime markers for the temporaries due to this.
7067  // FIXME: Do any other AST consumers care about this?
7068  return E;
7069  }
7070 
7071  // GCC seems to also exclude expressions of incomplete enum type.
7072  if (const EnumType *T = E->getType()->getAs<EnumType>()) {
7073  if (!T->getDecl()->isComplete()) {
7074  // FIXME: stupid workaround for a codegen bug!
7075  E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get();
7076  return E;
7077  }
7078  }
7079 
7081  if (Res.isInvalid())
7082  return E;
7083  E = Res.get();
7084 
7085  if (!E->getType()->isVoidType())
7087  diag::err_incomplete_type);
7088  return E;
7089 }
7090 
7091 // If we can unambiguously determine whether Var can never be used
7092 // in a constant expression, return true.
7093 // - if the variable and its initializer are non-dependent, then
7094 // we can unambiguously check if the variable is a constant expression.
7095 // - if the initializer is not value dependent - we can determine whether
7096 // it can be used to initialize a constant expression. If Init can not
7097 // be used to initialize a constant expression we conclude that Var can
7098 // never be a constant expression.
7099 // - FXIME: if the initializer is dependent, we can still do some analysis and
7100 // identify certain cases unambiguously as non-const by using a Visitor:
7101 // - such as those that involve odr-use of a ParmVarDecl, involve a new
7102 // delete, lambda-expr, dynamic-cast, reinterpret-cast etc...
7104  ASTContext &Context) {
7105  if (isa<ParmVarDecl>(Var)) return true;
7106  const VarDecl *DefVD = nullptr;
7107 
7108  // If there is no initializer - this can not be a constant expression.
7109  if (!Var->getAnyInitializer(DefVD)) return true;
7110  assert(DefVD);
7111  if (DefVD->isWeak()) return false;
7112  EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
7113 
7114  Expr *Init = cast<Expr>(Eval->Value);
7115 
7116  if (Var->getType()->isDependentType() || Init->isValueDependent()) {
7117  // FIXME: Teach the constant evaluator to deal with the non-dependent parts
7118  // of value-dependent expressions, and use it here to determine whether the
7119  // initializer is a potential constant expression.
7120  return false;
7121  }
7122 
7123  return !IsVariableAConstantExpression(Var, Context);
7124 }
7125 
7126 /// \brief Check if the current lambda has any potential captures
7127 /// that must be captured by any of its enclosing lambdas that are ready to
7128 /// capture. If there is a lambda that can capture a nested
7129 /// potential-capture, go ahead and do so. Also, check to see if any
7130 /// variables are uncaptureable or do not involve an odr-use so do not
7131 /// need to be captured.
7132 
7134  Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) {
7135 
7136  assert(!S.isUnevaluatedContext());
7137  assert(S.CurContext->isDependentContext());
7138 #ifndef NDEBUG
7139  DeclContext *DC = S.CurContext;
7140  while (DC && isa<CapturedDecl>(DC))
7141  DC = DC->getParent();
7142  assert(
7143  CurrentLSI->CallOperator == DC &&
7144  "The current call operator must be synchronized with Sema's CurContext");
7145 #endif // NDEBUG
7146 
7147  const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent();
7148 
7149  ArrayRef<const FunctionScopeInfo *> FunctionScopesArrayRef(
7150  S.FunctionScopes.data(), S.FunctionScopes.size());
7151 
7152  // All the potentially captureable variables in the current nested
7153  // lambda (within a generic outer lambda), must be captured by an
7154  // outer lambda that is enclosed within a non-dependent context.
7155  const unsigned NumPotentialCaptures =
7156  CurrentLSI->getNumPotentialVariableCaptures();
7157  for (unsigned I = 0; I != NumPotentialCaptures; ++I) {
7158  Expr *VarExpr = nullptr;
7159  VarDecl *Var = nullptr;
7160  CurrentLSI->getPotentialVariableCapture(I, Var, VarExpr);
7161  // If the variable is clearly identified as non-odr-used and the full
7162  // expression is not instantiation dependent, only then do we not
7163  // need to check enclosing lambda's for speculative captures.
7164  // For e.g.:
7165  // Even though 'x' is not odr-used, it should be captured.
7166  // int test() {
7167  // const int x = 10;
7168  // auto L = [=](auto a) {
7169  // (void) +x + a;
7170  // };
7171  // }
7172  if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) &&
7173  !IsFullExprInstantiationDependent)
7174  continue;
7175 
7176  // If we have a capture-capable lambda for the variable, go ahead and
7177  // capture the variable in that lambda (and all its enclosing lambdas).
7178  if (const Optional<unsigned> Index =
7180  FunctionScopesArrayRef, Var, S)) {
7181  const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7182  MarkVarDeclODRUsed(Var, VarExpr->getExprLoc(), S,
7183  &FunctionScopeIndexOfCapturableLambda);
7184  }
7185  const bool IsVarNeverAConstantExpression =
7187  if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7188  // This full expression is not instantiation dependent or the variable
7189  // can not be used in a constant expression - which means
7190  // this variable must be odr-used here, so diagnose a
7191  // capture violation early, if the variable is un-captureable.
7192  // This is purely for diagnosing errors early. Otherwise, this
7193  // error would get diagnosed when the lambda becomes capture ready.
7194  QualType CaptureType, DeclRefType;
7195  SourceLocation ExprLoc = VarExpr->getExprLoc();
7196  if (S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
7197  /*EllipsisLoc*/ SourceLocation(),
7198  /*BuildAndDiagnose*/false, CaptureType,
7199  DeclRefType, nullptr)) {
7200  // We will never be able to capture this variable, and we need
7201  // to be able to in any and all instantiations, so diagnose it.
7202  S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
7203  /*EllipsisLoc*/ SourceLocation(),
7204  /*BuildAndDiagnose*/true, CaptureType,
7205  DeclRefType, nullptr);
7206  }
7207  }
7208  }
7209 
7210  // Check if 'this' needs to be captured.
7211  if (CurrentLSI->hasPotentialThisCapture()) {
7212  // If we have a capture-capable lambda for 'this', go ahead and capture
7213  // 'this' in that lambda (and all its enclosing lambdas).
7214  if (const Optional<unsigned> Index =
7216  FunctionScopesArrayRef, /*0 is 'this'*/ nullptr, S)) {
7217  const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7219  /*Explicit*/ false, /*BuildAndDiagnose*/ true,
7220  &FunctionScopeIndexOfCapturableLambda);
7221  }
7222  }
7223 
7224  // Reset all the potential captures at the end of each full-expression.
7225  CurrentLSI->clearPotentialCaptures();
7226 }
7227 
7230  const TypoCorrection &TC) {
7231  LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(),
7232  Consumer.getLookupResult().getLookupKind());
7233  const CXXScopeSpec *SS = Consumer.getSS();
7234  CXXScopeSpec NewSS;
7235 
7236  // Use an approprate CXXScopeSpec for building the expr.
7237  if (auto *NNS = TC.getCorrectionSpecifier())
7238  NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange());
7239  else if (SS && !TC.WillReplaceSpecifier())
7240  NewSS = *SS;
7241 
7242  if (auto *ND = TC.getFoundDecl()) {
7243  R.setLookupName(ND->getDeclName());
7244  R.addDecl(ND);
7245  if (ND->isCXXClassMember()) {
7246  // Figure out the correct naming class to add to the LookupResult.
7247  CXXRecordDecl *Record = nullptr;
7248  if (auto *NNS = TC.getCorrectionSpecifier())
7249  Record = NNS->getAsType()->getAsCXXRecordDecl();
7250  if (!Record)
7251  Record =
7252  dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7253  if (Record)
7254  R.setNamingClass(Record);
7255 
7256  // Detect and handle the case where the decl might be an implicit
7257  // member.
7258  bool MightBeImplicitMember;
7259  if (!Consumer.isAddressOfOperand())
7260  MightBeImplicitMember = true;
7261  else if (!NewSS.isEmpty())
7262  MightBeImplicitMember = false;
7263  else if (R.isOverloadedResult())
7264  MightBeImplicitMember = false;
7265  else if (R.isUnresolvableResult())
7266  MightBeImplicitMember = true;
7267  else
7268  MightBeImplicitMember = isa<FieldDecl>(ND) ||
7269  isa<IndirectFieldDecl>(ND) ||
7270  isa<MSPropertyDecl>(ND);
7271 
7272  if (MightBeImplicitMember)
7273  return SemaRef.BuildPossibleImplicitMemberExpr(
7274  NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
7275  /*TemplateArgs*/ nullptr, /*S*/ nullptr);
7276  } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7277  return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
7278  Ivar->getIdentifier());
7279  }
7280  }
7281 
7282  return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
7283  /*AcceptInvalidDecl*/ true);
7284 }
7285 
7286 namespace {
7287 class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
7289 
7290 public:
7291  explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)
7292  : TypoExprs(TypoExprs) {}
7293  bool VisitTypoExpr(TypoExpr *TE) {
7294  TypoExprs.insert(TE);
7295  return true;
7296  }
7297 };
7298 
7299 class TransformTypos : public TreeTransform<TransformTypos> {
7300  typedef TreeTransform<TransformTypos> BaseTransform;
7301 
7302  VarDecl *InitDecl; // A decl to avoid as a correction because it is in the
7303  // process of being initialized.
7304  llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7305  llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs;
7306  llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7307  llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7308 
7309  /// \brief Emit diagnostics for all of the TypoExprs encountered.
7310  /// If the TypoExprs were successfully corrected, then the diagnostics should
7311  /// suggest the corrections. Otherwise the diagnostics will not suggest
7312  /// anything (having been passed an empty TypoCorrection).
7313  void EmitAllDiagnostics() {
7314  for (auto E : TypoExprs) {
7315  TypoExpr *TE = cast<TypoExpr>(E);
7316  auto &State = SemaRef.getTypoExprState(TE);
7317  if (State.DiagHandler) {
7318  TypoCorrection TC = State.Consumer->getCurrentCorrection();
7319  ExprResult Replacement = TransformCache[TE];
7320 
7321  // Extract the NamedDecl from the transformed TypoExpr and add it to the
7322  // TypoCorrection, replacing the existing decls. This ensures the right
7323  // NamedDecl is used in diagnostics e.g. in the case where overload
7324  // resolution was used to select one from several possible decls that
7325  // had been stored in the TypoCorrection.
7326  if (auto *ND = getDeclFromExpr(
7327  Replacement.isInvalid() ? nullptr : Replacement.get()))
7328  TC.setCorrectionDecl(ND);
7329 
7330  State.DiagHandler(TC);
7331  }
7332  SemaRef.clearDelayedTypo(TE);
7333  }
7334  }
7335 
7336  /// \brief If corrections for the first TypoExpr have been exhausted for a
7337  /// given combination of the other TypoExprs, retry those corrections against
7338  /// the next combination of substitutions for the other TypoExprs by advancing
7339  /// to the next potential correction of the second TypoExpr. For the second
7340  /// and subsequent TypoExprs, if its stream of corrections has been exhausted,
7341  /// the stream is reset and the next TypoExpr's stream is advanced by one (a
7342  /// TypoExpr's correction stream is advanced by removing the TypoExpr from the
7343  /// TransformCache). Returns true if there is still any untried combinations
7344  /// of corrections.
7345  bool CheckAndAdvanceTypoExprCorrectionStreams() {
7346  for (auto TE : TypoExprs) {
7347  auto &State = SemaRef.getTypoExprState(TE);
7348  TransformCache.erase(TE);
7349  if (!State.Consumer->finished())
7350  return true;
7351  State.Consumer->resetCorrectionStream();
7352  }
7353  return false;
7354  }
7355 
7357  if (auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7358  E = OverloadResolution[OE];
7359 
7360  if (!E)
7361  return nullptr;
7362  if (auto *DRE = dyn_cast<DeclRefExpr>(E))
7363  return DRE->getFoundDecl();
7364  if (auto *ME = dyn_cast<MemberExpr>(E))
7365  return ME->getFoundDecl();
7366  // FIXME: Add any other expr types that could be be seen by the delayed typo
7367  // correction TreeTransform for which the corresponding TypoCorrection could
7368  // contain multiple decls.
7369  return nullptr;
7370  }
7371 
7372  ExprResult TryTransform(Expr *E) {
7373  Sema::SFINAETrap Trap(SemaRef);
7374  ExprResult Res = TransformExpr(E);
7375  if (Trap.hasErrorOccurred() || Res.isInvalid())
7376  return ExprError();
7377 
7378  return ExprFilter(Res.get());
7379  }
7380 
7381 public:
7382  TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter)
7383  : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
7384 
7385  ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
7386  MultiExprArg Args,
7387  SourceLocation RParenLoc,
7388  Expr *ExecConfig = nullptr) {
7389  auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7390  RParenLoc, ExecConfig);
7391  if (auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7392  if (Result.isUsable()) {
7393  Expr *ResultCall = Result.get();
7394  if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7395  ResultCall = BE->getSubExpr();
7396  if (auto *CE = dyn_cast<CallExpr>(ResultCall))
7397  OverloadResolution[OE] = CE->getCallee();
7398  }
7399  }
7400  return Result;
7401  }
7402 
7403  ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); }
7404 
7405  ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); }
7406 
7407  ExprResult Transform(Expr *E) {
7408  ExprResult Res;
7409  while (true) {
7410  Res = TryTransform(E);
7411 
7412  // Exit if either the transform was valid or if there were no TypoExprs
7413  // to transform that still have any untried correction candidates..
7414  if (!Res.isInvalid() ||
7415  !CheckAndAdvanceTypoExprCorrectionStreams())
7416  break;
7417  }
7418 
7419  // Ensure none of the TypoExprs have multiple typo correction candidates
7420  // with the same edit length that pass all the checks and filters.
7421  // TODO: Properly handle various permutations of possible corrections when
7422  // there is more than one potentially ambiguous typo correction.
7423  // Also, disable typo correction while attempting the transform when
7424  // handling potentially ambiguous typo corrections as any new TypoExprs will
7425  // have been introduced by the application of one of the correction
7426  // candidates and add little to no value if corrected.
7427  SemaRef.DisableTypoCorrection = true;
7428  while (!AmbiguousTypoExprs.empty()) {
7429  auto TE = AmbiguousTypoExprs.back();
7430  auto Cached = TransformCache[TE];
7431  auto &State = SemaRef.getTypoExprState(TE);
7432  State.Consumer->saveCurrentPosition();
7433  TransformCache.erase(TE);
7434  if (!TryTransform(E).isInvalid()) {
7435  State.Consumer->resetCorrectionStream();
7436  TransformCache.erase(TE);
7437  Res = ExprError();
7438  break;
7439  }
7440  AmbiguousTypoExprs.remove(TE);
7441  State.Consumer->restoreSavedPosition();
7442  TransformCache[TE] = Cached;
7443  }
7444  SemaRef.DisableTypoCorrection = false;
7445 
7446  // Ensure that all of the TypoExprs within the current Expr have been found.
7447  if (!Res.isUsable())
7448  FindTypoExprs(TypoExprs).TraverseStmt(E);
7449 
7450  EmitAllDiagnostics();
7451 
7452  return Res;
7453  }
7454 
7455  ExprResult TransformTypoExpr(TypoExpr *E) {
7456  // If the TypoExpr hasn't been seen before, record it. Otherwise, return the
7457  // cached transformation result if there is one and the TypoExpr isn't the
7458  // first one that was encountered.
7459  auto &CacheEntry = TransformCache[E];
7460  if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7461  return CacheEntry;
7462  }
7463 
7464  auto &State = SemaRef.getTypoExprState(E);
7465  assert(State.Consumer && "Cannot transform a cleared TypoExpr");
7466 
7467  // For the first TypoExpr and an uncached TypoExpr, find the next likely
7468  // typo correction and return it.
7469  while (TypoCorrection TC = State.Consumer->getNextCorrection()) {
7470  if (InitDecl && TC.getFoundDecl() == InitDecl)
7471  continue;
7472  // FIXME: If we would typo-correct to an invalid declaration, it's
7473  // probably best to just suppress all errors from this typo correction.
7474  ExprResult NE = State.RecoveryHandler ?
7475  State.RecoveryHandler(SemaRef, E, TC) :
7476  attemptRecovery(SemaRef, *State.Consumer, TC);
7477  if (!NE.isInvalid()) {
7478  // Check whether there may be a second viable correction with the same
7479  // edit distance; if so, remember this TypoExpr may have an ambiguous
7480  // correction so it can be more thoroughly vetted later.
7481  TypoCorrection Next;
7482  if ((Next = State.Consumer->peekNextCorrection()) &&
7483  Next.getEditDistance(false) == TC.getEditDistance(false)) {
7484  AmbiguousTypoExprs.insert(E);
7485  } else {
7486  AmbiguousTypoExprs.remove(E);
7487  }
7488  assert(!NE.isUnset() &&
7489  "Typo was transformed into a valid-but-null ExprResult");
7490  return CacheEntry = NE;
7491  }
7492  }
7493  return CacheEntry = ExprError();
7494  }
7495 };
7496 }
7497 
7498 ExprResult
7500  llvm::function_ref<ExprResult(Expr *)> Filter) {
7501  // If the current evaluation context indicates there are uncorrected typos
7502  // and the current expression isn't guaranteed to not have typos, try to
7503  // resolve any TypoExpr nodes that might be in the expression.
7504  if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&
7505  (E->isTypeDependent() || E->isValueDependent() ||
7506  E->isInstantiationDependent())) {
7507  auto TyposInContext = ExprEvalContexts.back().NumTypos;
7508  assert(TyposInContext < ~0U && "Recursive call of CorrectDelayedTyposInExpr");
7509  ExprEvalContexts.back().NumTypos = ~0U;
7510  auto TyposResolved = DelayedTypos.size();
7511  auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E);
7512  ExprEvalContexts.back().NumTypos = TyposInContext;
7513  TyposResolved -= DelayedTypos.size();
7514  if (Result.isInvalid() || Result.get() != E) {
7515  ExprEvalContexts.back().NumTypos -= TyposResolved;
7516  return Result;
7517  }
7518  assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
7519  }
7520  return E;
7521 }
7522 
7524  bool DiscardedValue,
7525  bool IsConstexpr,
7526  bool IsLambdaInitCaptureInitializer) {
7527  ExprResult FullExpr = FE;
7528 
7529  if (!FullExpr.get())
7530  return ExprError();
7531 
7532  // If we are an init-expression in a lambdas init-capture, we should not
7533  // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
7534  // containing full-expression is done).
7535  // template<class ... Ts> void test(Ts ... t) {
7536  // test([&a(t)]() { <-- (t) is an init-expr that shouldn't be diagnosed now.
7537  // return a;
7538  // }() ...);
7539  // }
7540  // FIXME: This is a hack. It would be better if we pushed the lambda scope
7541  // when we parse the lambda introducer, and teach capturing (but not
7542  // unexpanded pack detection) to walk over LambdaScopeInfos which don't have a
7543  // corresponding class yet (that is, have LambdaScopeInfo either represent a
7544  // lambda where we've entered the introducer but not the body, or represent a
7545  // lambda where we've entered the body, depending on where the
7546  // parser/instantiation has got to).
7547  if (!IsLambdaInitCaptureInitializer &&
7549  return ExprError();
7550 
7551  // Top-level expressions default to 'id' when we're in a debugger.
7552  if (DiscardedValue && getLangOpts().DebuggerCastResultToId &&
7553  FullExpr.get()->getType() == Context.UnknownAnyTy) {
7554  FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType());
7555  if (FullExpr.isInvalid())
7556  return ExprError();
7557  }
7558 
7559  if (DiscardedValue) {
7560  FullExpr = CheckPlaceholderExpr(FullExpr.get());
7561  if (FullExpr.isInvalid())
7562  return ExprError();
7563 
7564  FullExpr = IgnoredValueConversions(FullExpr.get());
7565  if (FullExpr.isInvalid())
7566  return ExprError();
7567  }
7568 
7569  FullExpr = CorrectDelayedTyposInExpr(FullExpr.get());
7570  if (FullExpr.isInvalid())
7571  return ExprError();
7572 
7573  CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
7574 
7575  // At the end of this full expression (which could be a deeply nested
7576  // lambda), if there is a potential capture within the nested lambda,
7577  // have the outer capture-able lambda try and capture it.
7578  // Consider the following code:
7579  // void f(int, int);
7580  // void f(const int&, double);
7581  // void foo() {
7582  // const int x = 10, y = 20;
7583  // auto L = [=](auto a) {
7584  // auto M = [=](auto b) {
7585  // f(x, b); <-- requires x to be captured by L and M
7586  // f(y, a); <-- requires y to be captured by L, but not all Ms
7587  // };
7588  // };
7589  // }
7590 
7591  // FIXME: Also consider what happens for something like this that involves
7592  // the gnu-extension statement-expressions or even lambda-init-captures:
7593  // void f() {
7594  // const int n = 0;
7595  // auto L = [&](auto a) {
7596  // +n + ({ 0; a; });
7597  // };
7598  // }
7599  //
7600  // Here, we see +n, and then the full-expression 0; ends, so we don't
7601  // capture n (and instead remove it from our list of potential captures),
7602  // and then the full-expression +n + ({ 0; }); ends, but it's too late
7603  // for us to see that we need to capture n after all.
7604 
7605  LambdaScopeInfo *const CurrentLSI =
7606  getCurLambda(/*IgnoreCapturedRegions=*/true);
7607  // FIXME: PR 17877 showed that getCurLambda() can return a valid pointer
7608  // even if CurContext is not a lambda call operator. Refer to that Bug Report
7609  // for an example of the code that might cause this asynchrony.
7610  // By ensuring we are in the context of a lambda's call operator
7611  // we can fix the bug (we only need to check whether we need to capture
7612  // if we are within a lambda's body); but per the comments in that
7613  // PR, a proper fix would entail :
7614  // "Alternative suggestion:
7615  // - Add to Sema an integer holding the smallest (outermost) scope
7616  // index that we are *lexically* within, and save/restore/set to
7617  // FunctionScopes.size() in InstantiatingTemplate's
7618  // constructor/destructor.
7619  // - Teach the handful of places that iterate over FunctionScopes to
7620  // stop at the outermost enclosing lexical scope."
7621  DeclContext *DC = CurContext;
7622  while (DC && isa<CapturedDecl>(DC))
7623  DC = DC->getParent();
7624  const bool IsInLambdaDeclContext = isLambdaCallOperator(DC);
7625  if (IsInLambdaDeclContext && CurrentLSI &&
7626  CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
7628  *this);
7629  return MaybeCreateExprWithCleanups(FullExpr);
7630 }
7631 
7633  if (!FullStmt) return StmtError();
7634 
7635  return MaybeCreateStmtWithCleanups(FullStmt);
7636 }
7637 
7640  CXXScopeSpec &SS,
7641  const DeclarationNameInfo &TargetNameInfo) {
7642  DeclarationName TargetName = TargetNameInfo.getName();
7643  if (!TargetName)
7644  return IER_DoesNotExist;
7645 
7646  // If the name itself is dependent, then the result is dependent.
7647  if (TargetName.isDependentName())
7648  return IER_Dependent;
7649 
7650  // Do the redeclaration lookup in the current scope.
7651  LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
7653  LookupParsedName(R, S, &SS);
7654  R.suppressDiagnostics();
7655 
7656  switch (R.getResultKind()) {
7657  case LookupResult::Found:
7661  return IER_Exists;
7662 
7664  return IER_DoesNotExist;
7665 
7667  return IER_Dependent;
7668  }
7669 
7670  llvm_unreachable("Invalid LookupResult Kind!");
7671 }
7672 
7675  bool IsIfExists, CXXScopeSpec &SS,
7676  UnqualifiedId &Name) {
7677  DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
7678 
7679  // Check for an unexpanded parameter pack.
7680  auto UPPC = IsIfExists ? UPPC_IfExists : UPPC_IfNotExists;
7681  if (DiagnoseUnexpandedParameterPack(SS, UPPC) ||
7682  DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC))
7683  return IER_Error;
7684 
7685  return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
7686 }
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
Function pointer conversion (C++17 4.13)
Definition: Overload.h:65
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Definition: Overload.h:290
Defines the clang::ASTContext interface.
VariadicCallType
Definition: Sema.h:9293
CanThrowResult canThrow(const Expr *E)
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:161
QualType getCurrentThisType()
Try to retrieve the type of the &#39;this&#39; pointer.
This is the scope of a C++ try statement.
Definition: Scope.h:100
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:565
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:552
void MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt)
Definition: SemaInternal.h:70
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true)
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:49
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Definition: Overload.h:271
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2367
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E)
SourceRange getCorrectionRange() const
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1800
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2283
QualType getPointeeType() const
Definition: Type.h:2296
CanQualType VoidPtrTy
Definition: ASTContext.h:1012
Stores the type being destroyed by a pseudo-destructor expression.
Definition: ExprCXX.h:2146
A (possibly-)qualified type.
Definition: Type.h:653
ASTConsumer & Consumer
Definition: Sema.h:317
bool isBlockPointerType() const
Definition: Type.h:5950
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
Simple class containing the result of Sema::CorrectTypo.
void addThisCapture(bool isNested, SourceLocation Loc, Expr *Cpy, bool ByCopy)
Definition: ScopeInfo.h:965
static bool IsSpecialDiscardedValue(Expr *E)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2061
base_class_range bases()
Definition: DeclCXX.h:773
bool isArrayType() const
Definition: Type.h:5991
bool isMemberPointerType() const
Definition: Type.h:5973
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2483
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id)
void getPotentialVariableCapture(unsigned Idx, VarDecl *&VD, Expr *&E) const
Definition: ScopeInfo.cpp:232
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type, bool NRVO)
Create the initialization entity for an exception object.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:968
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2148
bool isMemberDataPointerType() const
Definition: Type.h:5984
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn&#39;t alre...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2994
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:260
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
Definition: Sema.h:9746
QualType CXXThisTypeOverride
When non-NULL, the C++ &#39;this&#39; expression is allowed despite the current context not being a non-stati...
Definition: Sema.h:5036
bool isArithmeticType() const
Definition: Type.cpp:1908
Stmt - This represents one statement.
Definition: Stmt.h:66
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:938
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:39
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
FullExprArg MakeFullExpr(Expr *Arg)
Definition: Sema.h:3648
Provides information about an attempted template argument deduction, whose success or failure was des...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
Microsoft __if_not_exists.
Definition: Sema.h:6540
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
Vector conversions.
Definition: Overload.h:79
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1893
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:472
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:815
ActionResult< Expr * > ExprResult
Definition: Ownership.h:251
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:72
bool isRecordType() const
Definition: Type.h:6015
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:430
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1880
static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Try to find a common type for two according to C++0x 5.16p5.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1427
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Definition: SemaExpr.cpp:6245
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isVariadic() const
Definition: Type.h:3615
ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
bool isVirtual() const
Definition: DeclCXX.h:2009
bool isExtVectorType() const
Definition: Type.h:6031
AssignConvertType
AssignConvertType - All of the &#39;assignment&#39; semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9353
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Microsoft __if_exists.
Definition: Sema.h:6537
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
StringRef P
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1665
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5891
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
Definition: SemaExpr.cpp:15871
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
Definition: Decl.h:2648
The base class of the type hierarchy.
Definition: Type.h:1351
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:46
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:169
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1124
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2558
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)
Check if the current lambda has any potential captures that must be captured by any of its enclosing ...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:395
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2423
Ambiguous candidates found.
Definition: Overload.h:43
QualType withConst() const
Definition: Type.h:818
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST...
Definition: Sema.h:9417
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
A container of type source information.
Definition: Decl.h:86
static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5629
QualType getLogicalOperationType() const
The result type of logical operations, &#39;<&#39;, &#39;>&#39;, &#39;!=&#39;, etc.
Definition: ASTContext.h:1736
capture_const_range captures() const
Definition: DeclCXX.h:1200
Conversions between compatible types in C99.
Definition: Overload.h:77
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2605
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
Definition: ExprCXX.cpp:675
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
const Expr * getAnyInitializer() const
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
Definition: Decl.h:1202
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2717
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:13861
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
Definition: ScopeInfo.h:918
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2597
size_t param_size() const
Definition: Decl.h:2183
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:2028
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
Definition: Type.cpp:2117
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7493
An identifier, stored as an IdentifierInfo*.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1840
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10640
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
bool isStructureType() const
Definition: Type.cpp:403
bool hasPotentialThisCapture() const
Definition: ScopeInfo.h:869
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
IfExistsResult
Describes the result of an "if-exists" condition check.
Definition: Sema.h:4450
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
Definition: Sema.h:516
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:255
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
QualType getReturnType() const
Definition: Decl.h:2207
DiagnosticsEngine & Diags
Definition: Sema.h:318
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo *> FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
unsigned getNumParams() const
Definition: Type.h:3489
bool isEnumeralType() const
Definition: Type.h:6019
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3426
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
Definition: SemaInit.cpp:3139
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2128
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
Definition: Type.h:3387
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD)
Retrieve the message suffix that should be added to a diagnostic complaining about the given function...
Definition: SemaExpr.cpp:304
CUDAFunctionPreference
Definition: Sema.h:10007
static bool hasNewExtendedAlignment(Sema &S, QualType AllocType)
Determine whether a type has new-extended alignment.
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:911
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:422
bool isAmbiguous() const
Definition: Lookup.h:304
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
A namespace, stored as a NamespaceDecl*.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:276
bool isInvalidDecl() const
Definition: DeclBase.h:546
static InitializationKind CreateDirectList(SourceLocation InitLoc)
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:274
bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
Definition: SemaExpr.cpp:14517
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:985
static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, QualType allocType)
Determine whether a given type is a class for which &#39;delete[]&#39; would call a member &#39;operator delete[]...
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isUnset() const
Definition: Ownership.h:160
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
Definition: Type.cpp:2276
The collection of all-type qualifiers we support.
Definition: Type.h:152
Information about a template-id annotation token.
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6047
bool isXValue() const
Definition: Expr.h:251
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1880
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:96
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
Definition: SemaExpr.cpp:6881
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:311
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:962
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
Boolean conversions (C++ 4.12)
Definition: Overload.h:76
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3388
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3373
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:59
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:4894
Step
Definition: OpenMPClause.h:141
bool isConst() const
Definition: DeclCXX.h:2006
Represents a class type in Objective C.
Definition: Type.h:5184
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
void DropFirstTypeObject()
Definition: DeclSpec.h:2165
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7393
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:422
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1182
LineState State
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:508
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
Definition: LangOptions.h:198
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3844
A C-style cast.
Definition: Sema.h:9233
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
Definition: ASTContext.h:1903
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
The current expression is potentially evaluated at run time, which means that code may be generated t...
Identity conversion (no conversion)
Definition: Overload.h:61
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with &#39;::operator new(size_t)&#39; is g...
Definition: TargetInfo.h:384
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:772
bool isAbstractType(SourceLocation Loc, QualType T)
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:245
bool hasAutoTypeSpec() const
Definition: DeclSpec.h:519
Floating point conversions (C++ 4.8)
Definition: Overload.h:71
bool isReferenceType() const
Definition: Type.h:5954
CXXRecordDecl * getStdBadAlloc() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1389
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
The fast qualifier mask.
Definition: Type.h:198
static const TST TST_error
Definition: DeclSpec.h:307
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:391
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse &#39;nullptr&#39;.
LookupResultKind getResultKind() const
Definition: Lookup.h:324
Expr * getSubExpr()
Definition: Expr.h:2761
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
Definition: SemaExprCXX.cpp:83
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:171
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:417
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:13722
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:5872
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:41
A user-defined literal name, e.g., operator "" _i.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:92
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:107
bool isInvalidType() const
Definition: DeclSpec.h:2412
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
bool getProducesResult() const
Definition: Type.h:3127
DeclClass * getAsSingle() const
Definition: Lookup.h:510
Floating point promotions (C++ 4.6)
Definition: Overload.h:68
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
bool isGLValue() const
Definition: Expr.h:252
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:943
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2703
Describes an C or C++ initializer list.
Definition: Expr.h:3872
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:638
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:70
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:910
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
Definition: SemaExpr.cpp:52
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1615
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1932
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:522
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
Represents the results of name lookup.
Definition: Lookup.h:32
PtrTy get() const
Definition: Ownership.h:162
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1307
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
Definition: SemaExpr.cpp:6219
Microsoft throw(...) extension.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, bool &DerivedToBase, bool &ObjCConversion, bool &ObjCLifetimeConversion)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
Succeeded, but refers to a deleted function.
Definition: Overload.h:44
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
Ref_Compatible - The two types are reference-compatible.
Definition: Sema.h:9607
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2166
ArrayTypeInfo Arr
Definition: DeclSpec.h:1493
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of &#39;this&#39; is actually available in the current context, if it is a potentially ev...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2144
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:14989
StmtResult StmtError()
Definition: Ownership.h:268
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1113
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2760
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2985
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5788
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:316
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
Definition: Overload.h:152
QualType getExceptionObjectType(QualType T) const
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
const Type * getClass() const
Definition: Type.h:2536
enum clang::DeclaratorChunk::@198 Kind
bool isRValueReferenceType() const
Definition: Type.h:5962
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9229
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition: Sema.h:812
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1152
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Definition: ASTLambda.h:71
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6530
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1875
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
New-expression has a C++98 paren-delimited initializer.
Definition: ExprCXX.h:1897
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:1006
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.h:3610
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5232
Qualification conversions (C++ 4.4)
Definition: Overload.h:66
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, bool UseGlobal, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete)
FindAllocationFunctions - Finds the overloads of operator new and delete that are appropriate for the...
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition: Type.cpp:100
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2710
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
Definition: SemaStmt.cpp:629
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1196
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:90
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1215
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1580
Preprocessor & PP
Definition: Sema.h:315
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
static FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage)
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:748
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:626
bool isScalarType() const
Definition: Type.h:6204
An ordinary object is located at an address in memory.
Definition: Specifiers.h:123
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
The number of conversion kinds.
Definition: Overload.h:90
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1458
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:7422
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2305
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
Definition: SemaExpr.cpp:5747
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5419
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
Definition: Overload.h:156
bool getNoReturn() const
Definition: Type.h:3126
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1296
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2720
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
Integral promotions (C++ 4.5)
Definition: Overload.h:67
const LangOptions & LangOpts
Definition: Sema.h:314
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1881
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
This object can be modified without requiring retains or releases.
Definition: Type.h:173
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
Represents the this expression in C++.
Definition: ExprCXX.h:945
C-only conversion between pointers with incompatible types.
Definition: Overload.h:88
New-expression has no initializer as written.
Definition: ExprCXX.h:1894
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1536
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
SourceLocation LAngleLoc
The location of the &#39;<&#39; before the template argument list.
bool isArrayForm() const
Definition: ExprCXX.h:2112
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:7431
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1735
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
Definition: SemaInit.cpp:3150
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
Definition: SemaInit.cpp:6511
bool isHalfType() const
Definition: Type.h:6175
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:216
bool hasAttr() const
Definition: DeclBase.h:535
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3269
An error occurred.
Definition: Sema.h:4462
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2197
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:595
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
A functional-style cast.
Definition: Sema.h:9235
static NamedDecl * getDeclFromExpr(Expr *E)
Definition: SemaExpr.cpp:11498
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3172
Transparent Union Conversions.
Definition: Overload.h:83
Retains information about a captured region.
Definition: ScopeInfo.h:697
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:158
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1718
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:540
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType...
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition: Type.h:6163
Defines a function that returns the minimum OS versions supporting C++17&#39;s aligned allocation functio...
SourceLocation PotentialThisCaptureLocation
Definition: ScopeInfo.h:817
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
ExprResult CheckConditionVariable(VarDecl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
Check the use of the given variable as a C++ condition in an if, while, do-while, or switch statement...
TST getTypeSpecType() const
Definition: DeclSpec.h:477
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:2942
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:133
unsigned hasStatic
True if this dimension included the &#39;static&#39; keyword.
Definition: DeclSpec.h:1182
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:190
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1802
CXXMethodDecl * CallOperator
The lambda&#39;s compiler-generated operator().
Definition: ScopeInfo.h:745
QualType getElementType() const
Definition: Type.h:2236
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
Definition: Decl.cpp:4200
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2487
Expr - This represents one expression.
Definition: Expr.h:106
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
Definition: ExprCXX.cpp:1419
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:104
static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From)
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2574
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:51
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:315
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
const FunctionProtoType * T
unsigned getIntWidth() const
getIntWidth/Align - Return the size of &#39;signed int&#39; and &#39;unsigned int&#39; for this target, in bits.
Definition: TargetInfo.h:346
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition: Type.cpp:3785
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T)
DeclContext * getEntity() const
Definition: Scope.h:319
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Definition: Lexer.cpp:1267
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:280
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6368
bool isObjCRetainableType() const
Definition: Type.cpp:3824
Inits[]
Definition: OpenMPClause.h:140
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4851
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
New-expression has a C++11 list-initializer.
Definition: ExprCXX.h:1900
static CXXUnresolvedConstructExpr * Create(const ASTContext &C, TypeSourceInfo *Type, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc)
Definition: ExprCXX.cpp:1092
static UsualDeallocFnInfo resolveDeallocationOverload(Sema &S, LookupResult &R, bool WantSize, bool WantAlign, llvm::SmallVectorImpl< UsualDeallocFnInfo > *BestFns=nullptr)
Select the correct "usual" deallocation function to use from a selection of deallocation functions (e...
const CXXScopeSpec * getSS() const
Definition: SemaInternal.h:219
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1973
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
Zero constant to queue.
Definition: Overload.h:86
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Defines the clang::Preprocessor interface.
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:809
bool isNullPtrType() const
Definition: Type.h:6182
bool IsVariableAConstantExpression(VarDecl *Var, ASTContext &Context)
Definition: SemaInternal.h:44
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:13517
#define bool
Definition: stdbool.h:31
bool isFileContext() const
Definition: DeclBase.h:1401
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:212
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:288
DeclContext * getDeclContext()
Definition: DeclBase.h:425
Overload resolution succeeded.
Definition: Overload.h:41
bool isAnyComplexType() const
Definition: Type.h:6023
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
Definition: SemaExpr.cpp:13269
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:15943
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7394
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
Floating-integral conversions (C++ 4.9)
Definition: Overload.h:73
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:992
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:13788
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2331
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:702
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1800
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1289
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, QualType RhsT, SourceLocation KeyLoc)
QualType getType() const
Definition: Expr.h:128
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.cpp:1594
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:537
SourceLocation Loc
Loc - The place where this type was defined.
Definition: DeclSpec.h:1130
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:426
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl *> &VBases, llvm::SetVector< CXXRecordDecl *> &PublicSubobjectsSeen, bool ParentIsPublic)
A boolean condition, from &#39;if&#39;, &#39;while&#39;, &#39;for&#39;, or &#39;do&#39;.
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:903
QualType getRecordType(const RecordDecl *Decl) const
ConditionKind
Definition: Sema.h:9748
bool isInvalid() const
Definition: Ownership.h:158
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1717
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1333
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2037
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
Definition: SemaExprCXX.cpp:49
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1041
void CleanupVarDeclMarking()
Definition: SemaExpr.cpp:14806
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4361
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6263
The symbol exists.
Definition: Sema.h:4452
ValueDecl * getDecl()
Definition: Expr.h:1041
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ &#39;delete&#39; expression.
bool isUsable() const
Definition: Ownership.h:159
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2682
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2007
bool isUnionType() const
Definition: Type.cpp:432
const Expr * getSubExpr() const
Definition: ExprCXX.h:1219
void removeLocalCVRQualifiers(unsigned Mask)
Definition: Type.h:5824
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1396
bool hasEmptyCollections() const
Are the empty collection symbols available?
Definition: ObjCRuntime.h:330
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:296
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5751
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:5244
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:122
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:412
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:3150
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
Definition: SemaExpr.cpp:3489
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5777
RecordDecl * getDecl() const
Definition: Type.h:3986
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr *> Args)
Diagnose an potentially-invalid initialization sequence.
Definition: SemaInit.cpp:7520
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void addAttr(Attr *A)
Definition: DeclBase.h:484
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
Definition: SemaCUDA.cpp:212
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
Expr * getArgument()
Definition: ExprCXX.h:2125
QualType getWideCharType() const
Return the type of wide characters.
Definition: ASTContext.h:1516
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
CanThrowResult
Possible results from evaluation of a noexcept expression.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, unsigned ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
CanQualType OverloadTy
Definition: ASTContext.h:1013
There is no lifetime qualification on this type.
Definition: Type.h:169
ExprResult ActOnDecltypeExpression(Expr *E)
Process the expression contained within a decltype.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:868
Integral conversions (C++ 4.7)
Definition: Overload.h:70
Complex promotions (Clang extension)
Definition: Overload.h:69
#define false
Definition: stdbool.h:33
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor...
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:180
Kind
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
Definition: ExprCXX.cpp:753
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:387
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
LookupInObjCMethod - The parser has read a name in, and Sema has detected that we&#39;re currently inside...
Definition: SemaExpr.cpp:2346
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:191
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:624
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
Definition: Sema.h:816
ASTContext & getASTContext() const
Definition: Sema.h:1200
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
Definition: TargetInfo.h:995
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1376
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3276
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4002
static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
Create the initialization entity for a lambda capture.
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
Definition: SemaExpr.cpp:5732
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5834
static void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc, bool IsDelete, Sema &S)
Represents a C++ temporary.
Definition: ExprCXX.h:1164
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1874
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:742
CastKind getCastKind() const
Definition: Expr.h:2757
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2210
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, bool Overaligned, DeclarationName Name)
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1842
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
Definition: SemaInit.cpp:8449
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
A vector splat from an arithmetic type.
Definition: Overload.h:80
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:121
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2134
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1722
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
const LookupResult & getLookupResult() const
Definition: SemaInternal.h:216
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
Definition: ExprCXX.cpp:1058
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:530
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1304
CanQualType FloatTy
Definition: ASTContext.h:1007
void setDestructor(const CXXDestructorDecl *Dtor)
Definition: ExprCXX.h:1177
Objective-C ARC writeback conversion.
Definition: Overload.h:84
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2190
bool CheckObjCARCUnavailableWeakConversion(QualType castType, QualType ExprType)
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:54
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates=nullptr, Expr *AlignArg=nullptr)
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
CanQualType VoidTy
Definition: ASTContext.h:996
bool isArray() const
Definition: ExprCXX.h:1947
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Describes the kind of initialization being performed, along with location information for tokens rela...
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
static void getUnambiguousPublicSubobjects(CXXRecordDecl *RD, llvm::SmallVectorImpl< CXXRecordDecl *> &Objects)
Look up any declaration with any name.
Definition: Sema.h:3034
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
Definition: SemaExpr.cpp:7872
bool isMemberFunctionPointerType() const
Definition: Type.h:5977
bool isAnyPointerType() const
Definition: Type.h:5946
bool isObjCObjectPointerType() const
Definition: Type.h:6039
bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
Pointer conversions (C++ 4.10)
Definition: Overload.h:74
const TypoExprState & getTypoExprState(TypoExpr *TE) const
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
Definition: Overload.h:734
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, Expr *ArraySize, SourceRange DirectInitRange, Expr *Initializer)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2822
static bool VariableCanNeverBeAConstantExpression(VarDecl *Var, ASTContext &Context)
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1096
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:249
Requests that all candidates be shown.
Definition: Overload.h:50
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1829
No entity found met the criteria.
Definition: Lookup.h:36
VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
TypeClass getTypeClass() const
Definition: Type.h:1613
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1909
The name is a dependent name, so the results will differ from one instantiation to the next...
Definition: Sema.h:4459
An expression trait intrinsic.
Definition: ExprCXX.h:2493
EnumDecl * getDecl() const
Definition: Type.h:4009
Derived-to-base (C++ [over.best.ics])
Definition: Overload.h:78
bool isVectorType() const
Definition: Type.h:6027
Complex-real conversions (C99 6.3.1.7)
Definition: Overload.h:81
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1310
Assigning into this object requires a lifetime extension.
Definition: Type.h:186
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3488
static Expr * captureThis(Sema &S, ASTContext &Context, RecordDecl *RD, QualType ThisTy, SourceLocation Loc, const bool ByCopy)
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:117
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:724
Constant expression in a noptr-new-declarator.
Definition: Sema.h:2579
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ &#39;new&#39; expression.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT, SourceLocation Loc, QualType ArgTy)
Check the completeness of a type in a unary type trait.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2214
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
A POD class for pairing a NamedDecl* with an access specifier.
AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair FoundDecl, bool Diagnose=true)
Checks access to an overloaded operator new or delete.
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists), where Base is an expression of class type and Member is the name of the member we&#39;re trying to find.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition: Type.h:6143
The scope of a struct/union/class definition.
Definition: Scope.h:64
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1876
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array&#39;s size can require, which limits the maximu...
Definition: Type.cpp:135
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
Definition: SemaExpr.cpp:15002
Represents a template argument.
Definition: TemplateBase.h:51
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:8377
static const TST TST_decltype_auto
Definition: DeclSpec.h:298
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
This file provides some common utility functions for processing Lambdas.
DeclAccessPair FoundCopyConstructor
Definition: Overload.h:213
static bool isInvalid(LocType Loc, bool *Invalid)
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2455
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
Definition: Sema.h:2589
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1121
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1686
ExtInfo getExtInfo() const
Definition: Type.h:3212
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, ArrayRef< QualType > Params)
DeclareGlobalAllocationFunction - Declares a single implicit global allocation function if it doesn&#39;t...
CanQualType NullPtrTy
Definition: ASTContext.h:1012
ExprResult BuildExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2071
static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style, Expr *Init)
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
static void noteOperatorArrows(Sema &S, ArrayRef< FunctionDecl *> OperatorArrows)
Note a set of &#39;operator->&#39; functions that were used for a member access.
static const TST TST_decltype
Definition: DeclSpec.h:297
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:224
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1216
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:466
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
Optional< unsigned > getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo *> FunctionScopes, VarDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
Definition: SemaLambda.cpp:173
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:204
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:116
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
Conversions allowed in C, but not C++.
Definition: Overload.h:87
A constant boolean condition from &#39;if constexpr&#39;.
Array-to-pointer conversion (C++ 4.2)
Definition: Overload.h:63
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:2162
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
Definition: Sema.h:882
DeclarationName - The name of a declaration.
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
Definition: Overload.h:263
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:979
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
bool isBooleanType() const
Definition: Type.h:6232
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
Definition: SemaExpr.cpp:5994
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:731
Requests that only viable candidates be shown.
Definition: Overload.h:53
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2502
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:1859
IdentifierResolver IdResolver
Definition: Sema.h:800
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1962
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:520
CXXThisScopeRAII(Sema &S, Decl *ContextDecl, unsigned CXXThisTypeQuals, bool Enabled=true)
Introduce a new scope where &#39;this&#39; may be allowed (when enabled), using the given declaration (which ...
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1307
bool exprNeedsCleanups() const
Definition: CleanupInfo.h:25
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition: Decl.cpp:3808
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr *> Args, SmallVectorImpl< Expr *> &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
Definition: SemaExpr.cpp:4800
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1382
bool hasCVRQualifiers() const
Definition: Type.h:290
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2552
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:567
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
Definition: Overload.h:285
Decl * getCalleeDecl()
Definition: Expr.cpp:1220
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression&#39;s result is syntactically ignored, perform any conversions that are required.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3600
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
Pointer to a block type.
Definition: Type.h:2385
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:45
static void DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, const MismatchingNewDeleteDetector &Detector)
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
bool isIncompleteArrayType() const
Definition: Type.h:5999
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
Definition: Expr.h:2608
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
bool cleanupsHaveSideEffects() const
Definition: CleanupInfo.h:27
Complex values, per C99 6.2.5p11.
Definition: Type.h:2223
CanQualType UnknownAnyTy
Definition: ASTContext.h:1013
The lookup is a reference to this name that is not for the purpose of redeclaring the name...
Definition: Sema.h:3042
CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
Definition: SemaCUDA.cpp:161
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Definition: SemaExpr.cpp:13704
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2172
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6191
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1074
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2011
CanQualType DependentTy
Definition: ASTContext.h:1013
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
bool isFunctionType() const
Definition: Type.h:5938
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1326
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Definition: SemaType.cpp:7906
CanQualType BoundMemberTy
Definition: ASTContext.h:1013
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1006
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:12164
The template argument is a type.
Definition: TemplateBase.h:60
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Block Pointer conversions.
Definition: Overload.h:82
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1425
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:265
The "class" keyword.
Definition: Type.h:4697
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2676
void setExprNeedsCleanups(bool SideEffects)
Definition: CleanupInfo.h:29
SmallVector< BlockDecl *, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
Definition: Sema.h:521
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
unsigned getNumPotentialVariableCaptures() const
Definition: ScopeInfo.h:933
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:126
const Expr * Replacement
Definition: AttributeList.h:59
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2479
Capture & getCXXThisCapture()
Retrieve the capture of C++ &#39;this&#39;, if it has been captured.
Definition: ScopeInfo.h:636
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1668
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
Condition in a constexpr if statement.
Definition: Sema.h:2580
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3368
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1986
static void getUuidAttrOfType(Sema &SemaRef, QualType QT, llvm::SmallSetVector< const UuidAttr *, 1 > &UuidAttrs)
Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to a single GUID...
bool isClassType() const
Definition: Type.cpp:397
static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, SourceLocation QuestionLoc, bool &HaveConversion, QualType &ToType)
Try to convert a type to another according to C++11 5.16p3.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
An implicit conversion.
Definition: Sema.h:9231
QualType withCVRQualifiers(unsigned CVR) const
Definition: Type.h:838
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
EnumDecl * getStdAlignValT() const
A template argument list.
Definition: DeclTemplate.h:210
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
bool isLValueReferenceType() const
Definition: Type.h:5958
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
Definition: SemaCast.cpp:2678
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
CXXRecordDecl * getNamingClass() const
Returns the &#39;naming class&#39; for this lookup, i.e.
Definition: Lookup.h:406
Reading or writing from this object requires a barrier call.
Definition: Type.h:183
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3371
An integral condition for a &#39;switch&#39; statement.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
QualType getParamType(unsigned i) const
Definition: Type.h:3491
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
Function-to-pointer (C++ 4.3)
Definition: Overload.h:64
bool Failed() const
Determine whether the initialization sequence is invalid.
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:989
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2387
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD)
Determine whether the given function is a non-placement deallocation function.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5798
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9355
bool isValid() const
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr *> &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc)
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6169
static bool hasAnyTypeDependentArguments(ArrayRef< Expr *> Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
Definition: Expr.cpp:2745
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3342
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Definition: ExprCXX.cpp:748
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Definition: DeclSpec.h:1190
static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op, Sema &Self, SourceLocation KeyLoc, ASTContext &C, bool(CXXRecordDecl::*HasTrivial)() const, bool(CXXRecordDecl::*HasNonTrivial)() const, bool(CXXMethodDecl::*IsDesiredOp)() const)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5745
bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R)
Checks that a type is suitable as the allocated type in a new-expression.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1841
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
bool isCXXThisCaptured() const
Determine whether the C++ &#39;this&#39; is captured.
Definition: ScopeInfo.h:633
bool isRValue() const
Definition: Expr.h:250
Declaration of a class template.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3779
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:127
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2143
SourceManager & getSourceManager() const
Definition: Sema.h:1198
iterator end() const
Definition: Lookup.h:339
A template-id, e.g., f<int>.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1227
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion)
type checking for vector binary operators.
Definition: SemaExpr.cpp:8331
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
ExprResult ExprError()
Definition: Ownership.h:267
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:245
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
static OpaquePtr make(QualType P)
Definition: Ownership.h:54
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
Definition: Type.h:5906
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1858
static bool canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, QualType DestructedType)
Check if it&#39;s ok to try and recover dot pseudo destructor calls on pointer objects.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:734
bool isUnion() const
Definition: Decl.h:3165
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4493
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
bool isPointerType() const
Definition: Type.h:5942
Zero constant to event (OpenCL1.2 6.12.10)
Definition: Overload.h:85
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
Definition: Type.h:374
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:146
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:64
No viable function found.
Definition: Overload.h:42
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:586
QualType getType() const
Definition: Decl.h:638
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:111
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:342
bool isFloatingType() const
Definition: Type.cpp:1877
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:316
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we&#39;re implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
Definition: Sema.cpp:424
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
Definition: SemaExpr.cpp:15352
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:530
Expr * getRepAsExpr() const
Definition: DeclSpec.h:493
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:455
CanQualType BoolTy
Definition: ASTContext.h:997
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression&#39;s return type is complete.
Definition: SemaExpr.cpp:15225
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:856
No keyword precedes the qualified type name.
Definition: Type.h:4726
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1428
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:12058
iterator begin() const
Definition: Lookup.h:338
bool isInterfaceType() const
Definition: Type.cpp:413
Pointer-to-member conversions (C++ 4.11)
Definition: Overload.h:75
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:609
Describes an entity that is being initialized.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:3631
unsigned NumArgs
NumArgs - The number of template arguments.
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr *> Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
Definition: SemaExpr.cpp:316
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:1878
The global specifier &#39;::&#39;. There is no stored value.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2910
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:277
ctor_range ctors() const
Definition: DeclCXX.h:835
static OpaquePtr getFromOpaquePtr(void *P)
Definition: Ownership.h:85
SourceLocation getBegin() const
AssignmentAction
Definition: Sema.h:2466
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
void WillReplaceSpecifier(bool ForceReplacement)
No in-class initializer.
Definition: Specifiers.h:227
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2618
This scope corresponds to an Objective-C method body.
Definition: Scope.h:94
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3393
The symbol does not exist.
Definition: Sema.h:4455
Declaration of a template function.
Definition: DeclTemplate.h:967
void clear()
Clears out any current state.
Definition: Lookup.h:557
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:416
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, bool IsCompAssign=false)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6...
Definition: SemaExpr.cpp:1219
QualType getPointeeType() const
Definition: Type.h:2522
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:4979
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:3108
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1223
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form, which contains extra information on the evaluated value of the initializer.
Definition: Decl.cpp:2195
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2434
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
const FormatStyle & Style
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:7462
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1070
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
Structure used to store a statement, the constant value to which it was evaluated (if any)...
Definition: Decl.h:776
A RAII object to temporarily push a declaration context.
Definition: Sema.h:705
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
Definition: Type.h:5916
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:141