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