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