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