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