clang  3.7.0
SemaExpr.cpp
Go to the documentation of this file.
1 //===--- SemaExpr.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 // This file implements semantic analysis for expressions.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "TreeTransform.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/ASTLambda.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/TypeLoc.h"
31 #include "clang/Basic/TargetInfo.h"
33 #include "clang/Lex/Preprocessor.h"
35 #include "clang/Sema/DeclSpec.h"
37 #include "clang/Sema/Designator.h"
39 #include "clang/Sema/Lookup.h"
41 #include "clang/Sema/Scope.h"
42 #include "clang/Sema/ScopeInfo.h"
44 #include "clang/Sema/Template.h"
45 #include "llvm/Support/ConvertUTF.h"
46 using namespace clang;
47 using namespace sema;
48 
49 /// \brief Determine whether the use of this declaration is valid, without
50 /// emitting diagnostics.
52  // See if this is an auto-typed variable whose initializer we are parsing.
53  if (ParsingInitForAutoVars.count(D))
54  return false;
55 
56  // See if this is a deleted function.
57  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
58  if (FD->isDeleted())
59  return false;
60 
61  // If the function has a deduced return type, and we can't deduce it,
62  // then we can't use it either.
63  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
64  DeduceReturnType(FD, SourceLocation(), /*Diagnose*/ false))
65  return false;
66  }
67 
68  // See if this function is unavailable.
69  if (D->getAvailability() == AR_Unavailable &&
70  cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)
71  return false;
72 
73  return true;
74 }
75 
77  // Warn if this is used but marked unused.
78  if (D->hasAttr<UnusedAttr>()) {
79  const Decl *DC = cast_or_null<Decl>(S.getCurObjCLexicalContext());
80  if (DC && !DC->hasAttr<UnusedAttr>())
81  S.Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName();
82  }
83 }
84 
86  const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
87  if (!OMD)
88  return false;
89  const ObjCInterfaceDecl *OID = OMD->getClassInterface();
90  if (!OID)
91  return false;
92 
93  for (const ObjCCategoryDecl *Cat : OID->visible_categories())
94  if (ObjCMethodDecl *CatMeth =
95  Cat->getMethod(OMD->getSelector(), OMD->isInstanceMethod()))
96  if (!CatMeth->hasAttr<AvailabilityAttr>())
97  return true;
98  return false;
99 }
100 
101 static AvailabilityResult
103  const ObjCInterfaceDecl *UnknownObjCClass,
104  bool ObjCPropertyAccess) {
105  // See if this declaration is unavailable or deprecated.
106  std::string Message;
108 
109  // For typedefs, if the typedef declaration appears available look
110  // to the underlying type to see if it is more restrictive.
111  while (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
112  if (Result == AR_Available) {
113  if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
114  D = TT->getDecl();
115  Result = D->getAvailability(&Message);
116  continue;
117  }
118  }
119  break;
120  }
121 
122  // Forward class declarations get their attributes from their definition.
123  if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
124  if (IDecl->getDefinition()) {
125  D = IDecl->getDefinition();
126  Result = D->getAvailability(&Message);
127  }
128  }
129 
130  if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D))
131  if (Result == AR_Available) {
132  const DeclContext *DC = ECD->getDeclContext();
133  if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC))
134  Result = TheEnumDecl->getAvailability(&Message);
135  }
136 
137  const ObjCPropertyDecl *ObjCPDecl = nullptr;
138  if (Result == AR_Deprecated || Result == AR_Unavailable ||
140  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
141  if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
142  AvailabilityResult PDeclResult = PD->getAvailability(nullptr);
143  if (PDeclResult == Result)
144  ObjCPDecl = PD;
145  }
146  }
147  }
148 
149  switch (Result) {
150  case AR_Available:
151  break;
152 
153  case AR_Deprecated:
156  D, Message, Loc, UnknownObjCClass, ObjCPDecl,
157  ObjCPropertyAccess);
158  break;
159 
160  case AR_NotYetIntroduced: {
161  // Don't do this for enums, they can't be redeclared.
162  if (isa<EnumConstantDecl>(D) || isa<EnumDecl>(D))
163  break;
164 
165  bool Warn = !D->getAttr<AvailabilityAttr>()->isInherited();
166  // Objective-C method declarations in categories are not modelled as
167  // redeclarations, so manually look for a redeclaration in a category
168  // if necessary.
170  Warn = false;
171  // In general, D will point to the most recent redeclaration. However,
172  // for `@class A;` decls, this isn't true -- manually go through the
173  // redecl chain in that case.
174  if (Warn && isa<ObjCInterfaceDecl>(D))
175  for (Decl *Redecl = D->getMostRecentDecl(); Redecl && Warn;
176  Redecl = Redecl->getPreviousDecl())
177  if (!Redecl->hasAttr<AvailabilityAttr>() ||
178  Redecl->getAttr<AvailabilityAttr>()->isInherited())
179  Warn = false;
180 
181  if (Warn)
182  S.EmitAvailabilityWarning(Sema::AD_Partial, D, Message, Loc,
183  UnknownObjCClass, ObjCPDecl,
184  ObjCPropertyAccess);
185  break;
186  }
187 
188  case AR_Unavailable:
191  D, Message, Loc, UnknownObjCClass, ObjCPDecl,
192  ObjCPropertyAccess);
193  break;
194 
195  }
196  return Result;
197 }
198 
199 /// \brief Emit a note explaining that this function is deleted.
201  assert(Decl->isDeleted());
202 
203  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl);
204 
205  if (Method && Method->isDeleted() && Method->isDefaulted()) {
206  // If the method was explicitly defaulted, point at that declaration.
207  if (!Method->isImplicit())
208  Diag(Decl->getLocation(), diag::note_implicitly_deleted);
209 
210  // Try to diagnose why this special member function was implicitly
211  // deleted. This might fail, if that reason no longer applies.
212  CXXSpecialMember CSM = getSpecialMember(Method);
213  if (CSM != CXXInvalid)
214  ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true);
215 
216  return;
217  }
218 
219  if (CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Decl)) {
220  if (CXXConstructorDecl *BaseCD =
221  const_cast<CXXConstructorDecl*>(CD->getInheritedConstructor())) {
222  Diag(Decl->getLocation(), diag::note_inherited_deleted_here);
223  if (BaseCD->isDeleted()) {
224  NoteDeletedFunction(BaseCD);
225  } else {
226  // FIXME: An explanation of why exactly it can't be inherited
227  // would be nice.
228  Diag(BaseCD->getLocation(), diag::note_cannot_inherit);
229  }
230  return;
231  }
232  }
233 
234  Diag(Decl->getLocation(), diag::note_availability_specified_here)
235  << Decl << true;
236 }
237 
238 /// \brief Determine whether a FunctionDecl was ever declared with an
239 /// explicit storage class.
241  for (auto I : D->redecls()) {
242  if (I->getStorageClass() != SC_None)
243  return true;
244  }
245  return false;
246 }
247 
248 /// \brief Check whether we're in an extern inline function and referring to a
249 /// variable or function with internal linkage (C11 6.7.4p3).
250 ///
251 /// This is only a warning because we used to silently accept this code, but
252 /// in many cases it will not behave correctly. This is not enabled in C++ mode
253 /// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
254 /// and so while there may still be user mistakes, most of the time we can't
255 /// prove that there are errors.
257  const NamedDecl *D,
258  SourceLocation Loc) {
259  // This is disabled under C++; there are too many ways for this to fire in
260  // contexts where the warning is a false positive, or where it is technically
261  // correct but benign.
262  if (S.getLangOpts().CPlusPlus)
263  return;
264 
265  // Check if this is an inlined function or method.
267  if (!Current)
268  return;
269  if (!Current->isInlined())
270  return;
271  if (!Current->isExternallyVisible())
272  return;
273 
274  // Check if the decl has internal linkage.
275  if (D->getFormalLinkage() != InternalLinkage)
276  return;
277 
278  // Downgrade from ExtWarn to Extension if
279  // (1) the supposedly external inline function is in the main file,
280  // and probably won't be included anywhere else.
281  // (2) the thing we're referencing is a pure function.
282  // (3) the thing we're referencing is another inline function.
283  // This last can give us false negatives, but it's better than warning on
284  // wrappers for simple C library functions.
285  const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D);
286  bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc);
287  if (!DowngradeWarning && UsedFn)
288  DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>();
289 
290  S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
291  : diag::ext_internal_in_extern_inline)
292  << /*IsVar=*/!UsedFn << D;
293 
295 
296  S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at)
297  << D;
298 }
299 
301  const FunctionDecl *First = Cur->getFirstDecl();
302 
303  // Suggest "static" on the function, if possible.
304  if (!hasAnyExplicitStorageClass(First)) {
305  SourceLocation DeclBegin = First->getSourceRange().getBegin();
306  Diag(DeclBegin, diag::note_convert_inline_to_static)
307  << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
308  }
309 }
310 
311 /// \brief Determine whether the use of this declaration is valid, and
312 /// emit any corresponding diagnostics.
313 ///
314 /// This routine diagnoses various problems with referencing
315 /// declarations that can occur when using a declaration. For example,
316 /// it might warn if a deprecated or unavailable declaration is being
317 /// used, or produce an error (and return true) if a C++0x deleted
318 /// function is being used.
319 ///
320 /// \returns true if there was an error (this declaration cannot be
321 /// referenced), false otherwise.
322 ///
324  const ObjCInterfaceDecl *UnknownObjCClass,
325  bool ObjCPropertyAccess) {
326  if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
327  // If there were any diagnostics suppressed by template argument deduction,
328  // emit them now.
329  SuppressedDiagnosticsMap::iterator
330  Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
331  if (Pos != SuppressedDiagnostics.end()) {
332  SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second;
333  for (unsigned I = 0, N = Suppressed.size(); I != N; ++I)
334  Diag(Suppressed[I].first, Suppressed[I].second);
335 
336  // Clear out the list of suppressed diagnostics, so that we don't emit
337  // them again for this specialization. However, we don't obsolete this
338  // entry from the table, because we want to avoid ever emitting these
339  // diagnostics again.
340  Suppressed.clear();
341  }
342 
343  // C++ [basic.start.main]p3:
344  // The function 'main' shall not be used within a program.
345  if (cast<FunctionDecl>(D)->isMain())
346  Diag(Loc, diag::ext_main_used);
347  }
348 
349  // See if this is an auto-typed variable whose initializer we are parsing.
350  if (ParsingInitForAutoVars.count(D)) {
351  Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
352  << D->getDeclName();
353  return true;
354  }
355 
356  // See if this is a deleted function.
357  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
358  if (FD->isDeleted()) {
359  Diag(Loc, diag::err_deleted_function_use);
360  NoteDeletedFunction(FD);
361  return true;
362  }
363 
364  // If the function has a deduced return type, and we can't deduce it,
365  // then we can't use it either.
366  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
367  DeduceReturnType(FD, Loc))
368  return true;
369  }
370  DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass,
371  ObjCPropertyAccess);
372 
373  DiagnoseUnusedOfDecl(*this, D, Loc);
374 
376 
377  return false;
378 }
379 
380 /// \brief Retrieve the message suffix that should be added to a
381 /// diagnostic complaining about the given function being deleted or
382 /// unavailable.
384  std::string Message;
385  if (FD->getAvailability(&Message))
386  return ": " + Message;
387 
388  return std::string();
389 }
390 
391 /// DiagnoseSentinelCalls - This routine checks whether a call or
392 /// message-send is to a declaration with the sentinel attribute, and
393 /// if so, it checks that the requirements of the sentinel are
394 /// satisfied.
396  ArrayRef<Expr *> Args) {
397  const SentinelAttr *attr = D->getAttr<SentinelAttr>();
398  if (!attr)
399  return;
400 
401  // The number of formal parameters of the declaration.
402  unsigned numFormalParams;
403 
404  // The kind of declaration. This is also an index into a %select in
405  // the diagnostic.
406  enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType;
407 
408  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
409  numFormalParams = MD->param_size();
410  calleeType = CT_Method;
411  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
412  numFormalParams = FD->param_size();
413  calleeType = CT_Function;
414  } else if (isa<VarDecl>(D)) {
415  QualType type = cast<ValueDecl>(D)->getType();
416  const FunctionType *fn = nullptr;
417  if (const PointerType *ptr = type->getAs<PointerType>()) {
418  fn = ptr->getPointeeType()->getAs<FunctionType>();
419  if (!fn) return;
420  calleeType = CT_Function;
421  } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) {
422  fn = ptr->getPointeeType()->castAs<FunctionType>();
423  calleeType = CT_Block;
424  } else {
425  return;
426  }
427 
428  if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) {
429  numFormalParams = proto->getNumParams();
430  } else {
431  numFormalParams = 0;
432  }
433  } else {
434  return;
435  }
436 
437  // "nullPos" is the number of formal parameters at the end which
438  // effectively count as part of the variadic arguments. This is
439  // useful if you would prefer to not have *any* formal parameters,
440  // but the language forces you to have at least one.
441  unsigned nullPos = attr->getNullPos();
442  assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel");
443  numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos);
444 
445  // The number of arguments which should follow the sentinel.
446  unsigned numArgsAfterSentinel = attr->getSentinel();
447 
448  // If there aren't enough arguments for all the formal parameters,
449  // the sentinel, and the args after the sentinel, complain.
450  if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {
451  Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
452  Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
453  return;
454  }
455 
456  // Otherwise, find the sentinel expression.
457  Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
458  if (!sentinelExpr) return;
459  if (sentinelExpr->isValueDependent()) return;
460  if (Context.isSentinelNullExpr(sentinelExpr)) return;
461 
462  // Pick a reasonable string to insert. Optimistically use 'nil', 'nullptr',
463  // or 'NULL' if those are actually defined in the context. Only use
464  // 'nil' for ObjC methods, where it's much more likely that the
465  // variadic arguments form a list of object pointers.
466  SourceLocation MissingNilLoc
467  = PP.getLocForEndOfToken(sentinelExpr->getLocEnd());
468  std::string NullValue;
469  if (calleeType == CT_Method && PP.isMacroDefined("nil"))
470  NullValue = "nil";
471  else if (getLangOpts().CPlusPlus11)
472  NullValue = "nullptr";
473  else if (PP.isMacroDefined("NULL"))
474  NullValue = "NULL";
475  else
476  NullValue = "(void*) 0";
477 
478  if (MissingNilLoc.isInvalid())
479  Diag(Loc, diag::warn_missing_sentinel) << int(calleeType);
480  else
481  Diag(MissingNilLoc, diag::warn_missing_sentinel)
482  << int(calleeType)
483  << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue);
484  Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
485 }
486 
488  return E ? E->getSourceRange() : SourceRange();
489 }
490 
491 //===----------------------------------------------------------------------===//
492 // Standard Promotions and Conversions
493 //===----------------------------------------------------------------------===//
494 
495 /// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
497  // Handle any placeholder expressions which made it here.
498  if (E->getType()->isPlaceholderType()) {
499  ExprResult result = CheckPlaceholderExpr(E);
500  if (result.isInvalid()) return ExprError();
501  E = result.get();
502  }
503 
504  QualType Ty = E->getType();
505  assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
506 
507  if (Ty->isFunctionType()) {
508  // If we are here, we are not calling a function but taking
509  // its address (which is not allowed in OpenCL v1.0 s6.8.a.3).
510  if (getLangOpts().OpenCL) {
511  Diag(E->getExprLoc(), diag::err_opencl_taking_function_address);
512  return ExprError();
513  }
514  E = ImpCastExprToType(E, Context.getPointerType(Ty),
516  } else if (Ty->isArrayType()) {
517  // In C90 mode, arrays only promote to pointers if the array expression is
518  // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
519  // type 'array of type' is converted to an expression that has type 'pointer
520  // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
521  // that has type 'array of type' ...". The relevant change is "an lvalue"
522  // (C90) to "an expression" (C99).
523  //
524  // C++ 4.2p1:
525  // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
526  // T" can be converted to an rvalue of type "pointer to T".
527  //
528  if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue())
529  E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
530  CK_ArrayToPointerDecay).get();
531  }
532  return E;
533 }
534 
536  // Check to see if we are dereferencing a null pointer. If so,
537  // and if not volatile-qualified, this is undefined behavior that the
538  // optimizer will delete, so warn about it. People sometimes try to use this
539  // to get a deterministic trap and are surprised by clang's behavior. This
540  // only handles the pattern "*null", which is a very syntactic check.
541  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
542  if (UO->getOpcode() == UO_Deref &&
543  UO->getSubExpr()->IgnoreParenCasts()->
544  isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) &&
545  !UO->getType().isVolatileQualified()) {
546  S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
547  S.PDiag(diag::warn_indirection_through_null)
548  << UO->getSubExpr()->getSourceRange());
549  S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
550  S.PDiag(diag::note_indirection_through_null));
551  }
552 }
553 
554 static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
555  SourceLocation AssignLoc,
556  const Expr* RHS) {
557  const ObjCIvarDecl *IV = OIRE->getDecl();
558  if (!IV)
559  return;
560 
561  DeclarationName MemberName = IV->getDeclName();
562  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
563  if (!Member || !Member->isStr("isa"))
564  return;
565 
566  const Expr *Base = OIRE->getBase();
567  QualType BaseType = Base->getType();
568  if (OIRE->isArrow())
569  BaseType = BaseType->getPointeeType();
570  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())
571  if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
572  ObjCInterfaceDecl *ClassDeclared = nullptr;
573  ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
574  if (!ClassDeclared->getSuperClass()
575  && (*ClassDeclared->ivar_begin()) == IV) {
576  if (RHS) {
577  NamedDecl *ObjectSetClass =
579  &S.Context.Idents.get("object_setClass"),
581  if (ObjectSetClass) {
582  SourceLocation RHSLocEnd = S.PP.getLocForEndOfToken(RHS->getLocEnd());
583  S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign) <<
584  FixItHint::CreateInsertion(OIRE->getLocStart(), "object_setClass(") <<
586  AssignLoc), ",") <<
587  FixItHint::CreateInsertion(RHSLocEnd, ")");
588  }
589  else
590  S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
591  } else {
592  NamedDecl *ObjectGetClass =
594  &S.Context.Idents.get("object_getClass"),
596  if (ObjectGetClass)
597  S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use) <<
598  FixItHint::CreateInsertion(OIRE->getLocStart(), "object_getClass(") <<
600  SourceRange(OIRE->getOpLoc(),
601  OIRE->getLocEnd()), ")");
602  else
603  S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use);
604  }
605  S.Diag(IV->getLocation(), diag::note_ivar_decl);
606  }
607  }
608 }
609 
611  // Handle any placeholder expressions which made it here.
612  if (E->getType()->isPlaceholderType()) {
613  ExprResult result = CheckPlaceholderExpr(E);
614  if (result.isInvalid()) return ExprError();
615  E = result.get();
616  }
617 
618  // C++ [conv.lval]p1:
619  // A glvalue of a non-function, non-array type T can be
620  // converted to a prvalue.
621  if (!E->isGLValue()) return E;
622 
623  QualType T = E->getType();
624  assert(!T.isNull() && "r-value conversion on typeless expression?");
625 
626  // We don't want to throw lvalue-to-rvalue casts on top of
627  // expressions of certain types in C++.
628  if (getLangOpts().CPlusPlus &&
629  (E->getType() == Context.OverloadTy ||
630  T->isDependentType() ||
631  T->isRecordType()))
632  return E;
633 
634  // The C standard is actually really unclear on this point, and
635  // DR106 tells us what the result should be but not why. It's
636  // generally best to say that void types just doesn't undergo
637  // lvalue-to-rvalue at all. Note that expressions of unqualified
638  // 'void' type are never l-values, but qualified void can be.
639  if (T->isVoidType())
640  return E;
641 
642  // OpenCL usually rejects direct accesses to values of 'half' type.
643  if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16 &&
644  T->isHalfType()) {
645  Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
646  << 0 << T;
647  return ExprError();
648  }
649 
651  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
652  NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
653  &Context.Idents.get("object_getClass"),
654  SourceLocation(), LookupOrdinaryName);
655  if (ObjectGetClass)
656  Diag(E->getExprLoc(), diag::warn_objc_isa_use) <<
657  FixItHint::CreateInsertion(OISA->getLocStart(), "object_getClass(") <<
659  SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
660  else
661  Diag(E->getExprLoc(), diag::warn_objc_isa_use);
662  }
663  else if (const ObjCIvarRefExpr *OIRE =
664  dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
665  DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);
666 
667  // C++ [conv.lval]p1:
668  // [...] If T is a non-class type, the type of the prvalue is the
669  // cv-unqualified version of T. Otherwise, the type of the
670  // rvalue is T.
671  //
672  // C99 6.3.2.1p2:
673  // If the lvalue has qualified type, the value has the unqualified
674  // version of the type of the lvalue; otherwise, the value has the
675  // type of the lvalue.
676  if (T.hasQualifiers())
677  T = T.getUnqualifiedType();
678 
679  UpdateMarkingForLValueToRValue(E);
680 
681  // Loading a __weak object implicitly retains the value, so we need a cleanup to
682  // balance that.
683  if (getLangOpts().ObjCAutoRefCount &&
685  ExprNeedsCleanups = true;
686 
688  nullptr, VK_RValue);
689 
690  // C11 6.3.2.1p2:
691  // ... if the lvalue has atomic type, the value has the non-atomic version
692  // of the type of the lvalue ...
693  if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
694  T = Atomic->getValueType().getUnqualifiedType();
696  nullptr, VK_RValue);
697  }
698 
699  return Res;
700 }
701 
703  ExprResult Res = DefaultFunctionArrayConversion(E);
704  if (Res.isInvalid())
705  return ExprError();
706  Res = DefaultLvalueConversion(Res.get());
707  if (Res.isInvalid())
708  return ExprError();
709  return Res;
710 }
711 
712 /// CallExprUnaryConversions - a special case of an unary conversion
713 /// performed on a function designator of a call expression.
715  QualType Ty = E->getType();
716  ExprResult Res = E;
717  // Only do implicit cast for a function type, but not for a pointer
718  // to function type.
719  if (Ty->isFunctionType()) {
720  Res = ImpCastExprToType(E, Context.getPointerType(Ty),
722  if (Res.isInvalid())
723  return ExprError();
724  }
725  Res = DefaultLvalueConversion(Res.get());
726  if (Res.isInvalid())
727  return ExprError();
728  return Res.get();
729 }
730 
731 /// UsualUnaryConversions - Performs various conversions that are common to most
732 /// operators (C99 6.3). The conversions of array and function types are
733 /// sometimes suppressed. For example, the array->pointer conversion doesn't
734 /// apply if the array is an argument to the sizeof or address (&) operators.
735 /// In these instances, this routine should *not* be called.
737  // First, convert to an r-value.
738  ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
739  if (Res.isInvalid())
740  return ExprError();
741  E = Res.get();
742 
743  QualType Ty = E->getType();
744  assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
745 
746  // Half FP have to be promoted to float unless it is natively supported
747  if (Ty->isHalfType() && !getLangOpts().NativeHalfType)
748  return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast);
749 
750  // Try to perform integral promotions if the object has a theoretically
751  // promotable type.
753  // C99 6.3.1.1p2:
754  //
755  // The following may be used in an expression wherever an int or
756  // unsigned int may be used:
757  // - an object or expression with an integer type whose integer
758  // conversion rank is less than or equal to the rank of int
759  // and unsigned int.
760  // - A bit-field of type _Bool, int, signed int, or unsigned int.
761  //
762  // If an int can represent all values of the original type, the
763  // value is converted to an int; otherwise, it is converted to an
764  // unsigned int. These are called the integer promotions. All
765  // other types are unchanged by the integer promotions.
766 
768  if (!PTy.isNull()) {
769  E = ImpCastExprToType(E, PTy, CK_IntegralCast).get();
770  return E;
771  }
772  if (Ty->isPromotableIntegerType()) {
774  E = ImpCastExprToType(E, PT, CK_IntegralCast).get();
775  return E;
776  }
777  }
778  return E;
779 }
780 
781 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
782 /// do not have a prototype. Arguments that have type float or __fp16
783 /// are promoted to double. All other argument types are converted by
784 /// UsualUnaryConversions().
786  QualType Ty = E->getType();
787  assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
788 
789  ExprResult Res = UsualUnaryConversions(E);
790  if (Res.isInvalid())
791  return ExprError();
792  E = Res.get();
793 
794  // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to
795  // double.
796  const BuiltinType *BTy = Ty->getAs<BuiltinType>();
797  if (BTy && (BTy->getKind() == BuiltinType::Half ||
798  BTy->getKind() == BuiltinType::Float))
799  E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
800 
801  // C++ performs lvalue-to-rvalue conversion as a default argument
802  // promotion, even on class types, but note:
803  // C++11 [conv.lval]p2:
804  // When an lvalue-to-rvalue conversion occurs in an unevaluated
805  // operand or a subexpression thereof the value contained in the
806  // referenced object is not accessed. Otherwise, if the glvalue
807  // has a class type, the conversion copy-initializes a temporary
808  // of type T from the glvalue and the result of the conversion
809  // is a prvalue for the temporary.
810  // FIXME: add some way to gate this entire thing for correctness in
811  // potentially potentially evaluated contexts.
812  if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
813  ExprResult Temp = PerformCopyInitialization(
815  E->getExprLoc(), E);
816  if (Temp.isInvalid())
817  return ExprError();
818  E = Temp.get();
819  }
820 
821  return E;
822 }
823 
824 /// Determine the degree of POD-ness for an expression.
825 /// Incomplete types are considered POD, since this check can be performed
826 /// when we're in an unevaluated context.
828  if (Ty->isIncompleteType()) {
829  // C++11 [expr.call]p7:
830  // After these conversions, if the argument does not have arithmetic,
831  // enumeration, pointer, pointer to member, or class type, the program
832  // is ill-formed.
833  //
834  // Since we've already performed array-to-pointer and function-to-pointer
835  // decay, the only such type in C++ is cv void. This also handles
836  // initializer lists as variadic arguments.
837  if (Ty->isVoidType())
838  return VAK_Invalid;
839 
840  if (Ty->isObjCObjectType())
841  return VAK_Invalid;
842  return VAK_Valid;
843  }
844 
845  if (Ty.isCXX98PODType(Context))
846  return VAK_Valid;
847 
848  // C++11 [expr.call]p7:
849  // Passing a potentially-evaluated argument of class type (Clause 9)
850  // having a non-trivial copy constructor, a non-trivial move constructor,
851  // or a non-trivial destructor, with no corresponding parameter,
852  // is conditionally-supported with implementation-defined semantics.
853  if (getLangOpts().CPlusPlus11 && !Ty->isDependentType())
854  if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl())
855  if (!Record->hasNonTrivialCopyConstructor() &&
856  !Record->hasNonTrivialMoveConstructor() &&
857  !Record->hasNonTrivialDestructor())
858  return VAK_ValidInCXX11;
859 
860  if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType())
861  return VAK_Valid;
862 
863  if (Ty->isObjCObjectType())
864  return VAK_Invalid;
865 
866  if (getLangOpts().MSVCCompat)
867  return VAK_MSVCUndefined;
868 
869  // FIXME: In C++11, these cases are conditionally-supported, meaning we're
870  // permitted to reject them. We should consider doing so.
871  return VAK_Undefined;
872 }
873 
875  // Don't allow one to pass an Objective-C interface to a vararg.
876  const QualType &Ty = E->getType();
877  VarArgKind VAK = isValidVarArgType(Ty);
878 
879  // Complain about passing non-POD types through varargs.
880  switch (VAK) {
881  case VAK_ValidInCXX11:
882  DiagRuntimeBehavior(
883  E->getLocStart(), nullptr,
884  PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg)
885  << Ty << CT);
886  // Fall through.
887  case VAK_Valid:
888  if (Ty->isRecordType()) {
889  // This is unlikely to be what the user intended. If the class has a
890  // 'c_str' member function, the user probably meant to call that.
891  DiagRuntimeBehavior(E->getLocStart(), nullptr,
892  PDiag(diag::warn_pass_class_arg_to_vararg)
893  << Ty << CT << hasCStrMethod(E) << ".c_str()");
894  }
895  break;
896 
897  case VAK_Undefined:
898  case VAK_MSVCUndefined:
899  DiagRuntimeBehavior(
900  E->getLocStart(), nullptr,
901  PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
902  << getLangOpts().CPlusPlus11 << Ty << CT);
903  break;
904 
905  case VAK_Invalid:
906  if (Ty->isObjCObjectType())
907  DiagRuntimeBehavior(
908  E->getLocStart(), nullptr,
909  PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
910  << Ty << CT);
911  else
912  Diag(E->getLocStart(), diag::err_cannot_pass_to_vararg)
913  << isa<InitListExpr>(E) << Ty << CT;
914  break;
915  }
916 }
917 
918 /// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
919 /// will create a trap if the resulting type is not a POD type.
921  FunctionDecl *FDecl) {
922  if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
923  // Strip the unbridged-cast placeholder expression off, if applicable.
924  if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
925  (CT == VariadicMethod ||
926  (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) {
927  E = stripARCUnbridgedCast(E);
928 
929  // Otherwise, do normal placeholder checking.
930  } else {
931  ExprResult ExprRes = CheckPlaceholderExpr(E);
932  if (ExprRes.isInvalid())
933  return ExprError();
934  E = ExprRes.get();
935  }
936  }
937 
938  ExprResult ExprRes = DefaultArgumentPromotion(E);
939  if (ExprRes.isInvalid())
940  return ExprError();
941  E = ExprRes.get();
942 
943  // Diagnostics regarding non-POD argument types are
944  // emitted along with format string checking in Sema::CheckFunctionCall().
945  if (isValidVarArgType(E->getType()) == VAK_Undefined) {
946  // Turn this into a trap.
947  CXXScopeSpec SS;
948  SourceLocation TemplateKWLoc;
949  UnqualifiedId Name;
950  Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"),
951  E->getLocStart());
952  ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc,
953  Name, true, false);
954  if (TrapFn.isInvalid())
955  return ExprError();
956 
957  ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(),
958  E->getLocStart(), None,
959  E->getLocEnd());
960  if (Call.isInvalid())
961  return ExprError();
962 
963  ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma,
964  Call.get(), E);
965  if (Comma.isInvalid())
966  return ExprError();
967  return Comma.get();
968  }
969 
970  if (!getLangOpts().CPlusPlus &&
971  RequireCompleteType(E->getExprLoc(), E->getType(),
972  diag::err_call_incomplete_argument))
973  return ExprError();
974 
975  return E;
976 }
977 
978 /// \brief Converts an integer to complex float type. Helper function of
979 /// UsualArithmeticConversions()
980 ///
981 /// \return false if the integer expression is an integer type and is
982 /// successfully converted to the complex type.
984  ExprResult &ComplexExpr,
985  QualType IntTy,
986  QualType ComplexTy,
987  bool SkipCast) {
988  if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
989  if (SkipCast) return false;
990  if (IntTy->isIntegerType()) {
991  QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType();
992  IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
993  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
995  } else {
996  assert(IntTy->isComplexIntegerType());
997  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
999  }
1000  return false;
1001 }
1002 
1003 /// \brief Handle arithmetic conversion with complex types. Helper function of
1004 /// UsualArithmeticConversions()
1006  ExprResult &RHS, QualType LHSType,
1007  QualType RHSType,
1008  bool IsCompAssign) {
1009  // if we have an integer operand, the result is the complex type.
1010  if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
1011  /*skipCast*/false))
1012  return LHSType;
1013  if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
1014  /*skipCast*/IsCompAssign))
1015  return RHSType;
1016 
1017  // This handles complex/complex, complex/float, or float/complex.
1018  // When both operands are complex, the shorter operand is converted to the
1019  // type of the longer, and that is the type of the result. This corresponds
1020  // to what is done when combining two real floating-point operands.
1021  // The fun begins when size promotion occur across type domains.
1022  // From H&S 6.3.4: When one operand is complex and the other is a real
1023  // floating-point type, the less precise type is converted, within it's
1024  // real or complex domain, to the precision of the other type. For example,
1025  // when combining a "long double" with a "double _Complex", the
1026  // "double _Complex" is promoted to "long double _Complex".
1027 
1028  // Compute the rank of the two types, regardless of whether they are complex.
1029  int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
1030 
1031  auto *LHSComplexType = dyn_cast<ComplexType>(LHSType);
1032  auto *RHSComplexType = dyn_cast<ComplexType>(RHSType);
1033  QualType LHSElementType =
1034  LHSComplexType ? LHSComplexType->getElementType() : LHSType;
1035  QualType RHSElementType =
1036  RHSComplexType ? RHSComplexType->getElementType() : RHSType;
1037 
1038  QualType ResultType = S.Context.getComplexType(LHSElementType);
1039  if (Order < 0) {
1040  // Promote the precision of the LHS if not an assignment.
1041  ResultType = S.Context.getComplexType(RHSElementType);
1042  if (!IsCompAssign) {
1043  if (LHSComplexType)
1044  LHS =
1045  S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast);
1046  else
1047  LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast);
1048  }
1049  } else if (Order > 0) {
1050  // Promote the precision of the RHS.
1051  if (RHSComplexType)
1052  RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast);
1053  else
1054  RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast);
1055  }
1056  return ResultType;
1057 }
1058 
1059 /// \brief Hande arithmetic conversion from integer to float. Helper function
1060 /// of UsualArithmeticConversions()
1062  ExprResult &IntExpr,
1063  QualType FloatTy, QualType IntTy,
1064  bool ConvertFloat, bool ConvertInt) {
1065  if (IntTy->isIntegerType()) {
1066  if (ConvertInt)
1067  // Convert intExpr to the lhs floating point type.
1068  IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy,
1070  return FloatTy;
1071  }
1072 
1073  // Convert both sides to the appropriate complex float.
1074  assert(IntTy->isComplexIntegerType());
1075  QualType result = S.Context.getComplexType(FloatTy);
1076 
1077  // _Complex int -> _Complex float
1078  if (ConvertInt)
1079  IntExpr = S.ImpCastExprToType(IntExpr.get(), result,
1081 
1082  // float -> _Complex float
1083  if (ConvertFloat)
1084  FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
1086 
1087  return result;
1088 }
1089 
1090 /// \brief Handle arithmethic conversion with floating point types. Helper
1091 /// function of UsualArithmeticConversions()
1093  ExprResult &RHS, QualType LHSType,
1094  QualType RHSType, bool IsCompAssign) {
1095  bool LHSFloat = LHSType->isRealFloatingType();
1096  bool RHSFloat = RHSType->isRealFloatingType();
1097 
1098  // If we have two real floating types, convert the smaller operand
1099  // to the bigger result.
1100  if (LHSFloat && RHSFloat) {
1101  int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
1102  if (order > 0) {
1103  RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast);
1104  return LHSType;
1105  }
1106 
1107  assert(order < 0 && "illegal float comparison");
1108  if (!IsCompAssign)
1109  LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
1110  return RHSType;
1111  }
1112 
1113  if (LHSFloat) {
1114  // Half FP has to be promoted to float unless it is natively supported
1115  if (LHSType->isHalfType() && !S.getLangOpts().NativeHalfType)
1116  LHSType = S.Context.FloatTy;
1117 
1118  return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
1119  /*convertFloat=*/!IsCompAssign,
1120  /*convertInt=*/ true);
1121  }
1122  assert(RHSFloat);
1123  return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
1124  /*convertInt=*/ true,
1125  /*convertFloat=*/!IsCompAssign);
1126 }
1127 
1128 typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
1129 
1130 namespace {
1131 /// These helper callbacks are placed in an anonymous namespace to
1132 /// permit their use as function template parameters.
1133 ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
1134  return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1135 }
1136 
1137 ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
1138  return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
1140 }
1141 }
1142 
1143 /// \brief Handle integer arithmetic conversions. Helper function of
1144 /// UsualArithmeticConversions()
1145 template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1147  ExprResult &RHS, QualType LHSType,
1148  QualType RHSType, bool IsCompAssign) {
1149  // The rules for this case are in C99 6.3.1.8
1150  int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
1151  bool LHSSigned = LHSType->hasSignedIntegerRepresentation();
1152  bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
1153  if (LHSSigned == RHSSigned) {
1154  // Same signedness; use the higher-ranked type
1155  if (order >= 0) {
1156  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1157  return LHSType;
1158  } else if (!IsCompAssign)
1159  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1160  return RHSType;
1161  } else if (order != (LHSSigned ? 1 : -1)) {
1162  // The unsigned type has greater than or equal rank to the
1163  // signed type, so use the unsigned type
1164  if (RHSSigned) {
1165  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1166  return LHSType;
1167  } else if (!IsCompAssign)
1168  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1169  return RHSType;
1170  } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
1171  // The two types are different widths; if we are here, that
1172  // means the signed type is larger than the unsigned type, so
1173  // use the signed type.
1174  if (LHSSigned) {
1175  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1176  return LHSType;
1177  } else if (!IsCompAssign)
1178  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1179  return RHSType;
1180  } else {
1181  // The signed type is higher-ranked than the unsigned type,
1182  // but isn't actually any bigger (like unsigned int and long
1183  // on most 32-bit systems). Use the unsigned type corresponding
1184  // to the signed type.
1185  QualType result =
1186  S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
1187  RHS = (*doRHSCast)(S, RHS.get(), result);
1188  if (!IsCompAssign)
1189  LHS = (*doLHSCast)(S, LHS.get(), result);
1190  return result;
1191  }
1192 }
1193 
1194 /// \brief Handle conversions with GCC complex int extension. Helper function
1195 /// of UsualArithmeticConversions()
1197  ExprResult &RHS, QualType LHSType,
1198  QualType RHSType,
1199  bool IsCompAssign) {
1200  const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType();
1201  const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();
1202 
1203  if (LHSComplexInt && RHSComplexInt) {
1204  QualType LHSEltType = LHSComplexInt->getElementType();
1205  QualType RHSEltType = RHSComplexInt->getElementType();
1206  QualType ScalarType =
1207  handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1208  (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1209 
1210  return S.Context.getComplexType(ScalarType);
1211  }
1212 
1213  if (LHSComplexInt) {
1214  QualType LHSEltType = LHSComplexInt->getElementType();
1215  QualType ScalarType =
1216  handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1217  (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1218  QualType ComplexType = S.Context.getComplexType(ScalarType);
1219  RHS = S.ImpCastExprToType(RHS.get(), ComplexType,
1221 
1222  return ComplexType;
1223  }
1224 
1225  assert(RHSComplexInt);
1226 
1227  QualType RHSEltType = RHSComplexInt->getElementType();
1228  QualType ScalarType =
1229  handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1230  (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1231  QualType ComplexType = S.Context.getComplexType(ScalarType);
1232 
1233  if (!IsCompAssign)
1234  LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
1236  return ComplexType;
1237 }
1238 
1239 /// UsualArithmeticConversions - Performs various conversions that are common to
1240 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
1241 /// routine returns the first non-arithmetic type found. The client is
1242 /// responsible for emitting appropriate error diagnostics.
1244  bool IsCompAssign) {
1245  if (!IsCompAssign) {
1246  LHS = UsualUnaryConversions(LHS.get());
1247  if (LHS.isInvalid())
1248  return QualType();
1249  }
1250 
1251  RHS = UsualUnaryConversions(RHS.get());
1252  if (RHS.isInvalid())
1253  return QualType();
1254 
1255  // For conversion purposes, we ignore any qualifiers.
1256  // For example, "const float" and "float" are equivalent.
1257  QualType LHSType =
1258  Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
1259  QualType RHSType =
1260  Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
1261 
1262  // For conversion purposes, we ignore any atomic qualifier on the LHS.
1263  if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>())
1264  LHSType = AtomicLHS->getValueType();
1265 
1266  // If both types are identical, no conversion is needed.
1267  if (LHSType == RHSType)
1268  return LHSType;
1269 
1270  // If either side is a non-arithmetic type (e.g. a pointer), we are done.
1271  // The caller can deal with this (e.g. pointer + int).
1272  if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
1273  return QualType();
1274 
1275  // Apply unary and bitfield promotions to the LHS's type.
1276  QualType LHSUnpromotedType = LHSType;
1277  if (LHSType->isPromotableIntegerType())
1278  LHSType = Context.getPromotedIntegerType(LHSType);
1279  QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
1280  if (!LHSBitfieldPromoteTy.isNull())
1281  LHSType = LHSBitfieldPromoteTy;
1282  if (LHSType != LHSUnpromotedType && !IsCompAssign)
1283  LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
1284 
1285  // If both types are identical, no conversion is needed.
1286  if (LHSType == RHSType)
1287  return LHSType;
1288 
1289  // At this point, we have two different arithmetic types.
1290 
1291  // Handle complex types first (C99 6.3.1.8p1).
1292  if (LHSType->isComplexType() || RHSType->isComplexType())
1293  return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1294  IsCompAssign);
1295 
1296  // Now handle "real" floating types (i.e. float, double, long double).
1297  if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
1298  return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1299  IsCompAssign);
1300 
1301  // Handle GCC complex int extension.
1302  if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
1303  return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
1304  IsCompAssign);
1305 
1306  // Finally, we have two differing integer types.
1307  return handleIntegerConversion<doIntegralCast, doIntegralCast>
1308  (*this, LHS, RHS, LHSType, RHSType, IsCompAssign);
1309 }
1310 
1311 
1312 //===----------------------------------------------------------------------===//
1313 // Semantic Analysis for various Expression Types
1314 //===----------------------------------------------------------------------===//
1315 
1316 
1317 ExprResult
1319  SourceLocation DefaultLoc,
1320  SourceLocation RParenLoc,
1321  Expr *ControllingExpr,
1322  ArrayRef<ParsedType> ArgTypes,
1323  ArrayRef<Expr *> ArgExprs) {
1324  unsigned NumAssocs = ArgTypes.size();
1325  assert(NumAssocs == ArgExprs.size());
1326 
1327  TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
1328  for (unsigned i = 0; i < NumAssocs; ++i) {
1329  if (ArgTypes[i])
1330  (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
1331  else
1332  Types[i] = nullptr;
1333  }
1334 
1335  ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
1336  ControllingExpr,
1337  llvm::makeArrayRef(Types, NumAssocs),
1338  ArgExprs);
1339  delete [] Types;
1340  return ER;
1341 }
1342 
1343 ExprResult
1345  SourceLocation DefaultLoc,
1346  SourceLocation RParenLoc,
1347  Expr *ControllingExpr,
1349  ArrayRef<Expr *> Exprs) {
1350  unsigned NumAssocs = Types.size();
1351  assert(NumAssocs == Exprs.size());
1352  if (ControllingExpr->getType()->isPlaceholderType()) {
1353  ExprResult result = CheckPlaceholderExpr(ControllingExpr);
1354  if (result.isInvalid()) return ExprError();
1355  ControllingExpr = result.get();
1356  }
1357 
1358  // The controlling expression is an unevaluated operand, so side effects are
1359  // likely unintended.
1360  if (ActiveTemplateInstantiations.empty() &&
1361  ControllingExpr->HasSideEffects(Context, false))
1362  Diag(ControllingExpr->getExprLoc(),
1363  diag::warn_side_effects_unevaluated_context);
1364 
1365  bool TypeErrorFound = false,
1366  IsResultDependent = ControllingExpr->isTypeDependent(),
1367  ContainsUnexpandedParameterPack
1368  = ControllingExpr->containsUnexpandedParameterPack();
1369 
1370  for (unsigned i = 0; i < NumAssocs; ++i) {
1371  if (Exprs[i]->containsUnexpandedParameterPack())
1372  ContainsUnexpandedParameterPack = true;
1373 
1374  if (Types[i]) {
1375  if (Types[i]->getType()->containsUnexpandedParameterPack())
1376  ContainsUnexpandedParameterPack = true;
1377 
1378  if (Types[i]->getType()->isDependentType()) {
1379  IsResultDependent = true;
1380  } else {
1381  // C11 6.5.1.1p2 "The type name in a generic association shall specify a
1382  // complete object type other than a variably modified type."
1383  unsigned D = 0;
1384  if (Types[i]->getType()->isIncompleteType())
1385  D = diag::err_assoc_type_incomplete;
1386  else if (!Types[i]->getType()->isObjectType())
1387  D = diag::err_assoc_type_nonobject;
1388  else if (Types[i]->getType()->isVariablyModifiedType())
1389  D = diag::err_assoc_type_variably_modified;
1390 
1391  if (D != 0) {
1392  Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1393  << Types[i]->getTypeLoc().getSourceRange()
1394  << Types[i]->getType();
1395  TypeErrorFound = true;
1396  }
1397 
1398  // C11 6.5.1.1p2 "No two generic associations in the same generic
1399  // selection shall specify compatible types."
1400  for (unsigned j = i+1; j < NumAssocs; ++j)
1401  if (Types[j] && !Types[j]->getType()->isDependentType() &&
1402  Context.typesAreCompatible(Types[i]->getType(),
1403  Types[j]->getType())) {
1404  Diag(Types[j]->getTypeLoc().getBeginLoc(),
1405  diag::err_assoc_compatible_types)
1406  << Types[j]->getTypeLoc().getSourceRange()
1407  << Types[j]->getType()
1408  << Types[i]->getType();
1409  Diag(Types[i]->getTypeLoc().getBeginLoc(),
1410  diag::note_compat_assoc)
1411  << Types[i]->getTypeLoc().getSourceRange()
1412  << Types[i]->getType();
1413  TypeErrorFound = true;
1414  }
1415  }
1416  }
1417  }
1418  if (TypeErrorFound)
1419  return ExprError();
1420 
1421  // If we determined that the generic selection is result-dependent, don't
1422  // try to compute the result expression.
1423  if (IsResultDependent)
1424  return new (Context) GenericSelectionExpr(
1425  Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1426  ContainsUnexpandedParameterPack);
1427 
1428  SmallVector<unsigned, 1> CompatIndices;
1429  unsigned DefaultIndex = -1U;
1430  for (unsigned i = 0; i < NumAssocs; ++i) {
1431  if (!Types[i])
1432  DefaultIndex = i;
1433  else if (Context.typesAreCompatible(ControllingExpr->getType(),
1434  Types[i]->getType()))
1435  CompatIndices.push_back(i);
1436  }
1437 
1438  // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have
1439  // type compatible with at most one of the types named in its generic
1440  // association list."
1441  if (CompatIndices.size() > 1) {
1442  // We strip parens here because the controlling expression is typically
1443  // parenthesized in macro definitions.
1444  ControllingExpr = ControllingExpr->IgnoreParens();
1445  Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match)
1446  << ControllingExpr->getSourceRange() << ControllingExpr->getType()
1447  << (unsigned) CompatIndices.size();
1448  for (SmallVectorImpl<unsigned>::iterator I = CompatIndices.begin(),
1449  E = CompatIndices.end(); I != E; ++I) {
1450  Diag(Types[*I]->getTypeLoc().getBeginLoc(),
1451  diag::note_compat_assoc)
1452  << Types[*I]->getTypeLoc().getSourceRange()
1453  << Types[*I]->getType();
1454  }
1455  return ExprError();
1456  }
1457 
1458  // C11 6.5.1.1p2 "If a generic selection has no default generic association,
1459  // its controlling expression shall have type compatible with exactly one of
1460  // the types named in its generic association list."
1461  if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1462  // We strip parens here because the controlling expression is typically
1463  // parenthesized in macro definitions.
1464  ControllingExpr = ControllingExpr->IgnoreParens();
1465  Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match)
1466  << ControllingExpr->getSourceRange() << ControllingExpr->getType();
1467  return ExprError();
1468  }
1469 
1470  // C11 6.5.1.1p3 "If a generic selection has a generic association with a
1471  // type name that is compatible with the type of the controlling expression,
1472  // then the result expression of the generic selection is the expression
1473  // in that generic association. Otherwise, the result expression of the
1474  // generic selection is the expression in the default generic association."
1475  unsigned ResultIndex =
1476  CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1477 
1478  return new (Context) GenericSelectionExpr(
1479  Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1480  ContainsUnexpandedParameterPack, ResultIndex);
1481 }
1482 
1483 /// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the
1484 /// location of the token and the offset of the ud-suffix within it.
1486  unsigned Offset) {
1487  return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(),
1488  S.getLangOpts());
1489 }
1490 
1491 /// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1492 /// the corresponding cooked (non-raw) literal operator, and build a call to it.
1494  IdentifierInfo *UDSuffix,
1495  SourceLocation UDSuffixLoc,
1496  ArrayRef<Expr*> Args,
1497  SourceLocation LitEndLoc) {
1498  assert(Args.size() <= 2 && "too many arguments for literal operator");
1499 
1500  QualType ArgTy[2];
1501  for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1502  ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1503  if (ArgTy[ArgIdx]->isArrayType())
1504  ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]);
1505  }
1506 
1507  DeclarationName OpName =
1509  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1510  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1511 
1512  LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName);
1513  if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()),
1514  /*AllowRaw*/false, /*AllowTemplate*/false,
1515  /*AllowStringTemplate*/false) == Sema::LOLR_Error)
1516  return ExprError();
1517 
1518  return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc);
1519 }
1520 
1521 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
1522 /// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
1523 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1524 /// multiple tokens. However, the common case is that StringToks points to one
1525 /// string.
1526 ///
1527 ExprResult
1529  assert(!StringToks.empty() && "Must have at least one string!");
1530 
1531  StringLiteralParser Literal(StringToks, PP);
1532  if (Literal.hadError)
1533  return ExprError();
1534 
1535  SmallVector<SourceLocation, 4> StringTokLocs;
1536  for (unsigned i = 0; i != StringToks.size(); ++i)
1537  StringTokLocs.push_back(StringToks[i].getLocation());
1538 
1539  QualType CharTy = Context.CharTy;
1541  if (Literal.isWide()) {
1542  CharTy = Context.getWideCharType();
1543  Kind = StringLiteral::Wide;
1544  } else if (Literal.isUTF8()) {
1545  Kind = StringLiteral::UTF8;
1546  } else if (Literal.isUTF16()) {
1547  CharTy = Context.Char16Ty;
1548  Kind = StringLiteral::UTF16;
1549  } else if (Literal.isUTF32()) {
1550  CharTy = Context.Char32Ty;
1551  Kind = StringLiteral::UTF32;
1552  } else if (Literal.isPascal()) {
1553  CharTy = Context.UnsignedCharTy;
1554  }
1555 
1556  QualType CharTyConst = CharTy;
1557  // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
1558  if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
1559  CharTyConst.addConst();
1560 
1561  // Get an array type for the string, according to C99 6.4.5. This includes
1562  // the nul terminator character as well as the string length for pascal
1563  // strings.
1564  QualType StrTy = Context.getConstantArrayType(CharTyConst,
1565  llvm::APInt(32, Literal.GetNumStringChars()+1),
1566  ArrayType::Normal, 0);
1567 
1568  // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
1569  if (getLangOpts().OpenCL) {
1571  }
1572 
1573  // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
1574  StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(),
1575  Kind, Literal.Pascal, StrTy,
1576  &StringTokLocs[0],
1577  StringTokLocs.size());
1578  if (Literal.getUDSuffix().empty())
1579  return Lit;
1580 
1581  // We're building a user-defined literal.
1582  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
1583  SourceLocation UDSuffixLoc =
1584  getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
1585  Literal.getUDSuffixOffset());
1586 
1587  // Make sure we're allowed user-defined literals here.
1588  if (!UDLScope)
1589  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl));
1590 
1591  // C++11 [lex.ext]p5: The literal L is treated as a call of the form
1592  // operator "" X (str, len)
1593  QualType SizeType = Context.getSizeType();
1594 
1595  DeclarationName OpName =
1597  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1598  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1599 
1600  QualType ArgTy[] = {
1601  Context.getArrayDecayedType(StrTy), SizeType
1602  };
1603 
1604  LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
1605  switch (LookupLiteralOperator(UDLScope, R, ArgTy,
1606  /*AllowRaw*/false, /*AllowTemplate*/false,
1607  /*AllowStringTemplate*/true)) {
1608 
1609  case LOLR_Cooked: {
1610  llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
1611  IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
1612  StringTokLocs[0]);
1613  Expr *Args[] = { Lit, LenArg };
1614 
1615  return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
1616  }
1617 
1618  case LOLR_StringTemplate: {
1619  TemplateArgumentListInfo ExplicitArgs;
1620 
1621  unsigned CharBits = Context.getIntWidth(CharTy);
1622  bool CharIsUnsigned = CharTy->isUnsignedIntegerType();
1623  llvm::APSInt Value(CharBits, CharIsUnsigned);
1624 
1625  TemplateArgument TypeArg(CharTy);
1627  ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));
1628 
1629  for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) {
1630  Value = Lit->getCodeUnit(I);
1631  TemplateArgument Arg(Context, Value, CharTy);
1632  TemplateArgumentLocInfo ArgInfo;
1633  ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
1634  }
1635  return BuildLiteralOperatorCall(R, OpNameInfo, None, StringTokLocs.back(),
1636  &ExplicitArgs);
1637  }
1638  case LOLR_Raw:
1639  case LOLR_Template:
1640  llvm_unreachable("unexpected literal operator lookup result");
1641  case LOLR_Error:
1642  return ExprError();
1643  }
1644  llvm_unreachable("unexpected literal operator lookup result");
1645 }
1646 
1647 ExprResult
1649  SourceLocation Loc,
1650  const CXXScopeSpec *SS) {
1651  DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
1652  return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
1653 }
1654 
1655 /// BuildDeclRefExpr - Build an expression that references a
1656 /// declaration that does not require a closure capture.
1657 ExprResult
1659  const DeclarationNameInfo &NameInfo,
1660  const CXXScopeSpec *SS, NamedDecl *FoundD,
1661  const TemplateArgumentListInfo *TemplateArgs) {
1662  if (getLangOpts().CUDA)
1663  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
1664  if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) {
1665  if (CheckCUDATarget(Caller, Callee)) {
1666  Diag(NameInfo.getLoc(), diag::err_ref_bad_target)
1667  << IdentifyCUDATarget(Callee) << D->getIdentifier()
1668  << IdentifyCUDATarget(Caller);
1669  Diag(D->getLocation(), diag::note_previous_decl)
1670  << D->getIdentifier();
1671  return ExprError();
1672  }
1673  }
1674 
1675  bool RefersToCapturedVariable =
1676  isa<VarDecl>(D) &&
1677  NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc());
1678 
1679  DeclRefExpr *E;
1680  if (isa<VarTemplateSpecializationDecl>(D)) {
1682  cast<VarTemplateSpecializationDecl>(D);
1683 
1686  VarSpec->getTemplateKeywordLoc(), D,
1687  RefersToCapturedVariable, NameInfo.getLoc(), Ty, VK,
1688  FoundD, TemplateArgs);
1689  } else {
1690  assert(!TemplateArgs && "No template arguments for non-variable"
1691  " template specialization references");
1694  SourceLocation(), D, RefersToCapturedVariable,
1695  NameInfo, Ty, VK, FoundD);
1696  }
1697 
1698  MarkDeclRefReferenced(E);
1699 
1700  if (getLangOpts().ObjCARCWeak && isa<VarDecl>(D) &&
1702  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getLocStart()))
1703  recordUseOfEvaluatedWeak(E);
1704 
1705  // Just in case we're building an illegal pointer-to-member.
1706  FieldDecl *FD = dyn_cast<FieldDecl>(D);
1707  if (FD && FD->isBitField())
1708  E->setObjectKind(OK_BitField);
1709 
1710  return E;
1711 }
1712 
1713 /// Decomposes the given name into a DeclarationNameInfo, its location, and
1714 /// possibly a list of template arguments.
1715 ///
1716 /// If this produces template arguments, it is permitted to call
1717 /// DecomposeTemplateName.
1718 ///
1719 /// This actually loses a lot of source location information for
1720 /// non-standard name kinds; we should consider preserving that in
1721 /// some way.
1722 void
1724  TemplateArgumentListInfo &Buffer,
1725  DeclarationNameInfo &NameInfo,
1726  const TemplateArgumentListInfo *&TemplateArgs) {
1727  if (Id.getKind() == UnqualifiedId::IK_TemplateId) {
1728  Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
1729  Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
1730 
1731  ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(),
1732  Id.TemplateId->NumArgs);
1733  translateTemplateArguments(TemplateArgsPtr, Buffer);
1734 
1735  TemplateName TName = Id.TemplateId->Template.get();
1736  SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
1737  NameInfo = Context.getNameForTemplate(TName, TNameLoc);
1738  TemplateArgs = &Buffer;
1739  } else {
1740  NameInfo = GetNameFromUnqualifiedId(Id);
1741  TemplateArgs = nullptr;
1742  }
1743 }
1744 
1746  const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS,
1748  unsigned DiagnosticID, unsigned DiagnosticSuggestID) {
1749  DeclContext *Ctx =
1750  SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false);
1751  if (!TC) {
1752  // Emit a special diagnostic for failed member lookups.
1753  // FIXME: computing the declaration context might fail here (?)
1754  if (Ctx)
1755  SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
1756  << SS.getRange();
1757  else
1758  SemaRef.Diag(TypoLoc, DiagnosticID) << Typo;
1759  return;
1760  }
1761 
1762  std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts());
1763  bool DroppedSpecifier =
1764  TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr;
1765  unsigned NoteID =
1766  (TC.getCorrectionDecl() && isa<ImplicitParamDecl>(TC.getCorrectionDecl()))
1767  ? diag::note_implicit_param_decl
1768  : diag::note_previous_decl;
1769  if (!Ctx)
1770  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(DiagnosticSuggestID) << Typo,
1771  SemaRef.PDiag(NoteID));
1772  else
1773  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
1774  << Typo << Ctx << DroppedSpecifier
1775  << SS.getRange(),
1776  SemaRef.PDiag(NoteID));
1777 }
1778 
1779 /// Diagnose an empty lookup.
1780 ///
1781 /// \return false if new lookup candidates were found
1782 bool
1784  std::unique_ptr<CorrectionCandidateCallback> CCC,
1785  TemplateArgumentListInfo *ExplicitTemplateArgs,
1786  ArrayRef<Expr *> Args, TypoExpr **Out) {
1787  DeclarationName Name = R.getLookupName();
1788 
1789  unsigned diagnostic = diag::err_undeclared_var_use;
1790  unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
1794  diagnostic = diag::err_undeclared_use;
1795  diagnostic_suggest = diag::err_undeclared_use_suggest;
1796  }
1797 
1798  // If the original lookup was an unqualified lookup, fake an
1799  // unqualified lookup. This is useful when (for example) the
1800  // original lookup would not have found something because it was a
1801  // dependent name.
1802  DeclContext *DC = (SS.isEmpty() && !CallsUndergoingInstantiation.empty())
1803  ? CurContext : nullptr;
1804  while (DC) {
1805  if (isa<CXXRecordDecl>(DC)) {
1806  LookupQualifiedName(R, DC);
1807 
1808  if (!R.empty()) {
1809  // Don't give errors about ambiguities in this lookup.
1810  R.suppressDiagnostics();
1811 
1812  // During a default argument instantiation the CurContext points
1813  // to a CXXMethodDecl; but we can't apply a this-> fixit inside a
1814  // function parameter list, hence add an explicit check.
1815  bool isDefaultArgument = !ActiveTemplateInstantiations.empty() &&
1816  ActiveTemplateInstantiations.back().Kind ==
1817  ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation;
1818  CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1819  bool isInstance = CurMethod &&
1820  CurMethod->isInstance() &&
1821  DC == CurMethod->getParent() && !isDefaultArgument;
1822 
1823 
1824  // Give a code modification hint to insert 'this->'.
1825  // TODO: fixit for inserting 'Base<T>::' in the other cases.
1826  // Actually quite difficult!
1827  if (getLangOpts().MSVCCompat)
1828  diagnostic = diag::ext_found_via_dependent_bases_lookup;
1829  if (isInstance) {
1830  Diag(R.getNameLoc(), diagnostic) << Name
1831  << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
1832  UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(
1833  CallsUndergoingInstantiation.back()->getCallee());
1834 
1835  CXXMethodDecl *DepMethod;
1836  if (CurMethod->isDependentContext())
1837  DepMethod = CurMethod;
1838  else if (CurMethod->getTemplatedKind() ==
1840  DepMethod = cast<CXXMethodDecl>(CurMethod->getPrimaryTemplate()->
1841  getInstantiatedFromMemberTemplate()->getTemplatedDecl());
1842  else
1843  DepMethod = cast<CXXMethodDecl>(
1844  CurMethod->getInstantiatedFromMemberFunction());
1845  assert(DepMethod && "No template pattern found");
1846 
1847  QualType DepThisType = DepMethod->getThisType(Context);
1848  CheckCXXThisCapture(R.getNameLoc());
1849  CXXThisExpr *DepThis = new (Context) CXXThisExpr(
1850  R.getNameLoc(), DepThisType, false);
1852  if (ULE->hasExplicitTemplateArgs())
1853  ULE->copyTemplateArgumentsInto(TList);
1854 
1855  CXXScopeSpec SS;
1856  SS.Adopt(ULE->getQualifierLoc());
1857  CXXDependentScopeMemberExpr *DepExpr =
1859  Context, DepThis, DepThisType, true, SourceLocation(),
1861  ULE->getTemplateKeywordLoc(), nullptr,
1862  R.getLookupNameInfo(),
1863  ULE->hasExplicitTemplateArgs() ? &TList : nullptr);
1864  CallsUndergoingInstantiation.back()->setCallee(DepExpr);
1865  } else {
1866  Diag(R.getNameLoc(), diagnostic) << Name;
1867  }
1868 
1869  // Do we really want to note all of these?
1870  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
1871  Diag((*I)->getLocation(), diag::note_dependent_var_use);
1872 
1873  // Return true if we are inside a default argument instantiation
1874  // and the found name refers to an instance member function, otherwise
1875  // the function calling DiagnoseEmptyLookup will try to create an
1876  // implicit member call and this is wrong for default argument.
1877  if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) {
1878  Diag(R.getNameLoc(), diag::err_member_call_without_object);
1879  return true;
1880  }
1881 
1882  // Tell the callee to try to recover.
1883  return false;
1884  }
1885 
1886  R.clear();
1887  }
1888 
1889  // In Microsoft mode, if we are performing lookup from within a friend
1890  // function definition declared at class scope then we must set
1891  // DC to the lexical parent to be able to search into the parent
1892  // class.
1893  if (getLangOpts().MSVCCompat && isa<FunctionDecl>(DC) &&
1894  cast<FunctionDecl>(DC)->getFriendObjectKind() &&
1895  DC->getLexicalParent()->isRecord())
1896  DC = DC->getLexicalParent();
1897  else
1898  DC = DC->getParent();
1899  }
1900 
1901  // We didn't find anything, so try to correct for a typo.
1902  TypoCorrection Corrected;
1903  if (S && Out) {
1904  SourceLocation TypoLoc = R.getNameLoc();
1905  assert(!ExplicitTemplateArgs &&
1906  "Diagnosing an empty lookup with explicit template args!");
1907  *Out = CorrectTypoDelayed(
1908  R.getLookupNameInfo(), R.getLookupKind(), S, &SS, std::move(CCC),
1909  [=](const TypoCorrection &TC) {
1910  emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
1911  diagnostic, diagnostic_suggest);
1912  },
1913  nullptr, CTK_ErrorRecovery);
1914  if (*Out)
1915  return true;
1916  } else if (S && (Corrected =
1917  CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S,
1918  &SS, std::move(CCC), CTK_ErrorRecovery))) {
1919  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
1920  bool DroppedSpecifier =
1921  Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr;
1922  R.setLookupName(Corrected.getCorrection());
1923 
1924  bool AcceptableWithRecovery = false;
1925  bool AcceptableWithoutRecovery = false;
1926  NamedDecl *ND = Corrected.getCorrectionDecl();
1927  if (ND) {
1928  if (Corrected.isOverloaded()) {
1932  for (TypoCorrection::decl_iterator CD = Corrected.begin(),
1933  CDEnd = Corrected.end();
1934  CD != CDEnd; ++CD) {
1935  if (FunctionTemplateDecl *FTD =
1936  dyn_cast<FunctionTemplateDecl>(*CD))
1937  AddTemplateOverloadCandidate(
1938  FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
1939  Args, OCS);
1940  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD))
1941  if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
1942  AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
1943  Args, OCS);
1944  }
1945  switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
1946  case OR_Success:
1947  ND = Best->Function;
1948  Corrected.setCorrectionDecl(ND);
1949  break;
1950  default:
1951  // FIXME: Arbitrarily pick the first declaration for the note.
1952  Corrected.setCorrectionDecl(ND);
1953  break;
1954  }
1955  }
1956  R.addDecl(ND);
1957  if (getLangOpts().CPlusPlus && ND->isCXXClassMember()) {
1958  CXXRecordDecl *Record = nullptr;
1959  if (Corrected.getCorrectionSpecifier()) {
1960  const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType();
1961  Record = Ty->getAsCXXRecordDecl();
1962  }
1963  if (!Record)
1964  Record = cast<CXXRecordDecl>(
1965  ND->getDeclContext()->getRedeclContext());
1966  R.setNamingClass(Record);
1967  }
1968 
1969  AcceptableWithRecovery =
1970  isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND);
1971  // FIXME: If we ended up with a typo for a type name or
1972  // Objective-C class name, we're in trouble because the parser
1973  // is in the wrong place to recover. Suggest the typo
1974  // correction, but don't make it a fix-it since we're not going
1975  // to recover well anyway.
1976  AcceptableWithoutRecovery =
1977  isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1978  } else {
1979  // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
1980  // because we aren't able to recover.
1981  AcceptableWithoutRecovery = true;
1982  }
1983 
1984  if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
1985  unsigned NoteID = (Corrected.getCorrectionDecl() &&
1986  isa<ImplicitParamDecl>(Corrected.getCorrectionDecl()))
1987  ? diag::note_implicit_param_decl
1988  : diag::note_previous_decl;
1989  if (SS.isEmpty())
1990  diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name,
1991  PDiag(NoteID), AcceptableWithRecovery);
1992  else
1993  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
1994  << Name << computeDeclContext(SS, false)
1995  << DroppedSpecifier << SS.getRange(),
1996  PDiag(NoteID), AcceptableWithRecovery);
1997 
1998  // Tell the callee whether to try to recover.
1999  return !AcceptableWithRecovery;
2000  }
2001  }
2002  R.clear();
2003 
2004  // Emit a special diagnostic for failed member lookups.
2005  // FIXME: computing the declaration context might fail here (?)
2006  if (!SS.isEmpty()) {
2007  Diag(R.getNameLoc(), diag::err_no_member)
2008  << Name << computeDeclContext(SS, false)
2009  << SS.getRange();
2010  return true;
2011  }
2012 
2013  // Give up, we can't recover.
2014  Diag(R.getNameLoc(), diagnostic) << Name;
2015  return true;
2016 }
2017 
2018 /// In Microsoft mode, if we are inside a template class whose parent class has
2019 /// dependent base classes, and we can't resolve an unqualified identifier, then
2020 /// assume the identifier is a member of a dependent base class. We can only
2021 /// recover successfully in static methods, instance methods, and other contexts
2022 /// where 'this' is available. This doesn't precisely match MSVC's
2023 /// instantiation model, but it's close enough.
2024 static Expr *
2026  DeclarationNameInfo &NameInfo,
2027  SourceLocation TemplateKWLoc,
2028  const TemplateArgumentListInfo *TemplateArgs) {
2029  // Only try to recover from lookup into dependent bases in static methods or
2030  // contexts where 'this' is available.
2031  QualType ThisType = S.getCurrentThisType();
2032  const CXXRecordDecl *RD = nullptr;
2033  if (!ThisType.isNull())
2034  RD = ThisType->getPointeeType()->getAsCXXRecordDecl();
2035  else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext))
2036  RD = MD->getParent();
2037  if (!RD || !RD->hasAnyDependentBases())
2038  return nullptr;
2039 
2040  // Diagnose this as unqualified lookup into a dependent base class. If 'this'
2041  // is available, suggest inserting 'this->' as a fixit.
2042  SourceLocation Loc = NameInfo.getLoc();
2043  auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2044  DB << NameInfo.getName() << RD;
2045 
2046  if (!ThisType.isNull()) {
2047  DB << FixItHint::CreateInsertion(Loc, "this->");
2049  Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true,
2050  /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc,
2051  /*FirstQualifierInScope=*/nullptr, NameInfo, TemplateArgs);
2052  }
2053 
2054  // Synthesize a fake NNS that points to the derived class. This will
2055  // perform name lookup during template instantiation.
2056  CXXScopeSpec SS;
2057  auto *NNS =
2058  NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl());
2059  SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
2061  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
2062  TemplateArgs);
2063 }
2064 
2065 ExprResult
2067  SourceLocation TemplateKWLoc, UnqualifiedId &Id,
2068  bool HasTrailingLParen, bool IsAddressOfOperand,
2069  std::unique_ptr<CorrectionCandidateCallback> CCC,
2070  bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
2071  assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2072  "cannot be direct & operand and have a trailing lparen");
2073  if (SS.isInvalid())
2074  return ExprError();
2075 
2076  TemplateArgumentListInfo TemplateArgsBuffer;
2077 
2078  // Decompose the UnqualifiedId into the following data.
2079  DeclarationNameInfo NameInfo;
2080  const TemplateArgumentListInfo *TemplateArgs;
2081  DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
2082 
2083  DeclarationName Name = NameInfo.getName();
2084  IdentifierInfo *II = Name.getAsIdentifierInfo();
2085  SourceLocation NameLoc = NameInfo.getLoc();
2086 
2087  // C++ [temp.dep.expr]p3:
2088  // An id-expression is type-dependent if it contains:
2089  // -- an identifier that was declared with a dependent type,
2090  // (note: handled after lookup)
2091  // -- a template-id that is dependent,
2092  // (note: handled in BuildTemplateIdExpr)
2093  // -- a conversion-function-id that specifies a dependent type,
2094  // -- a nested-name-specifier that contains a class-name that
2095  // names a dependent type.
2096  // Determine whether this is a member of an unknown specialization;
2097  // we need to handle these differently.
2098  bool DependentID = false;
2100  Name.getCXXNameType()->isDependentType()) {
2101  DependentID = true;
2102  } else if (SS.isSet()) {
2103  if (DeclContext *DC = computeDeclContext(SS, false)) {
2104  if (RequireCompleteDeclContext(SS, DC))
2105  return ExprError();
2106  } else {
2107  DependentID = true;
2108  }
2109  }
2110 
2111  if (DependentID)
2112  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2113  IsAddressOfOperand, TemplateArgs);
2114 
2115  // Perform the required lookup.
2116  LookupResult R(*this, NameInfo,
2118  ? LookupObjCImplicitSelfParam : LookupOrdinaryName);
2119  if (TemplateArgs) {
2120  // Lookup the template name again to correctly establish the context in
2121  // which it was found. This is really unfortunate as we already did the
2122  // lookup to determine that it was a template name in the first place. If
2123  // this becomes a performance hit, we can work harder to preserve those
2124  // results until we get here but it's likely not worth it.
2125  bool MemberOfUnknownSpecialization;
2126  LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
2127  MemberOfUnknownSpecialization);
2128 
2129  if (MemberOfUnknownSpecialization ||
2131  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2132  IsAddressOfOperand, TemplateArgs);
2133  } else {
2134  bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
2135  LookupParsedName(R, S, &SS, !IvarLookupFollowUp);
2136 
2137  // If the result might be in a dependent base class, this is a dependent
2138  // id-expression.
2140  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2141  IsAddressOfOperand, TemplateArgs);
2142 
2143  // If this reference is in an Objective-C method, then we need to do
2144  // some special Objective-C lookup, too.
2145  if (IvarLookupFollowUp) {
2146  ExprResult E(LookupInObjCMethod(R, S, II, true));
2147  if (E.isInvalid())
2148  return ExprError();
2149 
2150  if (Expr *Ex = E.getAs<Expr>())
2151  return Ex;
2152  }
2153  }
2154 
2155  if (R.isAmbiguous())
2156  return ExprError();
2157 
2158  // This could be an implicitly declared function reference (legal in C90,
2159  // extension in C99, forbidden in C++).
2160  if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) {
2161  NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
2162  if (D) R.addDecl(D);
2163  }
2164 
2165  // Determine whether this name might be a candidate for
2166  // argument-dependent lookup.
2167  bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
2168 
2169  if (R.empty() && !ADL) {
2170  if (SS.isEmpty() && getLangOpts().MSVCCompat) {
2171  if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
2172  TemplateKWLoc, TemplateArgs))
2173  return E;
2174  }
2175 
2176  // Don't diagnose an empty lookup for inline assembly.
2177  if (IsInlineAsmIdentifier)
2178  return ExprError();
2179 
2180  // If this name wasn't predeclared and if this is not a function
2181  // call, diagnose the problem.
2182  TypoExpr *TE = nullptr;
2183  auto DefaultValidator = llvm::make_unique<CorrectionCandidateCallback>(
2184  II, SS.isValid() ? SS.getScopeRep() : nullptr);
2185  DefaultValidator->IsAddressOfOperand = IsAddressOfOperand;
2186  assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&
2187  "Typo correction callback misconfigured");
2188  if (CCC) {
2189  // Make sure the callback knows what the typo being diagnosed is.
2190  CCC->setTypoName(II);
2191  if (SS.isValid())
2192  CCC->setTypoNNS(SS.getScopeRep());
2193  }
2194  if (DiagnoseEmptyLookup(S, SS, R,
2195  CCC ? std::move(CCC) : std::move(DefaultValidator),
2196  nullptr, None, &TE)) {
2197  if (TE && KeywordReplacement) {
2198  auto &State = getTypoExprState(TE);
2199  auto BestTC = State.Consumer->getNextCorrection();
2200  if (BestTC.isKeyword()) {
2201  auto *II = BestTC.getCorrectionAsIdentifierInfo();
2202  if (State.DiagHandler)
2203  State.DiagHandler(BestTC);
2204  KeywordReplacement->startToken();
2205  KeywordReplacement->setKind(II->getTokenID());
2206  KeywordReplacement->setIdentifierInfo(II);
2207  KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin());
2208  // Clean up the state associated with the TypoExpr, since it has
2209  // now been diagnosed (without a call to CorrectDelayedTyposInExpr).
2210  clearDelayedTypo(TE);
2211  // Signal that a correction to a keyword was performed by returning a
2212  // valid-but-null ExprResult.
2213  return (Expr*)nullptr;
2214  }
2215  State.Consumer->resetCorrectionStream();
2216  }
2217  return TE ? TE : ExprError();
2218  }
2219 
2220  assert(!R.empty() &&
2221  "DiagnoseEmptyLookup returned false but added no results");
2222 
2223  // If we found an Objective-C instance variable, let
2224  // LookupInObjCMethod build the appropriate expression to
2225  // reference the ivar.
2226  if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
2227  R.clear();
2228  ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier()));
2229  // In a hopelessly buggy code, Objective-C instance variable
2230  // lookup fails and no expression will be built to reference it.
2231  if (!E.isInvalid() && !E.get())
2232  return ExprError();
2233  return E;
2234  }
2235  }
2236 
2237  // This is guaranteed from this point on.
2238  assert(!R.empty() || ADL);
2239 
2240  // Check whether this might be a C++ implicit instance member access.
2241  // C++ [class.mfct.non-static]p3:
2242  // When an id-expression that is not part of a class member access
2243  // syntax and not used to form a pointer to member is used in the
2244  // body of a non-static member function of class X, if name lookup
2245  // resolves the name in the id-expression to a non-static non-type
2246  // member of some class C, the id-expression is transformed into a
2247  // class member access expression using (*this) as the
2248  // postfix-expression to the left of the . operator.
2249  //
2250  // But we don't actually need to do this for '&' operands if R
2251  // resolved to a function or overloaded function set, because the
2252  // expression is ill-formed if it actually works out to be a
2253  // non-static member function:
2254  //
2255  // C++ [expr.ref]p4:
2256  // Otherwise, if E1.E2 refers to a non-static member function. . .
2257  // [t]he expression can be used only as the left-hand operand of a
2258  // member function call.
2259  //
2260  // There are other safeguards against such uses, but it's important
2261  // to get this right here so that we don't end up making a
2262  // spuriously dependent expression if we're inside a dependent
2263  // instance method.
2264  if (!R.empty() && (*R.begin())->isCXXClassMember()) {
2265  bool MightBeImplicitMember;
2266  if (!IsAddressOfOperand)
2267  MightBeImplicitMember = true;
2268  else if (!SS.isEmpty())
2269  MightBeImplicitMember = false;
2270  else if (R.isOverloadedResult())
2271  MightBeImplicitMember = false;
2272  else if (R.isUnresolvableResult())
2273  MightBeImplicitMember = true;
2274  else
2275  MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) ||
2276  isa<IndirectFieldDecl>(R.getFoundDecl()) ||
2277  isa<MSPropertyDecl>(R.getFoundDecl());
2278 
2279  if (MightBeImplicitMember)
2280  return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
2281  R, TemplateArgs);
2282  }
2283 
2284  if (TemplateArgs || TemplateKWLoc.isValid()) {
2285 
2286  // In C++1y, if this is a variable template id, then check it
2287  // in BuildTemplateIdExpr().
2288  // The single lookup result must be a variable template declaration.
2289  if (Id.getKind() == UnqualifiedId::IK_TemplateId && Id.TemplateId &&
2290  Id.TemplateId->Kind == TNK_Var_template) {
2291  assert(R.getAsSingle<VarTemplateDecl>() &&
2292  "There should only be one declaration found.");
2293  }
2294 
2295  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
2296  }
2297 
2298  return BuildDeclarationNameExpr(SS, R, ADL);
2299 }
2300 
2301 /// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2302 /// declaration name, generally during template instantiation.
2303 /// There's a large number of things which don't need to be done along
2304 /// this path.
2305 ExprResult
2307  const DeclarationNameInfo &NameInfo,
2308  bool IsAddressOfOperand,
2309  TypeSourceInfo **RecoveryTSI) {
2310  DeclContext *DC = computeDeclContext(SS, false);
2311  if (!DC)
2312  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2313  NameInfo, /*TemplateArgs=*/nullptr);
2314 
2315  if (RequireCompleteDeclContext(SS, DC))
2316  return ExprError();
2317 
2318  LookupResult R(*this, NameInfo, LookupOrdinaryName);
2319  LookupQualifiedName(R, DC);
2320 
2321  if (R.isAmbiguous())
2322  return ExprError();
2323 
2325  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2326  NameInfo, /*TemplateArgs=*/nullptr);
2327 
2328  if (R.empty()) {
2329  Diag(NameInfo.getLoc(), diag::err_no_member)
2330  << NameInfo.getName() << DC << SS.getRange();
2331  return ExprError();
2332  }
2333 
2334  if (const TypeDecl *TD = R.getAsSingle<TypeDecl>()) {
2335  // Diagnose a missing typename if this resolved unambiguously to a type in
2336  // a dependent context. If we can recover with a type, downgrade this to
2337  // a warning in Microsoft compatibility mode.
2338  unsigned DiagID = diag::err_typename_missing;
2339  if (RecoveryTSI && getLangOpts().MSVCCompat)
2340  DiagID = diag::ext_typename_missing;
2341  SourceLocation Loc = SS.getBeginLoc();
2342  auto D = Diag(Loc, DiagID);
2343  D << SS.getScopeRep() << NameInfo.getName().getAsString()
2344  << SourceRange(Loc, NameInfo.getEndLoc());
2345 
2346  // Don't recover if the caller isn't expecting us to or if we're in a SFINAE
2347  // context.
2348  if (!RecoveryTSI)
2349  return ExprError();
2350 
2351  // Only issue the fixit if we're prepared to recover.
2352  D << FixItHint::CreateInsertion(Loc, "typename ");
2353 
2354  // Recover by pretending this was an elaborated type.
2355  QualType Ty = Context.getTypeDeclType(TD);
2356  TypeLocBuilder TLB;
2357  TLB.pushTypeSpec(Ty).setNameLoc(NameInfo.getLoc());
2358 
2359  QualType ET = getElaboratedType(ETK_None, SS, Ty);
2360  ElaboratedTypeLoc QTL = TLB.push<ElaboratedTypeLoc>(ET);
2363 
2364  *RecoveryTSI = TLB.getTypeSourceInfo(Context, ET);
2365 
2366  return ExprEmpty();
2367  }
2368 
2369  // Defend against this resolving to an implicit member access. We usually
2370  // won't get here if this might be a legitimate a class member (we end up in
2371  // BuildMemberReferenceExpr instead), but this can be valid if we're forming
2372  // a pointer-to-member or in an unevaluated context in C++11.
2373  if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand)
2374  return BuildPossibleImplicitMemberExpr(SS,
2375  /*TemplateKWLoc=*/SourceLocation(),
2376  R, /*TemplateArgs=*/nullptr);
2377 
2378  return BuildDeclarationNameExpr(SS, R, /* ADL */ false);
2379 }
2380 
2381 /// LookupInObjCMethod - The parser has read a name in, and Sema has
2382 /// detected that we're currently inside an ObjC method. Perform some
2383 /// additional lookup.
2384 ///
2385 /// Ideally, most of this would be done by lookup, but there's
2386 /// actually quite a lot of extra work involved.
2387 ///
2388 /// Returns a null sentinel to indicate trivial success.
2389 ExprResult
2391  IdentifierInfo *II, bool AllowBuiltinCreation) {
2392  SourceLocation Loc = Lookup.getNameLoc();
2393  ObjCMethodDecl *CurMethod = getCurMethodDecl();
2394 
2395  // Check for error condition which is already reported.
2396  if (!CurMethod)
2397  return ExprError();
2398 
2399  // There are two cases to handle here. 1) scoped lookup could have failed,
2400  // in which case we should look for an ivar. 2) scoped lookup could have
2401  // found a decl, but that decl is outside the current instance method (i.e.
2402  // a global variable). In these two cases, we do a lookup for an ivar with
2403  // this name, if the lookup sucedes, we replace it our current decl.
2404 
2405  // If we're in a class method, we don't normally want to look for
2406  // ivars. But if we don't find anything else, and there's an
2407  // ivar, that's an error.
2408  bool IsClassMethod = CurMethod->isClassMethod();
2409 
2410  bool LookForIvars;
2411  if (Lookup.empty())
2412  LookForIvars = true;
2413  else if (IsClassMethod)
2414  LookForIvars = false;
2415  else
2416  LookForIvars = (Lookup.isSingleResult() &&
2418  ObjCInterfaceDecl *IFace = nullptr;
2419  if (LookForIvars) {
2420  IFace = CurMethod->getClassInterface();
2421  ObjCInterfaceDecl *ClassDeclared;
2422  ObjCIvarDecl *IV = nullptr;
2423  if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {
2424  // Diagnose using an ivar in a class method.
2425  if (IsClassMethod)
2426  return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
2427  << IV->getDeclName());
2428 
2429  // If we're referencing an invalid decl, just return this as a silent
2430  // error node. The error diagnostic was already emitted on the decl.
2431  if (IV->isInvalidDecl())
2432  return ExprError();
2433 
2434  // Check if referencing a field with __attribute__((deprecated)).
2435  if (DiagnoseUseOfDecl(IV, Loc))
2436  return ExprError();
2437 
2438  // Diagnose the use of an ivar outside of the declaring class.
2439  if (IV->getAccessControl() == ObjCIvarDecl::Private &&
2440  !declaresSameEntity(ClassDeclared, IFace) &&
2441  !getLangOpts().DebuggerSupport)
2442  Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
2443 
2444  // FIXME: This should use a new expr for a direct reference, don't
2445  // turn this into Self->ivar, just return a BareIVarExpr or something.
2446  IdentifierInfo &II = Context.Idents.get("self");
2447  UnqualifiedId SelfName;
2448  SelfName.setIdentifier(&II, SourceLocation());
2450  CXXScopeSpec SelfScopeSpec;
2451  SourceLocation TemplateKWLoc;
2452  ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc,
2453  SelfName, false, false);
2454  if (SelfExpr.isInvalid())
2455  return ExprError();
2456 
2457  SelfExpr = DefaultLvalueConversion(SelfExpr.get());
2458  if (SelfExpr.isInvalid())
2459  return ExprError();
2460 
2461  MarkAnyDeclReferenced(Loc, IV, true);
2462 
2463  ObjCMethodFamily MF = CurMethod->getMethodFamily();
2464  if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize &&
2465  !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV))
2466  Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName();
2467 
2468  ObjCIvarRefExpr *Result = new (Context)
2469  ObjCIvarRefExpr(IV, IV->getUsageType(SelfExpr.get()->getType()), Loc,
2470  IV->getLocation(), SelfExpr.get(), true, true);
2471 
2472  if (getLangOpts().ObjCAutoRefCount) {
2473  if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
2474  if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))
2475  recordUseOfEvaluatedWeak(Result);
2476  }
2477  if (CurContext->isClosure())
2478  Diag(Loc, diag::warn_implicitly_retains_self)
2479  << FixItHint::CreateInsertion(Loc, "self->");
2480  }
2481 
2482  return Result;
2483  }
2484  } else if (CurMethod->isInstanceMethod()) {
2485  // We should warn if a local variable hides an ivar.
2486  if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) {
2487  ObjCInterfaceDecl *ClassDeclared;
2488  if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
2489  if (IV->getAccessControl() != ObjCIvarDecl::Private ||
2490  declaresSameEntity(IFace, ClassDeclared))
2491  Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
2492  }
2493  }
2494  } else if (Lookup.isSingleResult() &&
2496  // If accessing a stand-alone ivar in a class method, this is an error.
2497  if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl()))
2498  return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
2499  << IV->getDeclName());
2500  }
2501 
2502  if (Lookup.empty() && II && AllowBuiltinCreation) {
2503  // FIXME. Consolidate this with similar code in LookupName.
2504  if (unsigned BuiltinID = II->getBuiltinID()) {
2505  if (!(getLangOpts().CPlusPlus &&
2507  NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
2508  S, Lookup.isForRedeclaration(),
2509  Lookup.getNameLoc());
2510  if (D) Lookup.addDecl(D);
2511  }
2512  }
2513  }
2514  // Sentinel value saying that we didn't do anything special.
2515  return ExprResult((Expr *)nullptr);
2516 }
2517 
2518 /// \brief Cast a base object to a member's actual type.
2519 ///
2520 /// Logically this happens in three phases:
2521 ///
2522 /// * First we cast from the base type to the naming class.
2523 /// The naming class is the class into which we were looking
2524 /// when we found the member; it's the qualifier type if a
2525 /// qualifier was provided, and otherwise it's the base type.
2526 ///
2527 /// * Next we cast from the naming class to the declaring class.
2528 /// If the member we found was brought into a class's scope by
2529 /// a using declaration, this is that class; otherwise it's
2530 /// the class declaring the member.
2531 ///
2532 /// * Finally we cast from the declaring class to the "true"
2533 /// declaring class of the member. This conversion does not
2534 /// obey access control.
2535 ExprResult
2537  NestedNameSpecifier *Qualifier,
2538  NamedDecl *FoundDecl,
2539  NamedDecl *Member) {
2540  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext());
2541  if (!RD)
2542  return From;
2543 
2544  QualType DestRecordType;
2545  QualType DestType;
2546  QualType FromRecordType;
2547  QualType FromType = From->getType();
2548  bool PointerConversions = false;
2549  if (isa<FieldDecl>(Member)) {
2550  DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD));
2551 
2552  if (FromType->getAs<PointerType>()) {
2553  DestType = Context.getPointerType(DestRecordType);
2554  FromRecordType = FromType->getPointeeType();
2555  PointerConversions = true;
2556  } else {
2557  DestType = DestRecordType;
2558  FromRecordType = FromType;
2559  }
2560  } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) {
2561  if (Method->isStatic())
2562  return From;
2563 
2564  DestType = Method->getThisType(Context);
2565  DestRecordType = DestType->getPointeeType();
2566 
2567  if (FromType->getAs<PointerType>()) {
2568  FromRecordType = FromType->getPointeeType();
2569  PointerConversions = true;
2570  } else {
2571  FromRecordType = FromType;
2572  DestType = DestRecordType;
2573  }
2574  } else {
2575  // No conversion necessary.
2576  return From;
2577  }
2578 
2579  if (DestType->isDependentType() || FromType->isDependentType())
2580  return From;
2581 
2582  // If the unqualified types are the same, no conversion is necessary.
2583  if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
2584  return From;
2585 
2586  SourceRange FromRange = From->getSourceRange();
2587  SourceLocation FromLoc = FromRange.getBegin();
2588 
2589  ExprValueKind VK = From->getValueKind();
2590 
2591  // C++ [class.member.lookup]p8:
2592  // [...] Ambiguities can often be resolved by qualifying a name with its
2593  // class name.
2594  //
2595  // If the member was a qualified name and the qualified referred to a
2596  // specific base subobject type, we'll cast to that intermediate type
2597  // first and then to the object in which the member is declared. That allows
2598  // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as:
2599  //
2600  // class Base { public: int x; };
2601  // class Derived1 : public Base { };
2602  // class Derived2 : public Base { };
2603  // class VeryDerived : public Derived1, public Derived2 { void f(); };
2604  //
2605  // void VeryDerived::f() {
2606  // x = 17; // error: ambiguous base subobjects
2607  // Derived1::x = 17; // okay, pick the Base subobject of Derived1
2608  // }
2609  if (Qualifier && Qualifier->getAsType()) {
2610  QualType QType = QualType(Qualifier->getAsType(), 0);
2611  assert(QType->isRecordType() && "lookup done with non-record type");
2612 
2613  QualType QRecordType = QualType(QType->getAs<RecordType>(), 0);
2614 
2615  // In C++98, the qualifier type doesn't actually have to be a base
2616  // type of the object type, in which case we just ignore it.
2617  // Otherwise build the appropriate casts.
2618  if (IsDerivedFrom(FromRecordType, QRecordType)) {
2619  CXXCastPath BasePath;
2620  if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
2621  FromLoc, FromRange, &BasePath))
2622  return ExprError();
2623 
2624  if (PointerConversions)
2625  QType = Context.getPointerType(QType);
2626  From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
2627  VK, &BasePath).get();
2628 
2629  FromType = QType;
2630  FromRecordType = QRecordType;
2631 
2632  // If the qualifier type was the same as the destination type,
2633  // we're done.
2634  if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
2635  return From;
2636  }
2637  }
2638 
2639  bool IgnoreAccess = false;
2640 
2641  // If we actually found the member through a using declaration, cast
2642  // down to the using declaration's type.
2643  //
2644  // Pointer equality is fine here because only one declaration of a
2645  // class ever has member declarations.
2646  if (FoundDecl->getDeclContext() != Member->getDeclContext()) {
2647  assert(isa<UsingShadowDecl>(FoundDecl));
2648  QualType URecordType = Context.getTypeDeclType(
2649  cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
2650 
2651  // We only need to do this if the naming-class to declaring-class
2652  // conversion is non-trivial.
2653  if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) {
2654  assert(IsDerivedFrom(FromRecordType, URecordType));
2655  CXXCastPath BasePath;
2656  if (CheckDerivedToBaseConversion(FromRecordType, URecordType,
2657  FromLoc, FromRange, &BasePath))
2658  return ExprError();
2659 
2660  QualType UType = URecordType;
2661  if (PointerConversions)
2662  UType = Context.getPointerType(UType);
2663  From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase,
2664  VK, &BasePath).get();
2665  FromType = UType;
2666  FromRecordType = URecordType;
2667  }
2668 
2669  // We don't do access control for the conversion from the
2670  // declaring class to the true declaring class.
2671  IgnoreAccess = true;
2672  }
2673 
2674  CXXCastPath BasePath;
2675  if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
2676  FromLoc, FromRange, &BasePath,
2677  IgnoreAccess))
2678  return ExprError();
2679 
2680  return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase,
2681  VK, &BasePath);
2682 }
2683 
2685  const LookupResult &R,
2686  bool HasTrailingLParen) {
2687  // Only when used directly as the postfix-expression of a call.
2688  if (!HasTrailingLParen)
2689  return false;
2690 
2691  // Never if a scope specifier was provided.
2692  if (SS.isSet())
2693  return false;
2694 
2695  // Only in C++ or ObjC++.
2696  if (!getLangOpts().CPlusPlus)
2697  return false;
2698 
2699  // Turn off ADL when we find certain kinds of declarations during
2700  // normal lookup:
2701  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
2702  NamedDecl *D = *I;
2703 
2704  // C++0x [basic.lookup.argdep]p3:
2705  // -- a declaration of a class member
2706  // Since using decls preserve this property, we check this on the
2707  // original decl.
2708  if (D->isCXXClassMember())
2709  return false;
2710 
2711  // C++0x [basic.lookup.argdep]p3:
2712  // -- a block-scope function declaration that is not a
2713  // using-declaration
2714  // NOTE: we also trigger this for function templates (in fact, we
2715  // don't check the decl type at all, since all other decl types
2716  // turn off ADL anyway).
2717  if (isa<UsingShadowDecl>(D))
2718  D = cast<UsingShadowDecl>(D)->getTargetDecl();
2719  else if (D->getLexicalDeclContext()->isFunctionOrMethod())
2720  return false;
2721 
2722  // C++0x [basic.lookup.argdep]p3:
2723  // -- a declaration that is neither a function or a function
2724  // template
2725  // And also for builtin functions.
2726  if (isa<FunctionDecl>(D)) {
2727  FunctionDecl *FDecl = cast<FunctionDecl>(D);
2728 
2729  // But also builtin functions.
2730  if (FDecl->getBuiltinID() && FDecl->isImplicit())
2731  return false;
2732  } else if (!isa<FunctionTemplateDecl>(D))
2733  return false;
2734  }
2735 
2736  return true;
2737 }
2738 
2739 
2740 /// Diagnoses obvious problems with the use of the given declaration
2741 /// as an expression. This is only actually called for lookups that
2742 /// were not overloaded, and it doesn't promise that the declaration
2743 /// will in fact be used.
2744 static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) {
2745  if (isa<TypedefNameDecl>(D)) {
2746  S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();
2747  return true;
2748  }
2749 
2750  if (isa<ObjCInterfaceDecl>(D)) {
2751  S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();
2752  return true;
2753  }
2754 
2755  if (isa<NamespaceDecl>(D)) {
2756  S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();
2757  return true;
2758  }
2759 
2760  return false;
2761 }
2762 
2764  LookupResult &R, bool NeedsADL,
2765  bool AcceptInvalidDecl) {
2766  // If this is a single, fully-resolved result and we don't need ADL,
2767  // just build an ordinary singleton decl ref.
2768  if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>())
2769  return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
2770  R.getRepresentativeDecl(), nullptr,
2771  AcceptInvalidDecl);
2772 
2773  // We only need to check the declaration if there's exactly one
2774  // result, because in the overloaded case the results can only be
2775  // functions and function templates.
2776  if (R.isSingleResult() &&
2777  CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl()))
2778  return ExprError();
2779 
2780  // Otherwise, just build an unresolved lookup expression. Suppress
2781  // any lookup-related diagnostics; we'll hash these out later, when
2782  // we've picked a target.
2783  R.suppressDiagnostics();
2784 
2788  R.getLookupNameInfo(),
2789  NeedsADL, R.isOverloadedResult(),
2790  R.begin(), R.end());
2791 
2792  return ULE;
2793 }
2794 
2795 /// \brief Complete semantic analysis for a reference to the given declaration.
2797  const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
2798  NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs,
2799  bool AcceptInvalidDecl) {
2800  assert(D && "Cannot refer to a NULL declaration");
2801  assert(!isa<FunctionTemplateDecl>(D) &&
2802  "Cannot refer unambiguously to a function template");
2803 
2804  SourceLocation Loc = NameInfo.getLoc();
2805  if (CheckDeclInExpr(*this, Loc, D))
2806  return ExprError();
2807 
2808  if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
2809  // Specifically diagnose references to class templates that are missing
2810  // a template argument list.
2811  Diag(Loc, diag::err_template_decl_ref) << (isa<VarTemplateDecl>(D) ? 1 : 0)
2812  << Template << SS.getRange();
2813  Diag(Template->getLocation(), diag::note_template_decl_here);
2814  return ExprError();
2815  }
2816 
2817  // Make sure that we're referring to a value.
2818  ValueDecl *VD = dyn_cast<ValueDecl>(D);
2819  if (!VD) {
2820  Diag(Loc, diag::err_ref_non_value)
2821  << D << SS.getRange();
2822  Diag(D->getLocation(), diag::note_declared_at);
2823  return ExprError();
2824  }
2825 
2826  // Check whether this declaration can be used. Note that we suppress
2827  // this check when we're going to perform argument-dependent lookup
2828  // on this function name, because this might not be the function
2829  // that overload resolution actually selects.
2830  if (DiagnoseUseOfDecl(VD, Loc))
2831  return ExprError();
2832 
2833  // Only create DeclRefExpr's for valid Decl's.
2834  if (VD->isInvalidDecl() && !AcceptInvalidDecl)
2835  return ExprError();
2836 
2837  // Handle members of anonymous structs and unions. If we got here,
2838  // and the reference is to a class member indirect field, then this
2839  // must be the subject of a pointer-to-member expression.
2840  if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
2841  if (!indirectField->isCXXClassMember())
2842  return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
2843  indirectField);
2844 
2845  {
2846  QualType type = VD->getType();
2847  ExprValueKind valueKind = VK_RValue;
2848 
2849  switch (D->getKind()) {
2850  // Ignore all the non-ValueDecl kinds.
2851 #define ABSTRACT_DECL(kind)
2852 #define VALUE(type, base)
2853 #define DECL(type, base) \
2854  case Decl::type:
2855 #include "clang/AST/DeclNodes.inc"
2856  llvm_unreachable("invalid value decl kind");
2857 
2858  // These shouldn't make it here.
2859  case Decl::ObjCAtDefsField:
2860  case Decl::ObjCIvar:
2861  llvm_unreachable("forming non-member reference to ivar?");
2862 
2863  // Enum constants are always r-values and never references.
2864  // Unresolved using declarations are dependent.
2865  case Decl::EnumConstant:
2866  case Decl::UnresolvedUsingValue:
2867  valueKind = VK_RValue;
2868  break;
2869 
2870  // Fields and indirect fields that got here must be for
2871  // pointer-to-member expressions; we just call them l-values for
2872  // internal consistency, because this subexpression doesn't really
2873  // exist in the high-level semantics.
2874  case Decl::Field:
2875  case Decl::IndirectField:
2876  assert(getLangOpts().CPlusPlus &&
2877  "building reference to field in C?");
2878 
2879  // These can't have reference type in well-formed programs, but
2880  // for internal consistency we do this anyway.
2881  type = type.getNonReferenceType();
2882  valueKind = VK_LValue;
2883  break;
2884 
2885  // Non-type template parameters are either l-values or r-values
2886  // depending on the type.
2887  case Decl::NonTypeTemplateParm: {
2888  if (const ReferenceType *reftype = type->getAs<ReferenceType>()) {
2889  type = reftype->getPointeeType();
2890  valueKind = VK_LValue; // even if the parameter is an r-value reference
2891  break;
2892  }
2893 
2894  // For non-references, we need to strip qualifiers just in case
2895  // the template parameter was declared as 'const int' or whatever.
2896  valueKind = VK_RValue;
2897  type = type.getUnqualifiedType();
2898  break;
2899  }
2900 
2901  case Decl::Var:
2902  case Decl::VarTemplateSpecialization:
2903  case Decl::VarTemplatePartialSpecialization:
2904  // In C, "extern void blah;" is valid and is an r-value.
2905  if (!getLangOpts().CPlusPlus &&
2906  !type.hasQualifiers() &&
2907  type->isVoidType()) {
2908  valueKind = VK_RValue;
2909  break;
2910  }
2911  // fallthrough
2912 
2913  case Decl::ImplicitParam:
2914  case Decl::ParmVar: {
2915  // These are always l-values.
2916  valueKind = VK_LValue;
2917  type = type.getNonReferenceType();
2918 
2919  // FIXME: Does the addition of const really only apply in
2920  // potentially-evaluated contexts? Since the variable isn't actually
2921  // captured in an unevaluated context, it seems that the answer is no.
2922  if (!isUnevaluatedContext()) {
2923  QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc);
2924  if (!CapturedType.isNull())
2925  type = CapturedType;
2926  }
2927 
2928  break;
2929  }
2930 
2931  case Decl::Function: {
2932  if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
2934  type = Context.BuiltinFnTy;
2935  valueKind = VK_RValue;
2936  break;
2937  }
2938  }
2939 
2940  const FunctionType *fty = type->castAs<FunctionType>();
2941 
2942  // If we're referring to a function with an __unknown_anytype
2943  // result type, make the entire expression __unknown_anytype.
2944  if (fty->getReturnType() == Context.UnknownAnyTy) {
2945  type = Context.UnknownAnyTy;
2946  valueKind = VK_RValue;
2947  break;
2948  }
2949 
2950  // Functions are l-values in C++.
2951  if (getLangOpts().CPlusPlus) {
2952  valueKind = VK_LValue;
2953  break;
2954  }
2955 
2956  // C99 DR 316 says that, if a function type comes from a
2957  // function definition (without a prototype), that type is only
2958  // used for checking compatibility. Therefore, when referencing
2959  // the function, we pretend that we don't have the full function
2960  // type.
2961  if (!cast<FunctionDecl>(VD)->hasPrototype() &&
2962  isa<FunctionProtoType>(fty))
2964  fty->getExtInfo());
2965 
2966  // Functions are r-values in C.
2967  valueKind = VK_RValue;
2968  break;
2969  }
2970 
2971  case Decl::MSProperty:
2972  valueKind = VK_LValue;
2973  break;
2974 
2975  case Decl::CXXMethod:
2976  // If we're referring to a method with an __unknown_anytype
2977  // result type, make the entire expression __unknown_anytype.
2978  // This should only be possible with a type written directly.
2979  if (const FunctionProtoType *proto
2980  = dyn_cast<FunctionProtoType>(VD->getType()))
2981  if (proto->getReturnType() == Context.UnknownAnyTy) {
2982  type = Context.UnknownAnyTy;
2983  valueKind = VK_RValue;
2984  break;
2985  }
2986 
2987  // C++ methods are l-values if static, r-values if non-static.
2988  if (cast<CXXMethodDecl>(VD)->isStatic()) {
2989  valueKind = VK_LValue;
2990  break;
2991  }
2992  // fallthrough
2993 
2994  case Decl::CXXConversion:
2995  case Decl::CXXDestructor:
2996  case Decl::CXXConstructor:
2997  valueKind = VK_RValue;
2998  break;
2999  }
3000 
3001  return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
3002  TemplateArgs);
3003  }
3004 }
3005 
3006 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
3007  SmallString<32> &Target) {
3008  Target.resize(CharByteWidth * (Source.size() + 1));
3009  char *ResultPtr = &Target[0];
3010  const UTF8 *ErrorPtr;
3011  bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3012  (void)success;
3013  assert(success);
3014  Target.resize(ResultPtr - &Target[0]);
3015 }
3016 
3019  // Pick the current block, lambda, captured statement or function.
3020  Decl *currentDecl = nullptr;
3021  if (const BlockScopeInfo *BSI = getCurBlock())
3022  currentDecl = BSI->TheDecl;
3023  else if (const LambdaScopeInfo *LSI = getCurLambda())
3024  currentDecl = LSI->CallOperator;
3025  else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
3026  currentDecl = CSI->TheCapturedDecl;
3027  else
3028  currentDecl = getCurFunctionOrMethodDecl();
3029 
3030  if (!currentDecl) {
3031  Diag(Loc, diag::ext_predef_outside_function);
3032  currentDecl = Context.getTranslationUnitDecl();
3033  }
3034 
3035  QualType ResTy;
3036  StringLiteral *SL = nullptr;
3037  if (cast<DeclContext>(currentDecl)->isDependentContext())
3038  ResTy = Context.DependentTy;
3039  else {
3040  // Pre-defined identifiers are of type char[x], where x is the length of
3041  // the string.
3042  auto Str = PredefinedExpr::ComputeName(IT, currentDecl);
3043  unsigned Length = Str.length();
3044 
3045  llvm::APInt LengthI(32, Length + 1);
3046  if (IT == PredefinedExpr::LFunction) {
3047  ResTy = Context.WideCharTy.withConst();
3048  SmallString<32> RawChars;
3050  Str, RawChars);
3051  ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
3052  /*IndexTypeQuals*/ 0);
3054  /*Pascal*/ false, ResTy, Loc);
3055  } else {
3056  ResTy = Context.CharTy.withConst();
3057  ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
3058  /*IndexTypeQuals*/ 0);
3060  /*Pascal*/ false, ResTy, Loc);
3061  }
3062  }
3063 
3064  return new (Context) PredefinedExpr(Loc, ResTy, IT, SL);
3065 }
3066 
3069 
3070  switch (Kind) {
3071  default: llvm_unreachable("Unknown simple primary expr!");
3072  case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
3073  case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
3074  case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS]
3075  case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS]
3076  case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break;
3077  case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
3078  }
3079 
3080  return BuildPredefinedExpr(Loc, IT);
3081 }
3082 
3084  SmallString<16> CharBuffer;
3085  bool Invalid = false;
3086  StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
3087  if (Invalid)
3088  return ExprError();
3089 
3090  CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(),
3091  PP, Tok.getKind());
3092  if (Literal.hadError())
3093  return ExprError();
3094 
3095  QualType Ty;
3096  if (Literal.isWide())
3097  Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++.
3098  else if (Literal.isUTF16())
3099  Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11.
3100  else if (Literal.isUTF32())
3101  Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
3102  else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
3103  Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
3104  else
3105  Ty = Context.CharTy; // 'x' -> char in C++
3106 
3108  if (Literal.isWide())
3110  else if (Literal.isUTF16())
3112  else if (Literal.isUTF32())
3114 
3115  Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
3116  Tok.getLocation());
3117 
3118  if (Literal.getUDSuffix().empty())
3119  return Lit;
3120 
3121  // We're building a user-defined literal.
3122  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
3123  SourceLocation UDSuffixLoc =
3124  getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
3125 
3126  // Make sure we're allowed user-defined literals here.
3127  if (!UDLScope)
3128  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3129 
3130  // C++11 [lex.ext]p6: The literal L is treated as a call of the form
3131  // operator "" X (ch)
3132  return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc,
3133  Lit, Tok.getLocation());
3134 }
3135 
3137  unsigned IntSize = Context.getTargetInfo().getIntWidth();
3138  return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val),
3139  Context.IntTy, Loc);
3140 }
3141 
3143  QualType Ty, SourceLocation Loc) {
3144  const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty);
3145 
3146  using llvm::APFloat;
3147  APFloat Val(Format);
3148 
3149  APFloat::opStatus result = Literal.GetFloatValue(Val);
3150 
3151  // Overflow is always an error, but underflow is only an error if
3152  // we underflowed to zero (APFloat reports denormals as underflow).
3153  if ((result & APFloat::opOverflow) ||
3154  ((result & APFloat::opUnderflow) && Val.isZero())) {
3155  unsigned diagnostic;
3156  SmallString<20> buffer;
3157  if (result & APFloat::opOverflow) {
3158  diagnostic = diag::warn_float_overflow;
3159  APFloat::getLargest(Format).toString(buffer);
3160  } else {
3161  diagnostic = diag::warn_float_underflow;
3162  APFloat::getSmallest(Format).toString(buffer);
3163  }
3164 
3165  S.Diag(Loc, diagnostic)
3166  << Ty
3167  << StringRef(buffer.data(), buffer.size());
3168  }
3169 
3170  bool isExact = (result == APFloat::opOK);
3171  return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc);
3172 }
3173 
3175  assert(E && "Invalid expression");
3176 
3177  if (E->isValueDependent())
3178  return false;
3179 
3180  QualType QT = E->getType();
3181  if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) {
3182  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3183  return true;
3184  }
3185 
3186  llvm::APSInt ValueAPS;
3187  ExprResult R = VerifyIntegerConstantExpression(E, &ValueAPS);
3188 
3189  if (R.isInvalid())
3190  return true;
3191 
3192  bool ValueIsPositive = ValueAPS.isStrictlyPositive();
3193  if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3194  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
3195  << ValueAPS.toString(10) << ValueIsPositive;
3196  return true;
3197  }
3198 
3199  return false;
3200 }
3201 
3203  // Fast path for a single digit (which is quite common). A single digit
3204  // cannot have a trigraph, escaped newline, radix prefix, or suffix.
3205  if (Tok.getLength() == 1) {
3206  const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
3207  return ActOnIntegerConstant(Tok.getLocation(), Val-'0');
3208  }
3209 
3210  SmallString<128> SpellingBuffer;
3211  // NumericLiteralParser wants to overread by one character. Add padding to
3212  // the buffer in case the token is copied to the buffer. If getSpelling()
3213  // returns a StringRef to the memory buffer, it should have a null char at
3214  // the EOF, so it is also safe.
3215  SpellingBuffer.resize(Tok.getLength() + 1);
3216 
3217  // Get the spelling of the token, which eliminates trigraphs, etc.
3218  bool Invalid = false;
3219  StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid);
3220  if (Invalid)
3221  return ExprError();
3222 
3223  NumericLiteralParser Literal(TokSpelling, Tok.getLocation(), PP);
3224  if (Literal.hadError)
3225  return ExprError();
3226 
3227  if (Literal.hasUDSuffix()) {
3228  // We're building a user-defined literal.
3229  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
3230  SourceLocation UDSuffixLoc =
3231  getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
3232 
3233  // Make sure we're allowed user-defined literals here.
3234  if (!UDLScope)
3235  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3236 
3237  QualType CookedTy;
3238  if (Literal.isFloatingLiteral()) {
3239  // C++11 [lex.ext]p4: If S contains a literal operator with parameter type
3240  // long double, the literal is treated as a call of the form
3241  // operator "" X (f L)
3242  CookedTy = Context.LongDoubleTy;
3243  } else {
3244  // C++11 [lex.ext]p3: If S contains a literal operator with parameter type
3245  // unsigned long long, the literal is treated as a call of the form
3246  // operator "" X (n ULL)
3247  CookedTy = Context.UnsignedLongLongTy;
3248  }
3249 
3250  DeclarationName OpName =
3252  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
3253  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
3254 
3255  SourceLocation TokLoc = Tok.getLocation();
3256 
3257  // Perform literal operator lookup to determine if we're building a raw
3258  // literal or a cooked one.
3259  LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
3260  switch (LookupLiteralOperator(UDLScope, R, CookedTy,
3261  /*AllowRaw*/true, /*AllowTemplate*/true,
3262  /*AllowStringTemplate*/false)) {
3263  case LOLR_Error:
3264  return ExprError();
3265 
3266  case LOLR_Cooked: {
3267  Expr *Lit;
3268  if (Literal.isFloatingLiteral()) {
3269  Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation());
3270  } else {
3271  llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0);
3272  if (Literal.GetIntegerValue(ResultVal))
3273  Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
3274  << /* Unsigned */ 1;
3275  Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy,
3276  Tok.getLocation());
3277  }
3278  return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
3279  }
3280 
3281  case LOLR_Raw: {
3282  // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the
3283  // literal is treated as a call of the form
3284  // operator "" X ("n")
3285  unsigned Length = Literal.getUDSuffixOffset();
3287  Context.CharTy.withConst(), llvm::APInt(32, Length + 1),
3288  ArrayType::Normal, 0);
3289  Expr *Lit = StringLiteral::Create(
3290  Context, StringRef(TokSpelling.data(), Length), StringLiteral::Ascii,
3291  /*Pascal*/false, StrTy, &TokLoc, 1);
3292  return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
3293  }
3294 
3295  case LOLR_Template: {
3296  // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator
3297  // template), L is treated as a call fo the form
3298  // operator "" X <'c1', 'c2', ... 'ck'>()
3299  // where n is the source character sequence c1 c2 ... ck.
3300  TemplateArgumentListInfo ExplicitArgs;
3301  unsigned CharBits = Context.getIntWidth(Context.CharTy);
3302  bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType();
3303  llvm::APSInt Value(CharBits, CharIsUnsigned);
3304  for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
3305  Value = TokSpelling[I];
3306  TemplateArgument Arg(Context, Value, Context.CharTy);
3307  TemplateArgumentLocInfo ArgInfo;
3308  ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
3309  }
3310  return BuildLiteralOperatorCall(R, OpNameInfo, None, TokLoc,
3311  &ExplicitArgs);
3312  }
3313  case LOLR_StringTemplate:
3314  llvm_unreachable("unexpected literal operator lookup result");
3315  }
3316  }
3317 
3318  Expr *Res;
3319 
3320  if (Literal.isFloatingLiteral()) {
3321  QualType Ty;
3322  if (Literal.isFloat)
3323  Ty = Context.FloatTy;
3324  else if (!Literal.isLong)
3325  Ty = Context.DoubleTy;
3326  else
3327  Ty = Context.LongDoubleTy;
3328 
3329  Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
3330 
3331  if (Ty == Context.DoubleTy) {
3332  if (getLangOpts().SinglePrecisionConstants) {
3333  Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
3334  } else if (getLangOpts().OpenCL &&
3335  !((getLangOpts().OpenCLVersion >= 120) ||
3336  getOpenCLOptions().cl_khr_fp64)) {
3337  Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64);
3338  Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
3339  }
3340  }
3341  } else if (!Literal.isIntegerLiteral()) {
3342  return ExprError();
3343  } else {
3344  QualType Ty;
3345 
3346  // 'long long' is a C99 or C++11 feature.
3347  if (!getLangOpts().C99 && Literal.isLongLong) {
3348  if (getLangOpts().CPlusPlus)
3349  Diag(Tok.getLocation(),
3350  getLangOpts().CPlusPlus11 ?
3351  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
3352  else
3353  Diag(Tok.getLocation(), diag::ext_c99_longlong);
3354  }
3355 
3356  // Get the value in the widest-possible width.
3357  unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth();
3358  // The microsoft literal suffix extensions support 128-bit literals, which
3359  // may be wider than [u]intmax_t.
3360  // FIXME: Actually, they don't. We seem to have accidentally invented the
3361  // i128 suffix.
3362  if (Literal.MicrosoftInteger == 128 && MaxWidth < 128 &&
3364  MaxWidth = 128;
3365  llvm::APInt ResultVal(MaxWidth, 0);
3366 
3367  if (Literal.GetIntegerValue(ResultVal)) {
3368  // If this value didn't fit into uintmax_t, error and force to ull.
3369  Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
3370  << /* Unsigned */ 1;
3372  assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
3373  "long long is not intmax_t?");
3374  } else {
3375  // If this value fits into a ULL, try to figure out what else it fits into
3376  // according to the rules of C99 6.4.4.1p5.
3377 
3378  // Octal, Hexadecimal, and integers with a U suffix are allowed to
3379  // be an unsigned int.
3380  bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
3381 
3382  // Check from smallest to largest, picking the smallest type we can.
3383  unsigned Width = 0;
3384 
3385  // Microsoft specific integer suffixes are explicitly sized.
3386  if (Literal.MicrosoftInteger) {
3387  if (Literal.MicrosoftInteger > MaxWidth) {
3388  // If this target doesn't support __int128, error and force to ull.
3389  Diag(Tok.getLocation(), diag::err_int128_unsupported);
3390  Width = MaxWidth;
3391  Ty = Context.getIntMaxType();
3392  } else if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
3393  Width = 8;
3394  Ty = Context.CharTy;
3395  } else {
3396  Width = Literal.MicrosoftInteger;
3397  Ty = Context.getIntTypeForBitwidth(Width,
3398  /*Signed=*/!Literal.isUnsigned);
3399  }
3400  }
3401 
3402  if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) {
3403  // Are int/unsigned possibilities?
3404  unsigned IntSize = Context.getTargetInfo().getIntWidth();
3405 
3406  // Does it fit in a unsigned int?
3407  if (ResultVal.isIntN(IntSize)) {
3408  // Does it fit in a signed int?
3409  if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
3410  Ty = Context.IntTy;
3411  else if (AllowUnsigned)
3412  Ty = Context.UnsignedIntTy;
3413  Width = IntSize;
3414  }
3415  }
3416 
3417  // Are long/unsigned long possibilities?
3418  if (Ty.isNull() && !Literal.isLongLong) {
3419  unsigned LongSize = Context.getTargetInfo().getLongWidth();
3420 
3421  // Does it fit in a unsigned long?
3422  if (ResultVal.isIntN(LongSize)) {
3423  // Does it fit in a signed long?
3424  if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
3425  Ty = Context.LongTy;
3426  else if (AllowUnsigned)
3427  Ty = Context.UnsignedLongTy;
3428  // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2
3429  // is compatible.
3430  else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {
3431  const unsigned LongLongSize =
3433  Diag(Tok.getLocation(),
3434  getLangOpts().CPlusPlus
3435  ? Literal.isLong
3436  ? diag::warn_old_implicitly_unsigned_long_cxx
3437  : /*C++98 UB*/ diag::
3438  ext_old_implicitly_unsigned_long_cxx
3439  : diag::warn_old_implicitly_unsigned_long)
3440  << (LongLongSize > LongSize ? /*will have type 'long long'*/ 0
3441  : /*will be ill-formed*/ 1);
3442  Ty = Context.UnsignedLongTy;
3443  }
3444  Width = LongSize;
3445  }
3446  }
3447 
3448  // Check long long if needed.
3449  if (Ty.isNull()) {
3450  unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth();
3451 
3452  // Does it fit in a unsigned long long?
3453  if (ResultVal.isIntN(LongLongSize)) {
3454  // Does it fit in a signed long long?
3455  // To be compatible with MSVC, hex integer literals ending with the
3456  // LL or i64 suffix are always signed in Microsoft mode.
3457  if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
3458  (getLangOpts().MicrosoftExt && Literal.isLongLong)))
3459  Ty = Context.LongLongTy;
3460  else if (AllowUnsigned)
3462  Width = LongLongSize;
3463  }
3464  }
3465 
3466  // If we still couldn't decide a type, we probably have something that
3467  // does not fit in a signed long long, but has no U suffix.
3468  if (Ty.isNull()) {
3469  Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed);
3472  }
3473 
3474  if (ResultVal.getBitWidth() != Width)
3475  ResultVal = ResultVal.trunc(Width);
3476  }
3477  Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());
3478  }
3479 
3480  // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
3481  if (Literal.isImaginary)
3482  Res = new (Context) ImaginaryLiteral(Res,
3483  Context.getComplexType(Res->getType()));
3484 
3485  return Res;
3486 }
3487 
3489  assert(E && "ActOnParenExpr() missing expr");
3490  return new (Context) ParenExpr(L, R, E);
3491 }
3492 
3494  SourceLocation Loc,
3495  SourceRange ArgRange) {
3496  // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
3497  // scalar or vector data type argument..."
3498  // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
3499  // type (C99 6.2.5p18) or void.
3500  if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
3501  S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
3502  << T << ArgRange;
3503  return true;
3504  }
3505 
3506  assert((T->isVoidType() || !T->isIncompleteType()) &&
3507  "Scalar types should always be complete");
3508  return false;
3509 }
3510 
3512  SourceLocation Loc,
3513  SourceRange ArgRange,
3514  UnaryExprOrTypeTrait TraitKind) {
3515  // Invalid types must be hard errors for SFINAE in C++.
3516  if (S.LangOpts.CPlusPlus)
3517  return true;
3518 
3519  // C99 6.5.3.4p1:
3520  if (T->isFunctionType() &&
3521  (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf)) {
3522  // sizeof(function)/alignof(function) is allowed as an extension.
3523  S.Diag(Loc, diag::ext_sizeof_alignof_function_type)
3524  << TraitKind << ArgRange;
3525  return false;
3526  }
3527 
3528  // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where
3529  // this is an error (OpenCL v1.1 s6.3.k)
3530  if (T->isVoidType()) {
3531  unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
3532  : diag::ext_sizeof_alignof_void_type;
3533  S.Diag(Loc, DiagID) << TraitKind << ArgRange;
3534  return false;
3535  }
3536 
3537  return true;
3538 }
3539 
3541  SourceLocation Loc,
3542  SourceRange ArgRange,
3543  UnaryExprOrTypeTrait TraitKind) {
3544  // Reject sizeof(interface) and sizeof(interface<proto>) if the
3545  // runtime doesn't allow it.
3547  S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
3548  << T << (TraitKind == UETT_SizeOf)
3549  << ArgRange;
3550  return true;
3551  }
3552 
3553  return false;
3554 }
3555 
3556 /// \brief Check whether E is a pointer from a decayed array type (the decayed
3557 /// pointer type is equal to T) and emit a warning if it is.
3559  Expr *E) {
3560  // Don't warn if the operation changed the type.
3561  if (T != E->getType())
3562  return;
3563 
3564  // Now look for array decays.
3565  ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E);
3566  if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
3567  return;
3568 
3569  S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
3570  << ICE->getType()
3571  << ICE->getSubExpr()->getType();
3572 }
3573 
3574 /// \brief Check the constraints on expression operands to unary type expression
3575 /// and type traits.
3576 ///
3577 /// Completes any types necessary and validates the constraints on the operand
3578 /// expression. The logic mostly mirrors the type-based overload, but may modify
3579 /// the expression as it completes the type for that expression through template
3580 /// instantiation, etc.
3582  UnaryExprOrTypeTrait ExprKind) {
3583  QualType ExprTy = E->getType();
3584  assert(!ExprTy->isReferenceType());
3585 
3586  if (ExprKind == UETT_VecStep)
3587  return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(),
3588  E->getSourceRange());
3589 
3590  // Whitelist some types as extensions
3591  if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
3592  E->getSourceRange(), ExprKind))
3593  return false;
3594 
3595  // 'alignof' applied to an expression only requires the base element type of
3596  // the expression to be complete. 'sizeof' requires the expression's type to
3597  // be complete (and will attempt to complete it if it's an array of unknown
3598  // bound).
3599  if (ExprKind == UETT_AlignOf) {
3600  if (RequireCompleteType(E->getExprLoc(),
3602  diag::err_sizeof_alignof_incomplete_type, ExprKind,
3603  E->getSourceRange()))
3604  return true;
3605  } else {
3606  if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type,
3607  ExprKind, E->getSourceRange()))
3608  return true;
3609  }
3610 
3611  // Completing the expression's type may have changed it.
3612  ExprTy = E->getType();
3613  assert(!ExprTy->isReferenceType());
3614 
3615  if (ExprTy->isFunctionType()) {
3616  Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type)
3617  << ExprKind << E->getSourceRange();
3618  return true;
3619  }
3620 
3621  // The operand for sizeof and alignof is in an unevaluated expression context,
3622  // so side effects could result in unintended consequences.
3623  if ((ExprKind == UETT_SizeOf || ExprKind == UETT_AlignOf) &&
3624  ActiveTemplateInstantiations.empty() && E->HasSideEffects(Context, false))
3625  Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
3626 
3627  if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(),
3628  E->getSourceRange(), ExprKind))
3629  return true;
3630 
3631  if (ExprKind == UETT_SizeOf) {
3632  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
3633  if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
3634  QualType OType = PVD->getOriginalType();
3635  QualType Type = PVD->getType();
3636  if (Type->isPointerType() && OType->isArrayType()) {
3637  Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
3638  << Type << OType;
3639  Diag(PVD->getLocation(), diag::note_declared_at);
3640  }
3641  }
3642  }
3643 
3644  // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array
3645  // decays into a pointer and returns an unintended result. This is most
3646  // likely a typo for "sizeof(array) op x".
3647  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
3648  warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3649  BO->getLHS());
3650  warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3651  BO->getRHS());
3652  }
3653  }
3654 
3655  return false;
3656 }
3657 
3658 /// \brief Check the constraints on operands to unary expression and type
3659 /// traits.
3660 ///
3661 /// This will complete any types necessary, and validate the various constraints
3662 /// on those operands.
3663 ///
3664 /// The UsualUnaryConversions() function is *not* called by this routine.
3665 /// C99 6.3.2.1p[2-4] all state:
3666 /// Except when it is the operand of the sizeof operator ...
3667 ///
3668 /// C++ [expr.sizeof]p4
3669 /// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
3670 /// standard conversions are not applied to the operand of sizeof.
3671 ///
3672 /// This policy is followed for all of the unary trait expressions.
3674  SourceLocation OpLoc,
3675  SourceRange ExprRange,
3676  UnaryExprOrTypeTrait ExprKind) {
3677  if (ExprType->isDependentType())
3678  return false;
3679 
3680  // C++ [expr.sizeof]p2:
3681  // When applied to a reference or a reference type, the result
3682  // is the size of the referenced type.
3683  // C++11 [expr.alignof]p3:
3684  // When alignof is applied to a reference type, the result
3685  // shall be the alignment of the referenced type.
3686  if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
3687  ExprType = Ref->getPointeeType();
3688 
3689  // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
3690  // When alignof or _Alignof is applied to an array type, the result
3691  // is the alignment of the element type.
3692  if (ExprKind == UETT_AlignOf || ExprKind == UETT_OpenMPRequiredSimdAlign)
3693  ExprType = Context.getBaseElementType(ExprType);
3694 
3695  if (ExprKind == UETT_VecStep)
3696  return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
3697 
3698  // Whitelist some types as extensions
3699  if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
3700  ExprKind))
3701  return false;
3702 
3703  if (RequireCompleteType(OpLoc, ExprType,
3704  diag::err_sizeof_alignof_incomplete_type,
3705  ExprKind, ExprRange))
3706  return true;
3707 
3708  if (ExprType->isFunctionType()) {
3709  Diag(OpLoc, diag::err_sizeof_alignof_function_type)
3710  << ExprKind << ExprRange;
3711  return true;
3712  }
3713 
3714  if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
3715  ExprKind))
3716  return true;
3717 
3718  return false;
3719 }
3720 
3721 static bool CheckAlignOfExpr(Sema &S, Expr *E) {
3722  E = E->IgnoreParens();
3723 
3724  // Cannot know anything else if the expression is dependent.
3725  if (E->isTypeDependent())
3726  return false;
3727 
3728  if (E->getObjectKind() == OK_BitField) {
3729  S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield)
3730  << 1 << E->getSourceRange();
3731  return true;
3732  }
3733 
3734  ValueDecl *D = nullptr;
3735  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3736  D = DRE->getDecl();
3737  } else if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3738  D = ME->getMemberDecl();
3739  }
3740 
3741  // If it's a field, require the containing struct to have a
3742  // complete definition so that we can compute the layout.
3743  //
3744  // This can happen in C++11 onwards, either by naming the member
3745  // in a way that is not transformed into a member access expression
3746  // (in an unevaluated operand, for instance), or by naming the member
3747  // in a trailing-return-type.
3748  //
3749  // For the record, since __alignof__ on expressions is a GCC
3750  // extension, GCC seems to permit this but always gives the
3751  // nonsensical answer 0.
3752  //
3753  // We don't really need the layout here --- we could instead just
3754  // directly check for all the appropriate alignment-lowing
3755  // attributes --- but that would require duplicating a lot of
3756  // logic that just isn't worth duplicating for such a marginal
3757  // use-case.
3758  if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
3759  // Fast path this check, since we at least know the record has a
3760  // definition if we can find a member of it.
3761  if (!FD->getParent()->isCompleteDefinition()) {
3762  S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
3763  << E->getSourceRange();
3764  return true;
3765  }
3766 
3767  // Otherwise, if it's a field, and the field doesn't have
3768  // reference type, then it must have a complete type (or be a
3769  // flexible array member, which we explicitly want to
3770  // white-list anyway), which makes the following checks trivial.
3771  if (!FD->getType()->isReferenceType())
3772  return false;
3773  }
3774 
3776 }
3777 
3779  E = E->IgnoreParens();
3780 
3781  // Cannot know anything else if the expression is dependent.
3782  if (E->isTypeDependent())
3783  return false;
3784 
3785  return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep);
3786 }
3787 
3788 /// \brief Build a sizeof or alignof expression given a type operand.
3789 ExprResult
3791  SourceLocation OpLoc,
3792  UnaryExprOrTypeTrait ExprKind,
3793  SourceRange R) {
3794  if (!TInfo)
3795  return ExprError();
3796 
3797  QualType T = TInfo->getType();
3798 
3799  if (!T->isDependentType() &&
3800  CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind))
3801  return ExprError();
3802 
3803  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
3804  return new (Context) UnaryExprOrTypeTraitExpr(
3805  ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
3806 }
3807 
3808 /// \brief Build a sizeof or alignof expression given an expression
3809 /// operand.
3810 ExprResult
3812  UnaryExprOrTypeTrait ExprKind) {
3813  ExprResult PE = CheckPlaceholderExpr(E);
3814  if (PE.isInvalid())
3815  return ExprError();
3816 
3817  E = PE.get();
3818 
3819  // Verify that the operand is valid.
3820  bool isInvalid = false;
3821  if (E->isTypeDependent()) {
3822  // Delay type-checking for type-dependent expressions.
3823  } else if (ExprKind == UETT_AlignOf) {
3824  isInvalid = CheckAlignOfExpr(*this, E);
3825  } else if (ExprKind == UETT_VecStep) {
3826  isInvalid = CheckVecStepExpr(E);
3827  } else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
3828  Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
3829  isInvalid = true;
3830  } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
3831  Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0;
3832  isInvalid = true;
3833  } else {
3834  isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf);
3835  }
3836 
3837  if (isInvalid)
3838  return ExprError();
3839 
3840  if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) {
3841  PE = TransformToPotentiallyEvaluated(E);
3842  if (PE.isInvalid()) return ExprError();
3843  E = PE.get();
3844  }
3845 
3846  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
3847  return new (Context) UnaryExprOrTypeTraitExpr(
3848  ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd());
3849 }
3850 
3851 /// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
3852 /// expr and the same for @c alignof and @c __alignof
3853 /// Note that the ArgRange is invalid if isType is false.
3854 ExprResult
3856  UnaryExprOrTypeTrait ExprKind, bool IsType,
3857  void *TyOrEx, const SourceRange &ArgRange) {
3858  // If error parsing type, ignore.
3859  if (!TyOrEx) return ExprError();
3860 
3861  if (IsType) {
3862  TypeSourceInfo *TInfo;
3863  (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
3864  return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
3865  }
3866 
3867  Expr *ArgEx = (Expr *)TyOrEx;
3868  ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
3869  return Result;
3870 }
3871 
3873  bool IsReal) {
3874  if (V.get()->isTypeDependent())
3875  return S.Context.DependentTy;
3876 
3877  // _Real and _Imag are only l-values for normal l-values.
3878  if (V.get()->getObjectKind() != OK_Ordinary) {
3879  V = S.DefaultLvalueConversion(V.get());
3880  if (V.isInvalid())
3881  return QualType();
3882  }
3883 
3884  // These operators return the element type of a complex type.
3885  if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>())
3886  return CT->getElementType();
3887 
3888  // Otherwise they pass through real integer and floating point types here.
3889  if (V.get()->getType()->isArithmeticType())
3890  return V.get()->getType();
3891 
3892  // Test for placeholders.
3893  ExprResult PR = S.CheckPlaceholderExpr(V.get());
3894  if (PR.isInvalid()) return QualType();
3895  if (PR.get() != V.get()) {
3896  V = PR;
3897  return CheckRealImagOperand(S, V, Loc, IsReal);
3898  }
3899 
3900  // Reject anything else.
3901  S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
3902  << (IsReal ? "__real" : "__imag");
3903  return QualType();
3904 }
3905 
3906 
3907 
3908 ExprResult
3911  UnaryOperatorKind Opc;
3912  switch (Kind) {
3913  default: llvm_unreachable("Unknown unary op!");
3914  case tok::plusplus: Opc = UO_PostInc; break;
3915  case tok::minusminus: Opc = UO_PostDec; break;
3916  }
3917 
3918  // Since this might is a postfix expression, get rid of ParenListExprs.
3919  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
3920  if (Result.isInvalid()) return ExprError();
3921  Input = Result.get();
3922 
3923  return BuildUnaryOp(S, OpLoc, Opc, Input);
3924 }
3925 
3926 /// \brief Diagnose if arithmetic on the given ObjC pointer is illegal.
3927 ///
3928 /// \return true on error
3930  SourceLocation opLoc,
3931  Expr *op) {
3932  assert(op->getType()->isObjCObjectPointerType());
3934  !S.LangOpts.ObjCSubscriptingLegacyRuntime)
3935  return false;
3936 
3937  S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
3938  << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
3939  << op->getSourceRange();
3940  return true;
3941 }
3942 
3943 ExprResult
3945  Expr *idx, SourceLocation rbLoc) {
3946  // Since this might be a postfix expression, get rid of ParenListExprs.
3947  if (isa<ParenListExpr>(base)) {
3948  ExprResult result = MaybeConvertParenListExprToParenExpr(S, base);
3949  if (result.isInvalid()) return ExprError();
3950  base = result.get();
3951  }
3952 
3953  // Handle any non-overload placeholder types in the base and index
3954  // expressions. We can't handle overloads here because the other
3955  // operand might be an overloadable type, in which case the overload
3956  // resolution for the operator overload should get the first crack
3957  // at the overload.
3958  if (base->getType()->isNonOverloadPlaceholderType()) {
3959  ExprResult result = CheckPlaceholderExpr(base);
3960  if (result.isInvalid()) return ExprError();
3961  base = result.get();
3962  }
3963  if (idx->getType()->isNonOverloadPlaceholderType()) {
3964  ExprResult result = CheckPlaceholderExpr(idx);
3965  if (result.isInvalid()) return ExprError();
3966  idx = result.get();
3967  }
3968 
3969  // Build an unanalyzed expression if either operand is type-dependent.
3970  if (getLangOpts().CPlusPlus &&
3971  (base->isTypeDependent() || idx->isTypeDependent())) {
3972  return new (Context) ArraySubscriptExpr(base, idx, Context.DependentTy,
3973  VK_LValue, OK_Ordinary, rbLoc);
3974  }
3975 
3976  // Use C++ overloaded-operator rules if either operand has record
3977  // type. The spec says to do this if either type is *overloadable*,
3978  // but enum types can't declare subscript operators or conversion
3979  // operators, so there's nothing interesting for overload resolution
3980  // to do if there aren't any record types involved.
3981  //
3982  // ObjC pointers have their own subscripting logic that is not tied
3983  // to overload resolution and so should not take this path.
3984  if (getLangOpts().CPlusPlus &&
3985  (base->getType()->isRecordType() ||
3986  (!base->getType()->isObjCObjectPointerType() &&
3987  idx->getType()->isRecordType()))) {
3988  return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx);
3989  }
3990 
3991  return CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);
3992 }
3993 
3994 ExprResult
3996  Expr *Idx, SourceLocation RLoc) {
3997  Expr *LHSExp = Base;
3998  Expr *RHSExp = Idx;
3999 
4000  // Perform default conversions.
4001  if (!LHSExp->getType()->getAs<VectorType>()) {
4002  ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
4003  if (Result.isInvalid())
4004  return ExprError();
4005  LHSExp = Result.get();
4006  }
4007  ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
4008  if (Result.isInvalid())
4009  return ExprError();
4010  RHSExp = Result.get();
4011 
4012  QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
4013  ExprValueKind VK = VK_LValue;
4015 
4016  // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
4017  // to the expression *((e1)+(e2)). This means the array "Base" may actually be
4018  // in the subscript position. As a result, we need to derive the array base
4019  // and index from the expression types.
4020  Expr *BaseExpr, *IndexExpr;
4021  QualType ResultType;
4022  if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
4023  BaseExpr = LHSExp;
4024  IndexExpr = RHSExp;
4025  ResultType = Context.DependentTy;
4026  } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
4027  BaseExpr = LHSExp;
4028  IndexExpr = RHSExp;
4029  ResultType = PTy->getPointeeType();
4030  } else if (const ObjCObjectPointerType *PTy =
4031  LHSTy->getAs<ObjCObjectPointerType>()) {
4032  BaseExpr = LHSExp;
4033  IndexExpr = RHSExp;
4034 
4035  // Use custom logic if this should be the pseudo-object subscript
4036  // expression.
4037  if (!LangOpts.isSubscriptPointerArithmetic())
4038  return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, nullptr,
4039  nullptr);
4040 
4041  ResultType = PTy->getPointeeType();
4042  } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
4043  // Handle the uncommon case of "123[Ptr]".
4044  BaseExpr = RHSExp;
4045  IndexExpr = LHSExp;
4046  ResultType = PTy->getPointeeType();
4047  } else if (const ObjCObjectPointerType *PTy =
4048  RHSTy->getAs<ObjCObjectPointerType>()) {
4049  // Handle the uncommon case of "123[Ptr]".
4050  BaseExpr = RHSExp;
4051  IndexExpr = LHSExp;
4052  ResultType = PTy->getPointeeType();
4053  if (!LangOpts.isSubscriptPointerArithmetic()) {
4054  Diag(LLoc, diag::err_subscript_nonfragile_interface)
4055  << ResultType << BaseExpr->getSourceRange();
4056  return ExprError();
4057  }
4058  } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
4059  BaseExpr = LHSExp; // vectors: V[123]
4060  IndexExpr = RHSExp;
4061  VK = LHSExp->getValueKind();
4062  if (VK != VK_RValue)
4063  OK = OK_VectorComponent;
4064 
4065  // FIXME: need to deal with const...
4066  ResultType = VTy->getElementType();
4067  } else if (LHSTy->isArrayType()) {
4068  // If we see an array that wasn't promoted by
4069  // DefaultFunctionArrayLvalueConversion, it must be an array that
4070  // wasn't promoted because of the C90 rule that doesn't
4071  // allow promoting non-lvalue arrays. Warn, then
4072  // force the promotion here.
4073  Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
4074  LHSExp->getSourceRange();
4075  LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
4076  CK_ArrayToPointerDecay).get();
4077  LHSTy = LHSExp->getType();
4078 
4079  BaseExpr = LHSExp;
4080  IndexExpr = RHSExp;
4081  ResultType = LHSTy->getAs<PointerType>()->getPointeeType();
4082  } else if (RHSTy->isArrayType()) {
4083  // Same as previous, except for 123[f().a] case
4084  Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
4085  RHSExp->getSourceRange();
4086  RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
4087  CK_ArrayToPointerDecay).get();
4088  RHSTy = RHSExp->getType();
4089 
4090  BaseExpr = RHSExp;
4091  IndexExpr = LHSExp;
4092  ResultType = RHSTy->getAs<PointerType>()->getPointeeType();
4093  } else {
4094  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
4095  << LHSExp->getSourceRange() << RHSExp->getSourceRange());
4096  }
4097  // C99 6.5.2.1p1
4098  if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
4099  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
4100  << IndexExpr->getSourceRange());
4101 
4102  if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
4103  IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
4104  && !IndexExpr->isTypeDependent())
4105  Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();
4106 
4107  // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
4108  // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
4109  // type. Note that Functions are not objects, and that (in C99 parlance)
4110  // incomplete types are not object types.
4111  if (ResultType->isFunctionType()) {
4112  Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
4113  << ResultType << BaseExpr->getSourceRange();
4114  return ExprError();
4115  }
4116 
4117  if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
4118  // GNU extension: subscripting on pointer to void
4119  Diag(LLoc, diag::ext_gnu_subscript_void_type)
4120  << BaseExpr->getSourceRange();
4121 
4122  // C forbids expressions of unqualified void type from being l-values.
4123  // See IsCForbiddenLValueType.
4124  if (!ResultType.hasQualifiers()) VK = VK_RValue;
4125  } else if (!ResultType->isDependentType() &&
4126  RequireCompleteType(LLoc, ResultType,
4127  diag::err_subscript_incomplete_type, BaseExpr))
4128  return ExprError();
4129 
4130  assert(VK == VK_RValue || LangOpts.CPlusPlus ||
4131  !ResultType.isCForbiddenLValueType());
4132 
4133  return new (Context)
4134  ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc);
4135 }
4136 
4138  FunctionDecl *FD,
4139  ParmVarDecl *Param) {
4140  if (Param->hasUnparsedDefaultArg()) {
4141  Diag(CallLoc,
4142  diag::err_use_of_default_argument_to_function_declared_later) <<
4143  FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
4144  Diag(UnparsedDefaultArgLocs[Param],
4145  diag::note_default_argument_declared_here);
4146  return ExprError();
4147  }
4148 
4149  if (Param->hasUninstantiatedDefaultArg()) {
4150  Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
4151 
4152  EnterExpressionEvaluationContext EvalContext(*this, PotentiallyEvaluated,
4153  Param);
4154 
4155  // Instantiate the expression.
4156  MultiLevelTemplateArgumentList MutiLevelArgList
4157  = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true);
4158 
4159  InstantiatingTemplate Inst(*this, CallLoc, Param,
4160  MutiLevelArgList.getInnermost());
4161  if (Inst.isInvalid())
4162  return ExprError();
4163 
4165  {
4166  // C++ [dcl.fct.default]p5:
4167  // The names in the [default argument] expression are bound, and
4168  // the semantic constraints are checked, at the point where the
4169  // default argument expression appears.
4170  ContextRAII SavedContext(*this, FD);
4171  LocalInstantiationScope Local(*this);
4172  Result = SubstExpr(UninstExpr, MutiLevelArgList);
4173  }
4174  if (Result.isInvalid())
4175  return ExprError();
4176 
4177  // Check the expression as an initializer for the parameter.
4178  InitializedEntity Entity
4182  /*FIXME:EqualLoc*/UninstExpr->getLocStart());
4183  Expr *ResultE = Result.getAs<Expr>();
4184 
4185  InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
4186  Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
4187  if (Result.isInvalid())
4188  return ExprError();
4189 
4190  Expr *Arg = Result.getAs<Expr>();
4191  CheckCompletedExpr(Arg, Param->getOuterLocStart());
4192  // Build the default argument expression.
4193  return CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg);
4194  }
4195 
4196  // If the default expression creates temporaries, we need to
4197  // push them to the current stack of expression temporaries so they'll
4198  // be properly destroyed.
4199  // FIXME: We should really be rebuilding the default argument with new
4200  // bound temporaries; see the comment in PR5810.
4201  // We don't need to do that with block decls, though, because
4202  // blocks in default argument expression can never capture anything.
4203  if (isa<ExprWithCleanups>(Param->getInit())) {
4204  // Set the "needs cleanups" bit regardless of whether there are
4205  // any explicit objects.
4206  ExprNeedsCleanups = true;
4207 
4208  // Append all the objects to the cleanup list. Right now, this
4209  // should always be a no-op, because blocks in default argument
4210  // expressions should never be able to capture anything.
4211  assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() &&
4212  "default argument expression has capturing blocks?");
4213  }
4214 
4215  // We already type-checked the argument, so we know it works.
4216  // Just mark all of the declarations in this potentially-evaluated expression
4217  // as being "referenced".
4218  MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
4219  /*SkipLocalVariables=*/true);
4220  return CXXDefaultArgExpr::Create(Context, CallLoc, Param);
4221 }
4222 
4223 
4226  Expr *Fn) {
4227  if (Proto && Proto->isVariadic()) {
4228  if (dyn_cast_or_null<CXXConstructorDecl>(FDecl))
4229  return VariadicConstructor;
4230  else if (Fn && Fn->getType()->isBlockPointerType())
4231  return VariadicBlock;
4232  else if (FDecl) {
4233  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
4234  if (Method->isInstance())
4235  return VariadicMethod;
4236  } else if (Fn && Fn->getType() == Context.BoundMemberTy)
4237  return VariadicMethod;
4238  return VariadicFunction;
4239  }
4240  return VariadicDoesNotApply;
4241 }
4242 
4243 namespace {
4244 class FunctionCallCCC : public FunctionCallFilterCCC {
4245 public:
4246  FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName,
4247  unsigned NumArgs, MemberExpr *ME)
4248  : FunctionCallFilterCCC(SemaRef, NumArgs, false, ME),
4249  FunctionName(FuncName) {}
4250 
4251  bool ValidateCandidate(const TypoCorrection &candidate) override {
4252  if (!candidate.getCorrectionSpecifier() ||
4253  candidate.getCorrectionAsIdentifierInfo() != FunctionName) {
4254  return false;
4255  }
4256 
4257  return FunctionCallFilterCCC::ValidateCandidate(candidate);
4258  }
4259 
4260 private:
4261  const IdentifierInfo *const FunctionName;
4262 };
4263 }
4264 
4266  FunctionDecl *FDecl,
4267  ArrayRef<Expr *> Args) {
4268  MemberExpr *ME = dyn_cast<MemberExpr>(Fn);
4269  DeclarationName FuncName = FDecl->getDeclName();
4270  SourceLocation NameLoc = ME ? ME->getMemberLoc() : Fn->getLocStart();
4271 
4272  if (TypoCorrection Corrected = S.CorrectTypo(
4273  DeclarationNameInfo(FuncName, NameLoc), Sema::LookupOrdinaryName,
4274  S.getScopeForContext(S.CurContext), nullptr,
4275  llvm::make_unique<FunctionCallCCC>(S, FuncName.getAsIdentifierInfo(),
4276  Args.size(), ME),
4278  if (NamedDecl *ND = Corrected.getCorrectionDecl()) {
4279  if (Corrected.isOverloaded()) {
4282  for (TypoCorrection::decl_iterator CD = Corrected.begin(),
4283  CDEnd = Corrected.end();
4284  CD != CDEnd; ++CD) {
4285  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD))
4286  S.AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args,
4287  OCS);
4288  }
4289  switch (OCS.BestViableFunction(S, NameLoc, Best)) {
4290  case OR_Success:
4291  ND = Best->Function;
4292  Corrected.setCorrectionDecl(ND);
4293  break;
4294  default:
4295  break;
4296  }
4297  }
4298  if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
4299  return Corrected;
4300  }
4301  }
4302  }
4303  return TypoCorrection();
4304 }
4305 
4306 /// ConvertArgumentsForCall - Converts the arguments specified in
4307 /// Args/NumArgs to the parameter types of the function FDecl with
4308 /// function prototype Proto. Call is the call expression itself, and
4309 /// Fn is the function expression. For a C++ member function, this
4310 /// routine does not attempt to convert the object argument. Returns
4311 /// true if the call is ill-formed.
4312 bool
4314  FunctionDecl *FDecl,
4315  const FunctionProtoType *Proto,
4316  ArrayRef<Expr *> Args,
4317  SourceLocation RParenLoc,
4318  bool IsExecConfig) {
4319  // Bail out early if calling a builtin with custom typechecking.
4320  if (FDecl)
4321  if (unsigned ID = FDecl->getBuiltinID())
4323  return false;
4324 
4325  // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
4326  // assignment, to the types of the corresponding parameter, ...
4327  unsigned NumParams = Proto->getNumParams();
4328  bool Invalid = false;
4329  unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
4330  unsigned FnKind = Fn->getType()->isBlockPointerType()
4331  ? 1 /* block */
4332  : (IsExecConfig ? 3 /* kernel function (exec config) */
4333  : 0 /* function */);
4334 
4335  // If too few arguments are available (and we don't have default
4336  // arguments for the remaining parameters), don't make the call.
4337  if (Args.size() < NumParams) {
4338  if (Args.size() < MinArgs) {
4339  TypoCorrection TC;
4340  if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
4341  unsigned diag_id =
4342  MinArgs == NumParams && !Proto->isVariadic()
4343  ? diag::err_typecheck_call_too_few_args_suggest
4344  : diag::err_typecheck_call_too_few_args_at_least_suggest;
4345  diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs
4346  << static_cast<unsigned>(Args.size())
4347  << TC.getCorrectionRange());
4348  } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName())
4349  Diag(RParenLoc,
4350  MinArgs == NumParams && !Proto->isVariadic()
4351  ? diag::err_typecheck_call_too_few_args_one
4352  : diag::err_typecheck_call_too_few_args_at_least_one)
4353  << FnKind << FDecl->getParamDecl(0) << Fn->getSourceRange();
4354  else
4355  Diag(RParenLoc, MinArgs == NumParams && !Proto->isVariadic()
4356  ? diag::err_typecheck_call_too_few_args
4357  : diag::err_typecheck_call_too_few_args_at_least)
4358  << FnKind << MinArgs << static_cast<unsigned>(Args.size())
4359  << Fn->getSourceRange();
4360 
4361  // Emit the location of the prototype.
4362  if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
4363  Diag(FDecl->getLocStart(), diag::note_callee_decl)
4364  << FDecl;
4365 
4366  return true;
4367  }
4368  Call->setNumArgs(Context, NumParams);
4369  }
4370 
4371  // If too many are passed and not variadic, error on the extras and drop
4372  // them.
4373  if (Args.size() > NumParams) {
4374  if (!Proto->isVariadic()) {
4375  TypoCorrection TC;
4376  if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
4377  unsigned diag_id =
4378  MinArgs == NumParams && !Proto->isVariadic()
4379  ? diag::err_typecheck_call_too_many_args_suggest
4380  : diag::err_typecheck_call_too_many_args_at_most_suggest;
4381  diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams
4382  << static_cast<unsigned>(Args.size())
4383  << TC.getCorrectionRange());
4384  } else if (NumParams == 1 && FDecl &&
4385  FDecl->getParamDecl(0)->getDeclName())
4386  Diag(Args[NumParams]->getLocStart(),
4387  MinArgs == NumParams
4388  ? diag::err_typecheck_call_too_many_args_one
4389  : diag::err_typecheck_call_too_many_args_at_most_one)
4390  << FnKind << FDecl->getParamDecl(0)
4391  << static_cast<unsigned>(Args.size()) << Fn->getSourceRange()
4392  << SourceRange(Args[NumParams]->getLocStart(),
4393  Args.back()->getLocEnd());
4394  else
4395  Diag(Args[NumParams]->getLocStart(),
4396  MinArgs == NumParams
4397  ? diag::err_typecheck_call_too_many_args
4398  : diag::err_typecheck_call_too_many_args_at_most)
4399  << FnKind << NumParams << static_cast<unsigned>(Args.size())
4400  << Fn->getSourceRange()
4401  << SourceRange(Args[NumParams]->getLocStart(),
4402  Args.back()->getLocEnd());
4403 
4404  // Emit the location of the prototype.
4405  if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
4406  Diag(FDecl->getLocStart(), diag::note_callee_decl)
4407  << FDecl;
4408 
4409  // This deletes the extra arguments.
4410  Call->setNumArgs(Context, NumParams);
4411  return true;
4412  }
4413  }
4414  SmallVector<Expr *, 8> AllArgs;
4415  VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn);
4416 
4417  Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl,
4418  Proto, 0, Args, AllArgs, CallType);
4419  if (Invalid)
4420  return true;
4421  unsigned TotalNumArgs = AllArgs.size();
4422  for (unsigned i = 0; i < TotalNumArgs; ++i)
4423  Call->setArg(i, AllArgs[i]);
4424 
4425  return false;
4426 }
4427 
4429  const FunctionProtoType *Proto,
4430  unsigned FirstParam, ArrayRef<Expr *> Args,
4431  SmallVectorImpl<Expr *> &AllArgs,
4432  VariadicCallType CallType, bool AllowExplicit,
4433  bool IsListInitialization) {
4434  unsigned NumParams = Proto->getNumParams();
4435  bool Invalid = false;
4436  unsigned ArgIx = 0;
4437  // Continue to check argument types (even if we have too few/many args).
4438  for (unsigned i = FirstParam; i < NumParams; i++) {
4439  QualType ProtoArgType = Proto->getParamType(i);
4440 
4441  Expr *Arg;
4442  ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr;
4443  if (ArgIx < Args.size()) {
4444  Arg = Args[ArgIx++];
4445 
4446  if (RequireCompleteType(Arg->getLocStart(),
4447  ProtoArgType,
4448  diag::err_call_incomplete_argument, Arg))
4449  return true;
4450 
4451  // Strip the unbridged-cast placeholder expression off, if applicable.
4452  bool CFAudited = false;
4453  if (Arg->getType() == Context.ARCUnbridgedCastTy &&
4454  FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
4455  (!Param || !Param->hasAttr<CFConsumedAttr>()))
4456  Arg = stripARCUnbridgedCast(Arg);
4457  else if (getLangOpts().ObjCAutoRefCount &&
4458  FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
4459  (!Param || !Param->hasAttr<CFConsumedAttr>()))
4460  CFAudited = true;
4461 
4462  InitializedEntity Entity =
4464  ProtoArgType)
4466  Context, ProtoArgType, Proto->isParamConsumed(i));
4467 
4468  // Remember that parameter belongs to a CF audited API.
4469  if (CFAudited)
4470  Entity.setParameterCFAudited();
4471 
4472  ExprResult ArgE = PerformCopyInitialization(
4473  Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit);
4474  if (ArgE.isInvalid())
4475  return true;
4476 
4477  Arg = ArgE.getAs<Expr>();
4478  } else {
4479  assert(Param && "can't use default arguments without a known callee");
4480 
4481  ExprResult ArgExpr =
4482  BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
4483  if (ArgExpr.isInvalid())
4484  return true;
4485 
4486  Arg = ArgExpr.getAs<Expr>();
4487  }
4488 
4489  // Check for array bounds violations for each argument to the call. This
4490  // check only triggers warnings when the argument isn't a more complex Expr
4491  // with its own checking, such as a BinaryOperator.
4492  CheckArrayAccess(Arg);
4493 
4494  // Check for violations of C99 static array rules (C99 6.7.5.3p7).
4495  CheckStaticArrayArgument(CallLoc, Param, Arg);
4496 
4497  AllArgs.push_back(Arg);
4498  }
4499 
4500  // If this is a variadic call, handle args passed through "...".
4501  if (CallType != VariadicDoesNotApply) {
4502  // Assume that extern "C" functions with variadic arguments that
4503  // return __unknown_anytype aren't *really* variadic.
4504  if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl &&
4505  FDecl->isExternC()) {
4506  for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) {
4507  QualType paramType; // ignored
4508  ExprResult arg = checkUnknownAnyArg(CallLoc, Args[i], paramType);
4509  Invalid |= arg.isInvalid();
4510  AllArgs.push_back(arg.get());
4511  }
4512 
4513  // Otherwise do argument promotion, (C99 6.5.2.2p7).
4514  } else {
4515  for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) {
4516  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType,
4517  FDecl);
4518  Invalid |= Arg.isInvalid();
4519  AllArgs.push_back(Arg.get());
4520  }
4521  }
4522 
4523  // Check for array bounds violations.
4524  for (unsigned i = ArgIx, e = Args.size(); i != e; ++i)
4525  CheckArrayAccess(Args[i]);
4526  }
4527  return Invalid;
4528 }
4529 
4531  TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc();
4532  if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>())
4533  TL = DTL.getOriginalLoc();
4534  if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
4535  S.Diag(PVD->getLocation(), diag::note_callee_static_array)
4536  << ATL.getLocalSourceRange();
4537 }
4538 
4539 /// CheckStaticArrayArgument - If the given argument corresponds to a static
4540 /// array parameter, check that it is non-null, and that if it is formed by
4541 /// array-to-pointer decay, the underlying array is sufficiently large.
4542 ///
4543 /// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
4544 /// array type derivation, then for each call to the function, the value of the
4545 /// corresponding actual argument shall provide access to the first element of
4546 /// an array with at least as many elements as specified by the size expression.
4547 void
4549  ParmVarDecl *Param,
4550  const Expr *ArgExpr) {
4551  // Static array parameters are not supported in C++.
4552  if (!Param || getLangOpts().CPlusPlus)
4553  return;
4554 
4555  QualType OrigTy = Param->getOriginalType();
4556 
4557  const ArrayType *AT = Context.getAsArrayType(OrigTy);
4558  if (!AT || AT->getSizeModifier() != ArrayType::Static)
4559  return;
4560 
4561  if (ArgExpr->isNullPointerConstant(Context,
4563  Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
4564  DiagnoseCalleeStaticArrayParam(*this, Param);
4565  return;
4566  }
4567 
4568  const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT);
4569  if (!CAT)
4570  return;
4571 
4572  const ConstantArrayType *ArgCAT =
4574  if (!ArgCAT)
4575  return;
4576 
4577  if (ArgCAT->getSize().ult(CAT->getSize())) {
4578  Diag(CallLoc, diag::warn_static_array_too_small)
4579  << ArgExpr->getSourceRange()
4580  << (unsigned) ArgCAT->getSize().getZExtValue()
4581  << (unsigned) CAT->getSize().getZExtValue();
4582  DiagnoseCalleeStaticArrayParam(*this, Param);
4583  }
4584 }
4585 
4586 /// Given a function expression of unknown-any type, try to rebuild it
4587 /// to have a function type.
4589 
4590 /// Is the given type a placeholder that we need to lower out
4591 /// immediately during argument processing?
4593  // Placeholders are never sugared.
4594  const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
4595  if (!placeholder) return false;
4596 
4597  switch (placeholder->getKind()) {
4598  // Ignore all the non-placeholder types.
4599 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
4600 #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
4601 #include "clang/AST/BuiltinTypes.def"
4602  return false;
4603 
4604  // We cannot lower out overload sets; they might validly be resolved
4605  // by the call machinery.
4606  case BuiltinType::Overload:
4607  return false;
4608 
4609  // Unbridged casts in ARC can be handled in some call positions and
4610  // should be left in place.
4611  case BuiltinType::ARCUnbridgedCast:
4612  return false;
4613 
4614  // Pseudo-objects should be converted as soon as possible.
4615  case BuiltinType::PseudoObject:
4616  return true;
4617 
4618  // The debugger mode could theoretically but currently does not try
4619  // to resolve unknown-typed arguments based on known parameter types.
4620  case BuiltinType::UnknownAny:
4621  return true;
4622 
4623  // These are always invalid as call arguments and should be reported.
4624  case BuiltinType::BoundMember:
4625  case BuiltinType::BuiltinFn:
4626  return true;
4627  }
4628  llvm_unreachable("bad builtin type kind");
4629 }
4630 
4631 /// Check an argument list for placeholders that we won't try to
4632 /// handle later.
4634  // Apply this processing to all the arguments at once instead of
4635  // dying at the first failure.
4636  bool hasInvalid = false;
4637  for (size_t i = 0, e = args.size(); i != e; i++) {
4638  if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
4639  ExprResult result = S.CheckPlaceholderExpr(args[i]);
4640  if (result.isInvalid()) hasInvalid = true;
4641  else args[i] = result.get();
4642  } else if (hasInvalid) {
4643  (void)S.CorrectDelayedTyposInExpr(args[i]);
4644  }
4645  }
4646  return hasInvalid;
4647 }
4648 
4649 /// If a builtin function has a pointer argument with no explicit address
4650 /// space, than it should be able to accept a pointer to any address
4651 /// space as input. In order to do this, we need to replace the
4652 /// standard builtin declaration with one that uses the same address space
4653 /// as the call.
4654 ///
4655 /// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
4656 /// it does not contain any pointer arguments without
4657 /// an address space qualifer. Otherwise the rewritten
4658 /// FunctionDecl is returned.
4659 /// TODO: Handle pointer return types.
4661  const FunctionDecl *FDecl,
4662  MultiExprArg ArgExprs) {
4663 
4664  QualType DeclType = FDecl->getType();
4665  const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(DeclType);
4666 
4667  if (!Context.BuiltinInfo.hasPtrArgsOrResult(FDecl->getBuiltinID()) ||
4668  !FT || FT->isVariadic() || ArgExprs.size() != FT->getNumParams())
4669  return nullptr;
4670 
4671  bool NeedsNewDecl = false;
4672  unsigned i = 0;
4673  SmallVector<QualType, 8> OverloadParams;
4674 
4675  for (QualType ParamType : FT->param_types()) {
4676 
4677  // Convert array arguments to pointer to simplify type lookup.
4678  Expr *Arg = Sema->DefaultFunctionArrayLvalueConversion(ArgExprs[i++]).get();
4679  QualType ArgType = Arg->getType();
4680  if (!ParamType->isPointerType() ||
4681  ParamType.getQualifiers().hasAddressSpace() ||
4682  !ArgType->isPointerType() ||
4683  !ArgType->getPointeeType().getQualifiers().hasAddressSpace()) {
4684  OverloadParams.push_back(ParamType);
4685  continue;
4686  }
4687 
4688  NeedsNewDecl = true;
4689  unsigned AS = ArgType->getPointeeType().getQualifiers().getAddressSpace();
4690 
4691  QualType PointeeType = ParamType->getPointeeType();
4692  PointeeType = Context.getAddrSpaceQualType(PointeeType, AS);
4693  OverloadParams.push_back(Context.getPointerType(PointeeType));
4694  }
4695 
4696  if (!NeedsNewDecl)
4697  return nullptr;
4698 
4700  QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
4701  OverloadParams, EPI);
4702  DeclContext *Parent = Context.getTranslationUnitDecl();
4703  FunctionDecl *OverloadDecl = FunctionDecl::Create(Context, Parent,
4704  FDecl->getLocation(),
4705  FDecl->getLocation(),
4706  FDecl->getIdentifier(),
4707  OverloadTy,
4708  /*TInfo=*/nullptr,
4709  SC_Extern, false,
4710  /*hasPrototype=*/true);
4712  FT = cast<FunctionProtoType>(OverloadTy);
4713  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
4714  QualType ParamType = FT->getParamType(i);
4715  ParmVarDecl *Parm =
4716  ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
4717  SourceLocation(), nullptr, ParamType,
4718  /*TInfo=*/nullptr, SC_None, nullptr);
4719  Parm->setScopeInfo(0, i);
4720  Params.push_back(Parm);
4721  }
4722  OverloadDecl->setParams(Params);
4723  return OverloadDecl;
4724 }
4725 
4726 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
4727 /// This provides the location of the left/right parens and a list of comma
4728 /// locations.
4729 ExprResult
4731  MultiExprArg ArgExprs, SourceLocation RParenLoc,
4732  Expr *ExecConfig, bool IsExecConfig) {
4733  // Since this might be a postfix expression, get rid of ParenListExprs.
4734  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn);
4735  if (Result.isInvalid()) return ExprError();
4736  Fn = Result.get();
4737 
4738  if (checkArgsForPlaceholders(*this, ArgExprs))
4739  return ExprError();
4740 
4741  if (getLangOpts().CPlusPlus) {
4742  // If this is a pseudo-destructor expression, build the call immediately.
4743  if (isa<CXXPseudoDestructorExpr>(Fn)) {
4744  if (!ArgExprs.empty()) {
4745  // Pseudo-destructor calls should not have any arguments.
4746  Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args)
4748  SourceRange(ArgExprs[0]->getLocStart(),
4749  ArgExprs.back()->getLocEnd()));
4750  }
4751 
4752  return new (Context)
4753  CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc);
4754  }
4755  if (Fn->getType() == Context.PseudoObjectTy) {
4756  ExprResult result = CheckPlaceholderExpr(Fn);
4757  if (result.isInvalid()) return ExprError();
4758  Fn = result.get();
4759  }
4760 
4761  // Determine whether this is a dependent call inside a C++ template,
4762  // in which case we won't do any semantic analysis now.
4763  // FIXME: Will need to cache the results of name lookup (including ADL) in
4764  // Fn.
4765  bool Dependent = false;
4766  if (Fn->isTypeDependent())
4767  Dependent = true;
4768  else if (Expr::hasAnyTypeDependentArguments(ArgExprs))
4769  Dependent = true;
4770 
4771  if (Dependent) {
4772  if (ExecConfig) {
4773  return new (Context) CUDAKernelCallExpr(
4774  Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
4775  Context.DependentTy, VK_RValue, RParenLoc);
4776  } else {
4777  return new (Context) CallExpr(
4778  Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc);
4779  }
4780  }
4781 
4782  // Determine whether this is a call to an object (C++ [over.call.object]).
4783  if (Fn->getType()->isRecordType())
4784  return BuildCallToObjectOfClassType(S, Fn, LParenLoc, ArgExprs,
4785  RParenLoc);
4786 
4787  if (Fn->getType() == Context.UnknownAnyTy) {
4788  ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
4789  if (result.isInvalid()) return ExprError();
4790  Fn = result.get();
4791  }
4792 
4793  if (Fn->getType() == Context.BoundMemberTy) {
4794  return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, RParenLoc);
4795  }
4796  }
4797 
4798  // Check for overloaded calls. This can happen even in C due to extensions.
4799  if (Fn->getType() == Context.OverloadTy) {
4801 
4802  // We aren't supposed to apply this logic for if there's an '&' involved.
4803  if (!find.HasFormOfMemberPointer) {
4804  OverloadExpr *ovl = find.Expression;
4805  if (isa<UnresolvedLookupExpr>(ovl)) {
4806  UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl);
4807  return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, ArgExprs,
4808  RParenLoc, ExecConfig);
4809  } else {
4810  return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs,
4811  RParenLoc);
4812  }
4813  }
4814  }
4815 
4816  // If we're directly calling a function, get the appropriate declaration.
4817  if (Fn->getType() == Context.UnknownAnyTy) {
4818  ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
4819  if (result.isInvalid()) return ExprError();
4820  Fn = result.get();
4821  }
4822 
4823  Expr *NakedFn = Fn->IgnoreParens();
4824 
4825  NamedDecl *NDecl = nullptr;
4826  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn))
4827  if (UnOp->getOpcode() == UO_AddrOf)
4828  NakedFn = UnOp->getSubExpr()->IgnoreParens();
4829 
4830  if (isa<DeclRefExpr>(NakedFn)) {
4831  NDecl = cast<DeclRefExpr>(NakedFn)->getDecl();
4832 
4833  FunctionDecl *FDecl = dyn_cast<FunctionDecl>(NDecl);
4834  if (FDecl && FDecl->getBuiltinID()) {
4835  // Rewrite the function decl for this builtin by replacing paramaters
4836  // with no explicit address space with the address space of the arguments
4837  // in ArgExprs.
4838  if ((FDecl = rewriteBuiltinFunctionDecl(this, Context, FDecl, ArgExprs))) {
4839  NDecl = FDecl;
4841  SourceLocation(), FDecl, false,
4842  SourceLocation(), FDecl->getType(),
4843  Fn->getValueKind(), FDecl);
4844  }
4845  }
4846  } else if (isa<MemberExpr>(NakedFn))
4847  NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
4848 
4849  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
4850  if (FD->hasAttr<EnableIfAttr>()) {
4851  if (const EnableIfAttr *Attr = CheckEnableIf(FD, ArgExprs, true)) {
4852  Diag(Fn->getLocStart(),
4853  isa<CXXMethodDecl>(FD) ?
4854  diag::err_ovl_no_viable_member_function_in_call :
4855  diag::err_ovl_no_viable_function_in_call)
4856  << FD << FD->getSourceRange();
4857  Diag(FD->getLocation(),
4858  diag::note_ovl_candidate_disabled_by_enable_if_attr)
4859  << Attr->getCond()->getSourceRange() << Attr->getMessage();
4860  }
4861  }
4862  }
4863 
4864  return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
4865  ExecConfig, IsExecConfig);
4866 }
4867 
4868 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
4869 ///
4870 /// __builtin_astype( value, dst type )
4871 ///
4873  SourceLocation BuiltinLoc,
4874  SourceLocation RParenLoc) {
4875  ExprValueKind VK = VK_RValue;
4877  QualType DstTy = GetTypeFromParser(ParsedDestTy);
4878  QualType SrcTy = E->getType();
4879  if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy))
4880  return ExprError(Diag(BuiltinLoc,
4881  diag::err_invalid_astype_of_different_size)
4882  << DstTy
4883  << SrcTy
4884  << E->getSourceRange());
4885  return new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, RParenLoc);
4886 }
4887 
4888 /// ActOnConvertVectorExpr - create a new convert-vector expression from the
4889 /// provided arguments.
4890 ///
4891 /// __builtin_convertvector( value, dst type )
4892 ///
4894  SourceLocation BuiltinLoc,
4895  SourceLocation RParenLoc) {
4896  TypeSourceInfo *TInfo;
4897  GetTypeFromParser(ParsedDestTy, &TInfo);
4898  return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
4899 }
4900 
4901 /// BuildResolvedCallExpr - Build a call to a resolved expression,
4902 /// i.e. an expression not of \p OverloadTy. The expression should
4903 /// unary-convert to an expression of function-pointer or
4904 /// block-pointer type.
4905 ///
4906 /// \param NDecl the declaration being called, if available
4907 ExprResult
4909  SourceLocation LParenLoc,
4910  ArrayRef<Expr *> Args,
4911  SourceLocation RParenLoc,
4912  Expr *Config, bool IsExecConfig) {
4913  FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
4914  unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);
4915 
4916  // Promote the function operand.
4917  // We special-case function promotion here because we only allow promoting
4918  // builtin functions to function pointers in the callee of a call.
4920  if (BuiltinID &&
4921  Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
4922  Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()),
4924  } else {
4925  Result = CallExprUnaryConversions(Fn);
4926  }
4927  if (Result.isInvalid())
4928  return ExprError();
4929  Fn = Result.get();
4930 
4931  // Make the call expr early, before semantic checks. This guarantees cleanup
4932  // of arguments and function on error.
4933  CallExpr *TheCall;
4934  if (Config)
4935  TheCall = new (Context) CUDAKernelCallExpr(Context, Fn,
4936  cast<CallExpr>(Config), Args,
4938  RParenLoc);
4939  else
4940  TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy,
4941  VK_RValue, RParenLoc);
4942 
4943  if (!getLangOpts().CPlusPlus) {
4944  // C cannot always handle TypoExpr nodes in builtin calls and direct
4945  // function calls as their argument checking don't necessarily handle
4946  // dependent types properly, so make sure any TypoExprs have been
4947  // dealt with.
4948  ExprResult Result = CorrectDelayedTyposInExpr(TheCall);
4949  if (!Result.isUsable()) return ExprError();
4950  TheCall = dyn_cast<CallExpr>(Result.get());
4951  if (!TheCall) return Result;
4952  Args = ArrayRef<Expr *>(TheCall->getArgs(), TheCall->getNumArgs());
4953  }
4954 
4955  // Bail out early if calling a builtin with custom typechecking.
4956  if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID))
4957  return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
4958 
4959  retry:
4960  const FunctionType *FuncT;
4961  if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) {
4962  // C99 6.5.2.2p1 - "The expression that denotes the called function shall
4963  // have type pointer to function".
4964  FuncT = PT->getPointeeType()->getAs<FunctionType>();
4965  if (!FuncT)
4966  return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4967  << Fn->getType() << Fn->getSourceRange());
4968  } else if (const BlockPointerType *BPT =
4969  Fn->getType()->getAs<BlockPointerType>()) {
4970  FuncT = BPT->getPointeeType()->castAs<FunctionType>();
4971  } else {
4972  // Handle calls to expressions of unknown-any type.
4973  if (Fn->getType() == Context.UnknownAnyTy) {
4974  ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn);
4975  if (rewrite.isInvalid()) return ExprError();
4976  Fn = rewrite.get();
4977  TheCall->setCallee(Fn);
4978  goto retry;
4979  }
4980 
4981  return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4982  << Fn->getType() << Fn->getSourceRange());
4983  }
4984 
4985  if (getLangOpts().CUDA) {
4986  if (Config) {
4987  // CUDA: Kernel calls must be to global functions
4988  if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
4989  return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
4990  << FDecl->getName() << Fn->getSourceRange());
4991 
4992  // CUDA: Kernel function must have 'void' return type
4993  if (!FuncT->getReturnType()->isVoidType())
4994  return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
4995  << Fn->getType() << Fn->getSourceRange());
4996  } else {
4997  // CUDA: Calls to global functions must be configured
4998  if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
4999  return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
5000  << FDecl->getName() << Fn->getSourceRange());
5001  }
5002  }
5003 
5004  // Check for a valid return type
5005  if (CheckCallReturnType(FuncT->getReturnType(), Fn->getLocStart(), TheCall,
5006  FDecl))
5007  return ExprError();
5008 
5009  // We know the result type of the call, set it.
5010  TheCall->setType(FuncT->getCallResultType(Context));
5012 
5013  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT);
5014  if (Proto) {
5015  if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc,
5016  IsExecConfig))
5017  return ExprError();
5018  } else {
5019  assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
5020 
5021  if (FDecl) {
5022  // Check if we have too few/too many template arguments, based
5023  // on our knowledge of the function definition.
5024  const FunctionDecl *Def = nullptr;
5025  if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
5026  Proto = Def->getType()->getAs<FunctionProtoType>();
5027  if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
5028  Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
5029  << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
5030  }
5031 
5032  // If the function we're calling isn't a function prototype, but we have
5033  // a function prototype from a prior declaratiom, use that prototype.
5034  if (!FDecl->hasPrototype())
5035  Proto = FDecl->getType()->getAs<FunctionProtoType>();
5036  }
5037 
5038  // Promote the arguments (C99 6.5.2.2p6).
5039  for (unsigned i = 0, e = Args.size(); i != e; i++) {
5040  Expr *Arg = Args[i];
5041 
5042  if (Proto && i < Proto->getNumParams()) {
5044  Context, Proto->getParamType(i), Proto->isParamConsumed(i));
5045  ExprResult ArgE =
5046  PerformCopyInitialization(Entity, SourceLocation(), Arg);
5047  if (ArgE.isInvalid())
5048  return true;
5049 
5050  Arg = ArgE.getAs<Expr>();
5051 
5052  } else {
5053  ExprResult ArgE = DefaultArgumentPromotion(Arg);
5054 
5055  if (ArgE.isInvalid())
5056  return true;
5057 
5058  Arg = ArgE.getAs<Expr>();
5059  }
5060 
5061  if (RequireCompleteType(Arg->getLocStart(),
5062  Arg->getType(),
5063  diag::err_call_incomplete_argument, Arg))
5064  return ExprError();
5065 
5066  TheCall->setArg(i, Arg);
5067  }
5068  }
5069 
5070  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5071  if (!Method->isStatic())
5072  return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
5073  << Fn->getSourceRange());
5074 
5075  // Check for sentinels
5076  if (NDecl)
5077  DiagnoseSentinelCalls(NDecl, LParenLoc, Args);
5078 
5079  // Do special checking on direct calls to functions.
5080  if (FDecl) {
5081  if (CheckFunctionCall(FDecl, TheCall, Proto))
5082  return ExprError();
5083 
5084  if (BuiltinID)
5085  return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
5086  } else if (NDecl) {
5087  if (CheckPointerCall(NDecl, TheCall, Proto))
5088  return ExprError();
5089  } else {
5090  if (CheckOtherCall(TheCall, Proto))
5091  return ExprError();
5092  }
5093 
5094  return MaybeBindToTemporary(TheCall);
5095 }
5096 
5097 ExprResult
5099  SourceLocation RParenLoc, Expr *InitExpr) {
5100  assert(Ty && "ActOnCompoundLiteral(): missing type");
5101  // FIXME: put back this assert when initializers are worked out.
5102  //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
5103 
5104  TypeSourceInfo *TInfo;
5105  QualType literalType = GetTypeFromParser(Ty, &TInfo);
5106  if (!TInfo)
5107  TInfo = Context.getTrivialTypeSourceInfo(literalType);
5108 
5109  return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
5110 }
5111 
5112 ExprResult
5114  SourceLocation RParenLoc, Expr *LiteralExpr) {
5115  QualType literalType = TInfo->getType();
5116 
5117  if (literalType->isArrayType()) {
5118  if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType),
5119  diag::err_illegal_decl_array_incomplete_type,
5120  SourceRange(LParenLoc,
5121  LiteralExpr->getSourceRange().getEnd())))
5122  return ExprError();
5123  if (literalType->isVariableArrayType())
5124  return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
5125  << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()));
5126  } else if (!literalType->isDependentType() &&
5127  RequireCompleteType(LParenLoc, literalType,
5128  diag::err_typecheck_decl_incomplete_type,
5129  SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
5130  return ExprError();
5131 
5132  InitializedEntity Entity
5136  SourceRange(LParenLoc, RParenLoc),
5137  /*InitList=*/true);
5138  InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
5139  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
5140  &literalType);
5141  if (Result.isInvalid())
5142  return ExprError();
5143  LiteralExpr = Result.get();
5144 
5145  bool isFileScope = getCurFunctionOrMethodDecl() == nullptr;
5146  if (isFileScope &&
5147  !LiteralExpr->isTypeDependent() &&
5148  !LiteralExpr->isValueDependent() &&
5149  !literalType->isDependentType()) { // 6.5.2.5p3
5150  if (CheckForConstantInitializer(LiteralExpr, literalType))
5151  return ExprError();
5152  }
5153 
5154  // In C, compound literals are l-values for some reason.
5155  ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue;
5156 
5157  return MaybeBindToTemporary(
5158  new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
5159  VK, LiteralExpr, isFileScope));
5160 }
5161 
5162 ExprResult
5164  SourceLocation RBraceLoc) {
5165  // Immediately handle non-overload placeholders. Overloads can be
5166  // resolved contextually, but everything else here can't.
5167  for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
5168  if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
5169  ExprResult result = CheckPlaceholderExpr(InitArgList[I]);
5170 
5171  // Ignore failures; dropping the entire initializer list because
5172  // of one failure would be terrible for indexing/etc.
5173  if (result.isInvalid()) continue;
5174 
5175  InitArgList[I] = result.get();
5176  }
5177  }
5178 
5179  // Semantic analysis for initializers is done by ActOnDeclarator() and
5180  // CheckInitializer() - it requires knowledge of the object being intialized.
5181 
5182  InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
5183  RBraceLoc);
5184  E->setType(Context.VoidTy); // FIXME: just a place holder for now.
5185  return E;
5186 }
5187 
5188 /// Do an explicit extend of the given block pointer if we're in ARC.
5190  assert(E.get()->getType()->isBlockPointerType());
5191  assert(E.get()->isRValue());
5192 
5193  // Only do this in an r-value context.
5194  if (!getLangOpts().ObjCAutoRefCount) return;
5195 
5198  /*base path*/ nullptr, VK_RValue);
5199  ExprNeedsCleanups = true;
5200 }
5201 
5202 /// Prepare a conversion of the given expression to an ObjC object
5203 /// pointer type.
5205  QualType type = E.get()->getType();
5206  if (type->isObjCObjectPointerType()) {
5207  return CK_BitCast;
5208  } else if (type->isBlockPointerType()) {
5209  maybeExtendBlockObject(E);
5211  } else {
5212  assert(type->isPointerType());
5214  }
5215 }
5216 
5217 /// Prepares for a scalar cast, performing all the necessary stages
5218 /// except the final cast and returning the kind required.
5220  // Both Src and Dest are scalar types, i.e. arithmetic or pointer.
5221  // Also, callers should have filtered out the invalid cases with
5222  // pointers. Everything else should be possible.
5223 
5224  QualType SrcTy = Src.get()->getType();
5225  if (Context.hasSameUnqualifiedType(SrcTy, DestTy))
5226  return CK_NoOp;
5227 
5228  switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) {
5230  llvm_unreachable("member pointer type in C");
5231 
5232  case Type::STK_CPointer:
5235  switch (DestTy->getScalarTypeKind()) {
5236  case Type::STK_CPointer: {
5237  unsigned SrcAS = SrcTy->getPointeeType().getAddressSpace();
5238  unsigned DestAS = DestTy->getPointeeType().getAddressSpace();
5239  if (SrcAS != DestAS)
5241  return CK_BitCast;
5242  }
5244  return (SrcKind == Type::STK_BlockPointer
5247  if (SrcKind == Type::STK_ObjCObjectPointer)
5248  return CK_BitCast;
5249  if (SrcKind == Type::STK_CPointer)
5251  maybeExtendBlockObject(Src);
5253  case Type::STK_Bool:
5254  return CK_PointerToBoolean;
5255  case Type::STK_Integral:
5256  return CK_PointerToIntegral;
5257  case Type::STK_Floating:
5261  llvm_unreachable("illegal cast from pointer");
5262  }
5263  llvm_unreachable("Should have returned before this");
5264 
5265  case Type::STK_Bool: // casting from bool is like casting from an integer
5266  case Type::STK_Integral:
5267  switch (DestTy->getScalarTypeKind()) {
5268  case Type::STK_CPointer:
5271  if (Src.get()->isNullPointerConstant(Context,
5273  return CK_NullToPointer;
5274  return CK_IntegralToPointer;
5275  case Type::STK_Bool:
5276  return CK_IntegralToBoolean;
5277  case Type::STK_Integral:
5278  return CK_IntegralCast;
5279  case Type::STK_Floating:
5280  return CK_IntegralToFloating;
5282  Src = ImpCastExprToType(Src.get(),
5283  DestTy->castAs<ComplexType>()->getElementType(),
5284  CK_IntegralCast);
5285  return CK_IntegralRealToComplex;
5287  Src = ImpCastExprToType(Src.get(),
5288  DestTy->castAs<ComplexType>()->getElementType(),
5290  return CK_FloatingRealToComplex;
5292  llvm_unreachable("member pointer type in C");
5293  }
5294  llvm_unreachable("Should have returned before this");
5295 
5296  case Type::STK_Floating:
5297  switch (DestTy->getScalarTypeKind()) {
5298  case Type::STK_Floating:
5299  return CK_FloatingCast;
5300  case Type::STK_Bool:
5301  return CK_FloatingToBoolean;
5302  case Type::STK_Integral:
5303  return CK_FloatingToIntegral;
5305  Src = ImpCastExprToType(Src.get(),
5306  DestTy->castAs<ComplexType>()->getElementType(),
5307  CK_FloatingCast);
5308  return CK_FloatingRealToComplex;
5310  Src = ImpCastExprToType(Src.get(),
5311  DestTy->castAs<ComplexType>()->getElementType(),
5313  return CK_IntegralRealToComplex;
5314  case Type::STK_CPointer:
5317  llvm_unreachable("valid float->pointer cast?");
5319  llvm_unreachable("member pointer type in C");
5320  }
5321  llvm_unreachable("Should have returned before this");
5322 
5324  switch (DestTy->getScalarTypeKind()) {
5326  return CK_FloatingComplexCast;
5329  case Type::STK_Floating: {
5330  QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
5331  if (Context.hasSameType(ET, DestTy))
5332  return CK_FloatingComplexToReal;
5333  Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal);
5334  return CK_FloatingCast;
5335  }
5336  case Type::STK_Bool:
5338  case Type::STK_Integral:
5339  Src = ImpCastExprToType(Src.get(),
5340  SrcTy->castAs<ComplexType>()->getElementType(),
5342  return CK_FloatingToIntegral;
5343  case Type::STK_CPointer:
5346  llvm_unreachable("valid complex float->pointer cast?");
5348  llvm_unreachable("member pointer type in C");
5349  }
5350  llvm_unreachable("Should have returned before this");
5351 
5353  switch (DestTy->getScalarTypeKind()) {
5357  return CK_IntegralComplexCast;
5358  case Type::STK_Integral: {
5359  QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
5360  if (Context.hasSameType(ET, DestTy))
5361  return CK_IntegralComplexToReal;
5362  Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal);
5363  return CK_IntegralCast;
5364  }
5365  case Type::STK_Bool:
5367  case Type::STK_Floating:
5368  Src = ImpCastExprToType(Src.get(),
5369  SrcTy->castAs<ComplexType>()->getElementType(),
5371  return CK_IntegralToFloating;
5372  case Type::STK_CPointer:
5375  llvm_unreachable("valid complex int->pointer cast?");
5377  llvm_unreachable("member pointer type in C");
5378  }
5379  llvm_unreachable("Should have returned before this");
5380  }
5381 
5382  llvm_unreachable("Unhandled scalar cast");
5383 }
5384 
5385 static bool breakDownVectorType(QualType type, uint64_t &len,
5386  QualType &eltType) {
5387  // Vectors are simple.
5388  if (const VectorType *vecType = type->getAs<VectorType>()) {
5389  len = vecType->getNumElements();
5390  eltType = vecType->getElementType();
5391  assert(eltType->isScalarType());
5392  return true;
5393  }
5394 
5395  // We allow lax conversion to and from non-vector types, but only if
5396  // they're real types (i.e. non-complex, non-pointer scalar types).
5397  if (!type->isRealType()) return false;
5398 
5399  len = 1;
5400  eltType = type;
5401  return true;
5402 }
5403 
5404 static bool VectorTypesMatch(Sema &S, QualType srcTy, QualType destTy) {
5405  uint64_t srcLen, destLen;
5406  QualType srcElt, destElt;
5407  if (!breakDownVectorType(srcTy, srcLen, srcElt)) return false;
5408  if (!breakDownVectorType(destTy, destLen, destElt)) return false;
5409 
5410  // ASTContext::getTypeSize will return the size rounded up to a
5411  // power of 2, so instead of using that, we need to use the raw
5412  // element size multiplied by the element count.
5413  uint64_t srcEltSize = S.Context.getTypeSize(srcElt);
5414  uint64_t destEltSize = S.Context.getTypeSize(destElt);
5415 
5416  return (srcLen * srcEltSize == destLen * destEltSize);
5417 }
5418 
5419 /// Is this a legal conversion between two known vector types?
5421  assert(destTy->isVectorType() || srcTy->isVectorType());
5422 
5423  if (!Context.getLangOpts().LaxVectorConversions)
5424  return false;
5425  return VectorTypesMatch(*this, srcTy, destTy);
5426 }
5427 
5429  CastKind &Kind) {
5430  assert(VectorTy->isVectorType() && "Not a vector type!");
5431 
5432  if (Ty->isVectorType() || Ty->isIntegerType()) {
5433  if (!VectorTypesMatch(*this, Ty, VectorTy))
5434  return Diag(R.getBegin(),
5435  Ty->isVectorType() ?
5436  diag::err_invalid_conversion_between_vectors :
5437  diag::err_invalid_conversion_between_vector_and_integer)
5438  << VectorTy << Ty << R;
5439  } else
5440  return Diag(R.getBegin(),
5441  diag::err_invalid_conversion_between_vector_and_scalar)
5442  << VectorTy << Ty << R;
5443 
5444  Kind = CK_BitCast;
5445  return false;
5446 }
5447 
5449  Expr *CastExpr, CastKind &Kind) {
5450  assert(DestTy->isExtVectorType() && "Not an extended vector type!");
5451 
5452  QualType SrcTy = CastExpr->getType();
5453 
5454  // If SrcTy is a VectorType, the total size must match to explicitly cast to
5455  // an ExtVectorType.
5456  // In OpenCL, casts between vectors of different types are not allowed.
5457  // (See OpenCL 6.2).
5458  if (SrcTy->isVectorType()) {
5459  if (!VectorTypesMatch(*this, SrcTy, DestTy)
5460  || (getLangOpts().OpenCL &&
5461  (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) {
5462  Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
5463  << DestTy << SrcTy << R;
5464  return ExprError();
5465  }
5466  Kind = CK_BitCast;
5467  return CastExpr;
5468  }
5469 
5470  // All non-pointer scalars can be cast to ExtVector type. The appropriate
5471  // conversion will take place first from scalar to elt type, and then
5472  // splat from elt type to vector.
5473  if (SrcTy->isPointerType())
5474  return Diag(R.getBegin(),
5475  diag::err_invalid_conversion_between_vector_and_scalar)
5476  << DestTy << SrcTy << R;
5477 
5478  QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType();
5479  ExprResult CastExprRes = CastExpr;
5480  CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy);
5481  if (CastExprRes.isInvalid())
5482  return ExprError();
5483  CastExpr = ImpCastExprToType(CastExprRes.get(), DestElemTy, CK).get();
5484 
5485  Kind = CK_VectorSplat;
5486  return CastExpr;
5487 }
5488 
5489 ExprResult
5491  Declarator &D, ParsedType &Ty,
5492  SourceLocation RParenLoc, Expr *CastExpr) {
5493  assert(!D.isInvalidType() && (CastExpr != nullptr) &&
5494  "ActOnCastExpr(): missing type or expr");
5495 
5496  TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType());
5497  if (D.isInvalidType())
5498  return ExprError();
5499 
5500  if (getLangOpts().CPlusPlus) {
5501  // Check that there are no default arguments (C++ only).
5502  CheckExtraCXXDefaultArguments(D);
5503  } else {
5504  // Make sure any TypoExprs have been dealt with.
5505  ExprResult Res = CorrectDelayedTyposInExpr(CastExpr);
5506  if (!Res.isUsable())
5507  return ExprError();
5508  CastExpr = Res.get();
5509  }
5510 
5512 
5513  QualType castType = castTInfo->getType();
5514  Ty = CreateParsedType(castType, castTInfo);
5515 
5516  bool isVectorLiteral = false;
5517 
5518  // Check for an altivec or OpenCL literal,
5519  // i.e. all the elements are integer constants.
5520  ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
5521  ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
5522  if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL)
5523  && castType->isVectorType() && (PE || PLE)) {
5524  if (PLE && PLE->getNumExprs() == 0) {
5525  Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
5526  return ExprError();
5527  }
5528  if (PE || PLE->getNumExprs() == 1) {
5529  Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
5530  if (!E->getType()->isVectorType())
5531  isVectorLiteral = true;
5532  }
5533  else
5534  isVectorLiteral = true;
5535  }
5536 
5537  // If this is a vector initializer, '(' type ')' '(' init, ..., init ')'
5538  // then handle it as such.
5539  if (isVectorLiteral)
5540  return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo);
5541 
5542  // If the Expr being casted is a ParenListExpr, handle it specially.
5543  // This is not an AltiVec-style cast, so turn the ParenListExpr into a
5544  // sequence of BinOp comma operators.
5545  if (isa<ParenListExpr>(CastExpr)) {
5546  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
5547  if (Result.isInvalid()) return ExprError();
5548  CastExpr = Result.get();
5549  }
5550 
5551  if (getLangOpts().CPlusPlus && !castType->isVoidType() &&
5552  !getSourceManager().isInSystemMacro(LParenLoc))
5553  Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange();
5554 
5555  CheckTollFreeBridgeCast(castType, CastExpr);
5556 
5557  CheckObjCBridgeRelatedCast(castType, CastExpr);
5558 
5559  return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr);
5560 }
5561 
5563  SourceLocation RParenLoc, Expr *E,
5564  TypeSourceInfo *TInfo) {
5565  assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
5566  "Expected paren or paren list expression");
5567 
5568  Expr **exprs;
5569  unsigned numExprs;
5570  Expr *subExpr;
5571  SourceLocation LiteralLParenLoc, LiteralRParenLoc;
5572  if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) {
5573  LiteralLParenLoc = PE->getLParenLoc();
5574  LiteralRParenLoc = PE->getRParenLoc();
5575  exprs = PE->getExprs();
5576  numExprs = PE->getNumExprs();
5577  } else { // isa<ParenExpr> by assertion at function entrance
5578  LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
5579  LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
5580  subExpr = cast<ParenExpr>(E)->getSubExpr();
5581  exprs = &subExpr;
5582  numExprs = 1;
5583  }
5584 
5585  QualType Ty = TInfo->getType();
5586  assert(Ty->isVectorType() && "Expected vector type");
5587 
5588  SmallVector<Expr *, 8> initExprs;
5589  const VectorType *VTy = Ty->getAs<VectorType>();
5590  unsigned numElems = Ty->getAs<VectorType>()->getNumElements();
5591 
5592  // '(...)' form of vector initialization in AltiVec: the number of
5593  // initializers must be one or must match the size of the vector.
5594  // If a single value is specified in the initializer then it will be
5595  // replicated to all the components of the vector
5596  if (VTy->getVectorKind() == VectorType::AltiVecVector) {
5597  // The number of initializers must be one or must match the size of the
5598  // vector. If a single value is specified in the initializer then it will
5599  // be replicated to all the components of the vector
5600  if (numExprs == 1) {
5601  QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
5602  ExprResult Literal = DefaultLvalueConversion(exprs[0]);
5603  if (Literal.isInvalid())
5604  return ExprError();
5605  Literal = ImpCastExprToType(Literal.get(), ElemTy,
5606  PrepareScalarCast(Literal, ElemTy));
5607  return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
5608  }
5609  else if (numExprs < numElems) {
5610  Diag(E->getExprLoc(),
5611  diag::err_incorrect_number_of_vector_initializers);
5612  return ExprError();
5613  }
5614  else
5615  initExprs.append(exprs, exprs + numExprs);
5616  }
5617  else {
5618  // For OpenCL, when the number of initializers is a single value,
5619  // it will be replicated to all components of the vector.
5620  if (getLangOpts().OpenCL &&
5622  numExprs == 1) {
5623  QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
5624  ExprResult Literal = DefaultLvalueConversion(exprs[0]);
5625  if (Literal.isInvalid())
5626  return ExprError();
5627  Literal = ImpCastExprToType(Literal.get(), ElemTy,
5628  PrepareScalarCast(Literal, ElemTy));
5629  return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
5630  }
5631 
5632  initExprs.append(exprs, exprs + numExprs);
5633  }
5634  // FIXME: This means that pretty-printing the final AST will produce curly
5635  // braces instead of the original commas.
5636  InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
5637  initExprs, LiteralRParenLoc);
5638  initE->setType(Ty);
5639  return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
5640 }
5641 
5642 /// This is not an AltiVec-style cast or or C++ direct-initialization, so turn
5643 /// the ParenListExpr into a sequence of comma binary operators.
5644 ExprResult
5646  ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
5647  if (!E)
5648  return OrigExpr;
5649 
5650  ExprResult Result(E->getExpr(0));
5651 
5652  for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
5653  Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
5654  E->getExpr(i));
5655 
5656  if (Result.isInvalid()) return ExprError();
5657 
5658  return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
5659 }
5660 
5662  SourceLocation R,
5663  MultiExprArg Val) {
5664  Expr *expr = new (Context) ParenListExpr(Context, L, Val, R);
5665  return expr;
5666 }
5667 
5668 /// \brief Emit a specialized diagnostic when one expression is a null pointer
5669 /// constant and the other is not a pointer. Returns true if a diagnostic is
5670 /// emitted.
5672  SourceLocation QuestionLoc) {
5673  Expr *NullExpr = LHSExpr;
5674  Expr *NonPointerExpr = RHSExpr;
5676  NullExpr->isNullPointerConstant(Context,
5678 
5679  if (NullKind == Expr::NPCK_NotNull) {
5680  NullExpr = RHSExpr;
5681  NonPointerExpr = LHSExpr;
5682  NullKind =
5683  NullExpr->isNullPointerConstant(Context,
5685  }
5686 
5687  if (NullKind == Expr::NPCK_NotNull)
5688  return false;
5689 
5690  if (NullKind == Expr::NPCK_ZeroExpression)
5691  return false;
5692 
5693  if (NullKind == Expr::NPCK_ZeroLiteral) {
5694  // In this case, check to make sure that we got here from a "NULL"
5695  // string in the source code.
5696  NullExpr = NullExpr->IgnoreParenImpCasts();
5697  SourceLocation loc = NullExpr->getExprLoc();
5698  if (!findMacroSpelling(loc, "NULL"))
5699  return false;
5700  }
5701 
5702  int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
5703  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
5704  << NonPointerExpr->getType() << DiagType
5705  << NonPointerExpr->getSourceRange();
5706  return true;
5707 }
5708 
5709 /// \brief Return false if the condition expression is valid, true otherwise.
5710 static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) {
5711  QualType CondTy = Cond->getType();
5712 
5713  // OpenCL v1.1 s6.3.i says the condition cannot be a floating point type.
5714  if (S.getLangOpts().OpenCL && CondTy->isFloatingType()) {
5715  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
5716  << CondTy << Cond->getSourceRange();
5717  return true;
5718  }
5719 
5720  // C99 6.5.15p2
5721  if (CondTy->isScalarType()) return false;
5722 
5723  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
5724  << CondTy << Cond->getSourceRange();
5725  return true;
5726 }
5727 
5728 /// \brief Handle when one or both operands are void type.
5730  ExprResult &RHS) {
5731  Expr *LHSExpr = LHS.get();
5732  Expr *RHSExpr = RHS.get();
5733 
5734  if (!LHSExpr->getType()->isVoidType())
5735  S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void)
5736  << RHSExpr->getSourceRange();
5737  if (!RHSExpr->getType()->isVoidType())
5738  S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void)
5739  << LHSExpr->getSourceRange();
5740  LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid);
5741  RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid);
5742  return S.Context.VoidTy;
5743 }
5744 
5745 /// \brief Return false if the NullExpr can be promoted to PointerTy,
5746 /// true otherwise.
5747 static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
5748  QualType PointerTy) {
5749  if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
5750  !NullExpr.get()->isNullPointerConstant(S.Context,
5752  return true;
5753 
5754  NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer);
5755  return false;
5756 }
5757 
5758 /// \brief Checks compatibility between two pointers and return the resulting
5759 /// type.
5761  ExprResult &RHS,
5762  SourceLocation Loc) {
5763  QualType LHSTy = LHS.get()->getType();
5764  QualType RHSTy = RHS.get()->getType();
5765 
5766  if (S.Context.hasSameType(LHSTy, RHSTy)) {
5767  // Two identical pointers types are always compatible.
5768  return LHSTy;
5769  }
5770 
5771  QualType lhptee, rhptee;
5772 
5773  // Get the pointee types.
5774  bool IsBlockPointer = false;
5775  if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) {
5776  lhptee = LHSBTy->getPointeeType();
5777  rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType();
5778  IsBlockPointer = true;
5779  } else {
5780  lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
5781  rhptee = RHSTy->castAs<PointerType>()->getPointeeType();
5782  }
5783 
5784  // C99 6.5.15p6: If both operands are pointers to compatible types or to
5785  // differently qualified versions of compatible types, the result type is
5786  // a pointer to an appropriately qualified version of the composite
5787  // type.
5788 
5789  // Only CVR-qualifiers exist in the standard, and the differently-qualified
5790  // clause doesn't make sense for our extensions. E.g. address space 2 should
5791  // be incompatible with address space 3: they may live on different devices or
5792  // anything.
5793  Qualifiers lhQual = lhptee.getQualifiers();
5794  Qualifiers rhQual = rhptee.getQualifiers();
5795 
5796  unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
5797  lhQual.removeCVRQualifiers();
5798  rhQual.removeCVRQualifiers();
5799 
5800  lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual);
5801  rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual);
5802 
5803  QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee);
5804 
5805  if (CompositeTy.isNull()) {
5806  S.Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
5807  << LHSTy << RHSTy << LHS.get()->getSourceRange()
5808  << RHS.get()->getSourceRange();
5809  // In this situation, we assume void* type. No especially good
5810  // reason, but this is what gcc does, and we do have to pick
5811  // to get a consistent AST.
5812  QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy);
5813  LHS = S.ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast);
5814  RHS = S.ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast);
5815  return incompatTy;
5816  }
5817 
5818  // The pointer types are compatible.
5819  QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual);
5820  if (IsBlockPointer)
5821  ResultTy = S.Context.getBlockPointerType(ResultTy);
5822  else
5823  ResultTy = S.Context.getPointerType(ResultTy);
5824 
5825  LHS = S.ImpCastExprToType(LHS.get(), ResultTy, CK_BitCast);
5826  RHS = S.ImpCastExprToType(RHS.get(), ResultTy, CK_BitCast);
5827  return ResultTy;
5828 }
5829 
5830 /// \brief Return the resulting type when the operands are both block pointers.
5832  ExprResult &LHS,
5833  ExprResult &RHS,
5834  SourceLocation Loc) {
5835  QualType LHSTy = LHS.get()->getType();
5836  QualType RHSTy = RHS.get()->getType();
5837 
5838  if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
5839  if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
5840  QualType destType = S.Context.getPointerType(S.Context.VoidTy);
5841  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
5842  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
5843  return destType;
5844  }
5845  S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
5846  << LHSTy << RHSTy << LHS.get()->getSourceRange()
5847  << RHS.get()->getSourceRange();
5848  return QualType();
5849  }
5850 
5851  // We have 2 block pointer types.
5852  return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
5853 }
5854 
5855 /// \brief Return the resulting type when the operands are both pointers.
5856 static QualType
5858  ExprResult &RHS,
5859  SourceLocation Loc) {
5860  // get the pointer types
5861  QualType LHSTy = LHS.get()->getType();
5862  QualType RHSTy = RHS.get()->getType();
5863 
5864  // get the "pointed to" types
5865  QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
5866  QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
5867 
5868  // ignore qualifiers on void (C99 6.5.15p3, clause 6)
5869  if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
5870  // Figure out necessary qualifiers (C99 6.5.15p6)
5871  QualType destPointee
5872  = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
5873  QualType destType = S.Context.getPointerType(destPointee);
5874  // Add qualifiers if necessary.
5875  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp);
5876  // Promote to void*.
5877  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
5878  return destType;
5879  }
5880  if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
5881  QualType destPointee
5882  = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
5883  QualType destType = S.Context.getPointerType(destPointee);
5884  // Add qualifiers if necessary.
5885  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp);
5886  // Promote to void*.
5887  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
5888  return destType;
5889  }
5890 
5891  return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
5892 }
5893 
5894 /// \brief Return false if the first expression is not an integer and the second
5895 /// expression is not a pointer, true otherwise.
5897  Expr* PointerExpr, SourceLocation Loc,
5898  bool IsIntFirstExpr) {
5899  if (!PointerExpr->getType()->isPointerType() ||
5900  !Int.get()->getType()->isIntegerType())
5901  return false;
5902 
5903  Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
5904  Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
5905 
5906  S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
5907  << Expr1->getType() << Expr2->getType()
5908  << Expr1->getSourceRange() << Expr2->getSourceRange();
5909  Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(),
5911  return true;
5912 }
5913 
5914 /// \brief Simple conversion between integer and floating point types.
5915 ///
5916 /// Used when handling the OpenCL conditional operator where the
5917 /// condition is a vector while the other operands are scalar.
5918 ///
5919 /// OpenCL v1.1 s6.3.i and s6.11.6 together require that the scalar
5920 /// types are either integer or floating type. Between the two
5921 /// operands, the type with the higher rank is defined as the "result
5922 /// type". The other operand needs to be promoted to the same type. No
5923 /// other type promotion is allowed. We cannot use
5924 /// UsualArithmeticConversions() for this purpose, since it always
5925 /// promotes promotable types.
5927  ExprResult &RHS,
5928  SourceLocation QuestionLoc) {
5930  if (LHS.isInvalid())
5931  return QualType();
5933  if (RHS.isInvalid())
5934  return QualType();
5935 
5936  // For conversion purposes, we ignore any qualifiers.
5937  // For example, "const float" and "float" are equivalent.
5938  QualType LHSType =
5939  S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
5940  QualType RHSType =
5941  S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
5942 
5943  if (!LHSType->isIntegerType() && !LHSType->isRealFloatingType()) {
5944  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
5945  << LHSType << LHS.get()->getSourceRange();
5946  return QualType();
5947  }
5948 
5949  if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
5950  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
5951  << RHSType << RHS.get()->getSourceRange();
5952  return QualType();
5953  }
5954 
5955  // If both types are identical, no conversion is needed.
5956  if (LHSType == RHSType)
5957  return LHSType;
5958 
5959  // Now handle "real" floating types (i.e. float, double, long double).
5960  if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
5961  return handleFloatConversion(S, LHS, RHS, LHSType, RHSType,
5962  /*IsCompAssign = */ false);
5963 
5964  // Finally, we have two differing integer types.
5965  return handleIntegerConversion<doIntegralCast, doIntegralCast>
5966  (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
5967 }
5968 
5969 /// \brief Convert scalar operands to a vector that matches the
5970 /// condition in length.
5971 ///
5972 /// Used when handling the OpenCL conditional operator where the
5973 /// condition is a vector while the other operands are scalar.
5974 ///
5975 /// We first compute the "result type" for the scalar operands
5976 /// according to OpenCL v1.1 s6.3.i. Both operands are then converted
5977 /// into a vector of that type where the length matches the condition
5978 /// vector type. s6.11.6 requires that the element types of the result
5979 /// and the condition must have the same number of bits.
5980 static QualType
5982  QualType CondTy, SourceLocation QuestionLoc) {
5983  QualType ResTy = OpenCLArithmeticConversions(S, LHS, RHS, QuestionLoc);
5984  if (ResTy.isNull()) return QualType();
5985 
5986  const VectorType *CV = CondTy->getAs<VectorType>();
5987  assert(CV);
5988 
5989  // Determine the vector result type
5990  unsigned NumElements = CV->getNumElements();
5991  QualType VectorTy = S.Context.getExtVectorType(ResTy, NumElements);
5992 
5993  // Ensure that all types have the same number of bits
5994  if (S.Context.getTypeSize(CV->getElementType())
5995  != S.Context.getTypeSize(ResTy)) {
5996  // Since VectorTy is created internally, it does not pretty print
5997  // with an OpenCL name. Instead, we just print a description.
5998  std::string EleTyName = ResTy.getUnqualifiedType().getAsString();
5999  SmallString<64> Str;
6000  llvm::raw_svector_ostream OS(Str);
6001  OS << "(vector of " << NumElements << " '" << EleTyName << "' values)";
6002  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
6003  << CondTy << OS.str();
6004  return QualType();
6005  }
6006 
6007  // Convert operands to the vector result type
6008  LHS = S.ImpCastExprToType(LHS.get(), VectorTy, CK_VectorSplat);
6009  RHS = S.ImpCastExprToType(RHS.get(), VectorTy, CK_VectorSplat);
6010 
6011  return VectorTy;
6012 }
6013 
6014 /// \brief Return false if this is a valid OpenCL condition vector
6015 static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
6016  SourceLocation QuestionLoc) {
6017  // OpenCL v1.1 s6.11.6 says the elements of the vector must be of
6018  // integral type.
6019  const VectorType *CondTy = Cond->getType()->getAs<VectorType>();
6020  assert(CondTy);
6021  QualType EleTy = CondTy->getElementType();
6022  if (EleTy->isIntegerType()) return false;
6023 
6024  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
6025  << Cond->getType() << Cond->getSourceRange();
6026  return true;
6027 }
6028 
6029 /// \brief Return false if the vector condition type and the vector
6030 /// result type are compatible.
6031 ///
6032 /// OpenCL v1.1 s6.11.6 requires that both vector types have the same
6033 /// number of elements, and their element types have the same number
6034 /// of bits.
6035 static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
6036  SourceLocation QuestionLoc) {
6037  const VectorType *CV = CondTy->getAs<VectorType>();
6038  const VectorType *RV = VecResTy->getAs<VectorType>();
6039  assert(CV && RV);
6040 
6041  if (CV->getNumElements() != RV->getNumElements()) {
6042  S.Diag(QuestionLoc, diag::err_conditional_vector_size)
6043  << CondTy << VecResTy;
6044  return true;
6045  }
6046 
6047  QualType CVE = CV->getElementType();
6048  QualType RVE = RV->getElementType();
6049 
6050  if (S.Context.getTypeSize(CVE) != S.Context.getTypeSize(RVE)) {
6051  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
6052  << CondTy << VecResTy;
6053  return true;
6054  }
6055 
6056  return false;
6057 }
6058 
6059 /// \brief Return the resulting type for the conditional operator in
6060 /// OpenCL (aka "ternary selection operator", OpenCL v1.1
6061 /// s6.3.i) when the condition is a vector type.
6062 static QualType
6064  ExprResult &LHS, ExprResult &RHS,
6065  SourceLocation QuestionLoc) {
6066  Cond = S.DefaultFunctionArrayLvalueConversion(Cond.get());
6067  if (Cond.isInvalid())
6068  return QualType();
6069  QualType CondTy = Cond.get()->getType();
6070 
6071  if (checkOpenCLConditionVector(S, Cond.get(), QuestionLoc))
6072  return QualType();
6073 
6074  // If either operand is a vector then find the vector type of the
6075  // result as specified in OpenCL v1.1 s6.3.i.
6076  if (LHS.get()->getType()->isVectorType() ||
6077  RHS.get()->getType()->isVectorType()) {
6078  QualType VecResTy = S.CheckVectorOperands(LHS, RHS, QuestionLoc,
6079  /*isCompAssign*/false,
6080  /*AllowBothBool*/true,
6081  /*AllowBoolConversions*/false);
6082  if (VecResTy.isNull()) return QualType();
6083  // The result type must match the condition type as specified in
6084  // OpenCL v1.1 s6.11.6.
6085  if (checkVectorResult(S, CondTy, VecResTy, QuestionLoc))
6086  return QualType();
6087  return VecResTy;
6088  }
6089 
6090  // Both operands are scalar.
6091  return OpenCLConvertScalarsToVectors(S, LHS, RHS, CondTy, QuestionLoc);
6092 }
6093 
6094 /// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
6095 /// In that case, LHS = cond.
6096 /// C99 6.5.15
6098  ExprResult &RHS, ExprValueKind &VK,
6099  ExprObjectKind &OK,
6100  SourceLocation QuestionLoc) {
6101 
6102  ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
6103  if (!LHSResult.isUsable()) return QualType();
6104  LHS = LHSResult;
6105 
6106  ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
6107  if (!RHSResult.isUsable()) return QualType();
6108  RHS = RHSResult;
6109 
6110  // C++ is sufficiently different to merit its own checker.
6111  if (getLangOpts().CPlusPlus)
6112  return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
6113 
6114  VK = VK_RValue;
6115  OK = OK_Ordinary;
6116 
6117  // The OpenCL operator with a vector condition is sufficiently
6118  // different to merit its own checker.
6119  if (getLangOpts().OpenCL && Cond.get()->getType()->isVectorType())
6120  return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);
6121 
6122  // First, check the condition.
6123  Cond = UsualUnaryConversions(Cond.get());
6124  if (Cond.isInvalid())
6125  return QualType();
6126  if (checkCondition(*this, Cond.get(), QuestionLoc))
6127  return QualType();
6128 
6129  // Now check the two expressions.
6130  if (LHS.get()->getType()->isVectorType() ||
6131  RHS.get()->getType()->isVectorType())
6132  return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
6133  /*AllowBothBool*/true,
6134  /*AllowBoolConversions*/false);
6135 
6136  QualType ResTy = UsualArithmeticConversions(LHS, RHS);
6137  if (LHS.isInvalid() || RHS.isInvalid())
6138  return QualType();
6139 
6140  QualType LHSTy = LHS.get()->getType();
6141  QualType RHSTy = RHS.get()->getType();
6142 
6143  // If both operands have arithmetic type, do the usual arithmetic conversions
6144  // to find a common type: C99 6.5.15p3,5.
6145  if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
6146  LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
6147  RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
6148 
6149  return ResTy;
6150  }
6151 
6152  // If both operands are the same structure or union type, the result is that
6153  // type.
6154  if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3
6155  if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
6156  if (LHSRT->getDecl() == RHSRT->getDecl())
6157  // "If both the operands have structure or union type, the result has
6158  // that type." This implies that CV qualifiers are dropped.
6159  return LHSTy.getUnqualifiedType();
6160  // FIXME: Type of conditional expression must be complete in C mode.
6161  }
6162 
6163  // C99 6.5.15p5: "If both operands have void type, the result has void type."
6164  // The following || allows only one side to be void (a GCC-ism).
6165  if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
6166  return checkConditionalVoidType(*this, LHS, RHS);
6167  }
6168 
6169  // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
6170  // the type of the other operand."
6171  if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
6172  if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;
6173 
6174  // All objective-c pointer type analysis is done here.
6175  QualType compositeType = FindCompositeObjCPointerType(LHS, RHS,
6176  QuestionLoc);
6177  if (LHS.isInvalid() || RHS.isInvalid())
6178  return QualType();
6179  if (!compositeType.isNull())
6180  return compositeType;
6181 
6182 
6183  // Handle block pointer types.
6184  if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
6185  return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
6186  QuestionLoc);
6187 
6188  // Check constraints for C object pointers types (C99 6.5.15p3,6).
6189  if (LHSTy->isPointerType() && RHSTy->isPointerType())
6190  return checkConditionalObjectPointersCompatibility(*this, LHS, RHS,
6191  QuestionLoc);
6192 
6193  // GCC compatibility: soften pointer/integer mismatch. Note that
6194  // null pointers have been filtered out by this point.
6195  if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
6196  /*isIntFirstExpr=*/true))
6197  return RHSTy;
6198  if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
6199  /*isIntFirstExpr=*/false))
6200  return LHSTy;
6201 
6202  // Emit a better diagnostic if one of the expressions is a null pointer
6203  // constant and the other is not a pointer type. In this case, the user most
6204  // likely forgot to take the address of the other expression.
6205  if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
6206  return QualType();
6207 
6208  // Otherwise, the operands are not compatible.
6209  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6210  << LHSTy << RHSTy << LHS.get()->getSourceRange()
6211  << RHS.get()->getSourceRange();
6212  return QualType();
6213 }
6214 
6215 /// FindCompositeObjCPointerType - Helper method to find composite type of
6216 /// two objective-c pointer types of the two input expressions.
6218  SourceLocation QuestionLoc) {
6219  QualType LHSTy = LHS.get()->getType();
6220  QualType RHSTy = RHS.get()->getType();
6221 
6222  // Handle things like Class and struct objc_class*. Here we case the result
6223  // to the pseudo-builtin, because that will be implicitly cast back to the
6224  // redefinition type if an attempt is made to access its fields.
6225  if (LHSTy->isObjCClassType() &&
6227  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
6228  return LHSTy;
6229  }
6230  if (RHSTy->isObjCClassType() &&
6232  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
6233  return RHSTy;
6234  }
6235  // And the same for struct objc_object* / id
6236  if (LHSTy->isObjCIdType() &&
6238  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
6239  return LHSTy;
6240  }
6241  if (RHSTy->isObjCIdType() &&
6243  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
6244  return RHSTy;
6245  }
6246  // And the same for struct objc_selector* / SEL
6247  if (Context.isObjCSelType(LHSTy) &&
6249  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast);
6250  return LHSTy;
6251  }
6252  if (Context.isObjCSelType(RHSTy) &&
6254  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast);
6255  return RHSTy;
6256  }
6257  // Check constraints for Objective-C object pointers types.
6258  if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {
6259 
6260  if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
6261  // Two identical object pointer types are always compatible.
6262  return LHSTy;
6263  }
6264  const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>();
6265  const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>();
6266  QualType compositeType = LHSTy;
6267 
6268  // If both operands are interfaces and either operand can be
6269  // assigned to the other, use that type as the composite
6270  // type. This allows
6271  // xxx ? (A*) a : (B*) b
6272  // where B is a subclass of A.
6273  //
6274  // Additionally, as for assignment, if either type is 'id'
6275  // allow silent coercion. Finally, if the types are
6276  // incompatible then make sure to use 'id' as the composite
6277  // type so the result is acceptable for sending messages to.
6278 
6279  // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
6280  // It could return the composite type.
6281  if (!(compositeType =
6282  Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) {
6283  // Nothing more to do.
6284  } else if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
6285  compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
6286  } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
6287  compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
6288  } else if ((LHSTy->isObjCQualifiedIdType() ||
6289  RHSTy->isObjCQualifiedIdType()) &&
6290  Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) {
6291  // Need to handle "id<xx>" explicitly.
6292  // GCC allows qualified id and any Objective-C type to devolve to
6293  // id. Currently localizing to here until clear this should be
6294  // part of ObjCQualifiedIdTypesAreCompatible.
6295  compositeType = Context.getObjCIdType();
6296  } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
6297  compositeType = Context.getObjCIdType();
6298  } else {
6299  Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
6300  << LHSTy << RHSTy
6301  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
6302  QualType incompatTy = Context.getObjCIdType();
6303  LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast);
6304  RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast);
6305  return incompatTy;
6306  }
6307  // The object pointer types are compatible.
6308  LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast);
6309  RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast);
6310  return compositeType;
6311  }
6312  // Check Objective-C object pointer types and 'void *'
6313  if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
6314  if (getLangOpts().ObjCAutoRefCount) {
6315  // ARC forbids the implicit conversion of object pointers to 'void *',
6316  // so these types are not compatible.
6317  Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
6318  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
6319  LHS = RHS = true;
6320  return QualType();
6321  }
6322  QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
6323  QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
6324  QualType destPointee
6325  = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
6326  QualType destType = Context.getPointerType(destPointee);
6327  // Add qualifiers if necessary.
6328  LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp);
6329  // Promote to void*.
6330  RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast);
6331  return destType;
6332  }
6333  if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
6334  if (getLangOpts().ObjCAutoRefCount) {
6335  // ARC forbids the implicit conversion of object pointers to 'void *',
6336  // so these types are not compatible.
6337  Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
6338  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
6339  LHS = RHS = true;
6340  return QualType();
6341  }
6342  QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
6343  QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
6344  QualType destPointee
6345  = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
6346  QualType destType = Context.getPointerType(destPointee);
6347  // Add qualifiers if necessary.
6348  RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp);
6349  // Promote to void*.
6350  LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast);
6351  return destType;
6352  }
6353  return QualType();
6354 }
6355 
6356 /// SuggestParentheses - Emit a note with a fixit hint that wraps
6357 /// ParenRange in parentheses.
6358 static void SuggestParentheses(Sema &Self, SourceLocation Loc,
6359  const PartialDiagnostic &Note,
6360  SourceRange ParenRange) {
6361  SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd());
6362  if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
6363  EndLoc.isValid()) {
6364  Self.Diag(Loc, Note)
6365  << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
6366  << FixItHint::CreateInsertion(EndLoc, ")");
6367  } else {
6368  // We can't display the parentheses, so just show the bare note.
6369  Self.Diag(Loc, Note) << ParenRange;
6370  }
6371 }
6372 
6374  return Opc >= BO_Mul && Opc <= BO_Shr;
6375 }
6376 
6377 /// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary
6378 /// expression, either using a built-in or overloaded operator,
6379 /// and sets *OpCode to the opcode and *RHSExprs to the right-hand side
6380 /// expression.
6382  Expr **RHSExprs) {
6383  // Don't strip parenthesis: we should not warn if E is in parenthesis.
6384  E = E->IgnoreImpCasts();
6385  E = E->IgnoreConversionOperator();
6386  E = E->IgnoreImpCasts();
6387 
6388  // Built-in binary operator.
6389  if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) {
6390  if (IsArithmeticOp(OP->getOpcode())) {
6391  *Opcode = OP->getOpcode();
6392  *RHSExprs = OP->getRHS();
6393  return true;
6394  }
6395  }
6396 
6397  // Overloaded operator.
6398  if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) {
6399  if (Call->getNumArgs() != 2)
6400  return false;
6401 
6402  // Make sure this is really a binary operator that is safe to pass into
6403  // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
6404  OverloadedOperatorKind OO = Call->getOperator();
6405  if (OO < OO_Plus || OO > OO_Arrow ||
6406  OO == OO_PlusPlus || OO == OO_MinusMinus)
6407  return false;
6408 
6410  if (IsArithmeticOp(OpKind)) {
6411  *Opcode = OpKind;
6412  *RHSExprs = Call->getArg(1);
6413  return true;
6414  }
6415  }
6416 
6417  return false;
6418 }
6419 
6420 static bool IsLogicOp(BinaryOperatorKind Opc) {
6421  return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr);
6422 }
6423 
6424 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
6425 /// or is a logical expression such as (x==y) which has int type, but is
6426 /// commonly interpreted as boolean.
6427 static bool ExprLooksBoolean(Expr *E) {
6428  E = E->IgnoreParenImpCasts();
6429 
6430  if (E->getType()->isBooleanType())
6431  return true;
6432  if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E))
6433  return IsLogicOp(OP->getOpcode());
6434  if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E))
6435  return OP->getOpcode() == UO_LNot;
6436  if (E->getType()->isPointerType())
6437  return true;
6438 
6439  return false;
6440 }
6441 
6442 /// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator
6443 /// and binary operator are mixed in a way that suggests the programmer assumed
6444 /// the conditional operator has higher precedence, for example:
6445 /// "int x = a + someBinaryCondition ? 1 : 2".
6447  SourceLocation OpLoc,
6448  Expr *Condition,
6449  Expr *LHSExpr,
6450  Expr *RHSExpr) {
6451  BinaryOperatorKind CondOpcode;
6452  Expr *CondRHS;
6453 
6454  if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS))
6455  return;
6456  if (!ExprLooksBoolean(CondRHS))
6457  return;
6458 
6459  // The condition is an arithmetic binary expression, with a right-
6460  // hand side that looks boolean, so warn.
6461 
6462  Self.Diag(OpLoc, diag::warn_precedence_conditional)
6463  << Condition->getSourceRange()
6464  << BinaryOperator::getOpcodeStr(CondOpcode);
6465 
6466  SuggestParentheses(Self, OpLoc,
6467  Self.PDiag(diag::note_precedence_silence)
6468  << BinaryOperator::getOpcodeStr(CondOpcode),
6469  SourceRange(Condition->getLocStart(), Condition->getLocEnd()));
6470 
6471  SuggestParentheses(Self, OpLoc,
6472  Self.PDiag(diag::note_precedence_conditional_first),
6473  SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd()));
6474 }
6475 
6476 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
6477 /// in the case of a the GNU conditional expr extension.
6480  Expr *CondExpr, Expr *LHSExpr,
6481  Expr *RHSExpr) {
6482  if (!getLangOpts().CPlusPlus) {
6483  // C cannot handle TypoExpr nodes in the condition because it
6484  // doesn't handle dependent types properly, so make sure any TypoExprs have
6485  // been dealt with before checking the operands.
6486  ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr);
6487  if (!CondResult.isUsable()) return ExprError();
6488  CondExpr = CondResult.get();
6489  }
6490 
6491  // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
6492  // was the condition.
6493  OpaqueValueExpr *opaqueValue = nullptr;
6494  Expr *commonExpr = nullptr;
6495  if (!LHSExpr) {
6496  commonExpr = CondExpr;
6497  // Lower out placeholder types first. This is important so that we don't
6498  // try to capture a placeholder. This happens in few cases in C++; such
6499  // as Objective-C++'s dictionary subscripting syntax.
6500  if (commonExpr->hasPlaceholderType()) {
6501  ExprResult result = CheckPlaceholderExpr(commonExpr);
6502  if (!result.isUsable()) return ExprError();
6503  commonExpr = result.get();
6504  }
6505  // We usually want to apply unary conversions *before* saving, except
6506  // in the special case of a C++ l-value conditional.
6507  if (!(getLangOpts().CPlusPlus
6508  && !commonExpr->isTypeDependent()
6509  && commonExpr->getValueKind() == RHSExpr->getValueKind()
6510  && commonExpr->isGLValue()
6511  && commonExpr->isOrdinaryOrBitFieldObject()
6512  && RHSExpr->isOrdinaryOrBitFieldObject()
6513  && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
6514  ExprResult commonRes = UsualUnaryConversions(commonExpr);
6515  if (commonRes.isInvalid())
6516  return ExprError();
6517  commonExpr = commonRes.get();
6518  }
6519 
6520  opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
6521  commonExpr->getType(),
6522  commonExpr->getValueKind(),
6523  commonExpr->getObjectKind(),
6524  commonExpr);
6525  LHSExpr = CondExpr = opaqueValue;
6526  }
6527 
6528  ExprValueKind VK = VK_RValue;
6530  ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
6531  QualType result = CheckConditionalOperands(Cond, LHS, RHS,
6532  VK, OK, QuestionLoc);
6533  if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
6534  RHS.isInvalid())
6535  return ExprError();
6536 
6537  DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
6538  RHS.get());
6539 
6540  CheckBoolLikeConversion(Cond.get(), QuestionLoc);
6541 
6542  if (!commonExpr)
6543  return new (Context)
6544  ConditionalOperator(Cond.get(), QuestionLoc, LHS.get(), ColonLoc,
6545  RHS.get(), result, VK, OK);
6546 
6547  return new (Context) BinaryConditionalOperator(
6548  commonExpr, opaqueValue, Cond.get(), LHS.get(), RHS.get(), QuestionLoc,
6549  ColonLoc, result, VK, OK);
6550 }
6551 
6552 // checkPointerTypesForAssignment - This is a very tricky routine (despite
6553 // being closely modeled after the C99 spec:-). The odd characteristic of this
6554 // routine is it effectively iqnores the qualifiers on the top level pointee.
6555 // This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
6556 // FIXME: add a couple examples in this comment.
6559  assert(LHSType.isCanonical() && "LHS not canonicalized!");
6560  assert(RHSType.isCanonical() && "RHS not canonicalized!");
6561 
6562  // get the "pointed to" type (ignoring qualifiers at the top level)
6563  const Type *lhptee, *rhptee;
6564  Qualifiers lhq, rhq;
6565  std::tie(lhptee, lhq) =
6566  cast<PointerType>(LHSType)->getPointeeType().split().asPair();
6567  std::tie(rhptee, rhq) =
6568  cast<PointerType>(RHSType)->getPointeeType().split().asPair();
6569 
6571 
6572  // C99 6.5.16.1p1: This following citation is common to constraints
6573  // 3 & 4 (below). ...and the type *pointed to* by the left has all the
6574  // qualifiers of the type *pointed to* by the right;
6575 
6576  // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay.
6577  if (lhq.getObjCLifetime() != rhq.getObjCLifetime() &&
6578  lhq.compatiblyIncludesObjCLifetime(rhq)) {
6579  // Ignore lifetime for further calculation.
6580  lhq.removeObjCLifetime();
6581  rhq.removeObjCLifetime();
6582  }
6583 
6584  if (!lhq.compatiblyIncludes(rhq)) {
6585  // Treat address-space mismatches as fatal. TODO: address subspaces
6586  if (!lhq.isAddressSpaceSupersetOf(rhq))
6588 
6589  // It's okay to add or remove GC or lifetime qualifiers when converting to
6590  // and from void*.
6591  else if (lhq.withoutObjCGCAttr().withoutObjCLifetime()
6594  && (lhptee->isVoidType() || rhptee->isVoidType()))
6595  ; // keep old
6596 
6597  // Treat lifetime mismatches as fatal.
6598  else if (lhq.getObjCLifetime() != rhq.getObjCLifetime())
6600 
6601  // For GCC compatibility, other qualifier mismatches are treated
6602  // as still compatible in C.
6604  }
6605 
6606  // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
6607  // incomplete type and the other is a pointer to a qualified or unqualified
6608  // version of void...
6609  if (lhptee->isVoidType()) {
6610  if (rhptee->isIncompleteOrObjectType())
6611  return ConvTy;
6612 
6613  // As an extension, we allow cast to/from void* to function pointer.
6614  assert(rhptee->isFunctionType());
6616  }
6617 
6618  if (rhptee->isVoidType()) {
6619  if (lhptee->isIncompleteOrObjectType())
6620  return ConvTy;
6621 
6622  // As an extension, we allow cast to/from void* to function pointer.
6623  assert(lhptee->isFunctionType());
6625  }
6626 
6627  // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
6628  // unqualified versions of compatible types, ...
6629  QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0);
6630  if (!S.Context.typesAreCompatible(ltrans, rtrans)) {
6631  // Check if the pointee types are compatible ignoring the sign.
6632  // We explicitly check for char so that we catch "char" vs
6633  // "unsigned char" on systems where "char" is unsigned.
6634  if (lhptee->isCharType())
6635  ltrans = S.Context.UnsignedCharTy;
6636  else if (lhptee->hasSignedIntegerRepresentation())
6637  ltrans = S.Context.getCorrespondingUnsignedType(ltrans);
6638 
6639  if (rhptee->isCharType())
6640  rtrans = S.Context.UnsignedCharTy;
6641  else if (rhptee->hasSignedIntegerRepresentation())
6642  rtrans = S.Context.getCorrespondingUnsignedType(rtrans);
6643 
6644  if (ltrans == rtrans) {
6645  // Types are compatible ignoring the sign. Qualifier incompatibility
6646  // takes priority over sign incompatibility because the sign
6647  // warning can be disabled.
6648  if (ConvTy != Sema::Compatible)
6649  return ConvTy;
6650 
6652  }
6653 
6654  // If we are a multi-level pointer, it's possible that our issue is simply
6655  // one of qualification - e.g. char ** -> const char ** is not allowed. If
6656  // the eventual target type is the same and the pointers have the same
6657  // level of indirection, this must be the issue.
6658  if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
6659  do {
6660  lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr();
6661  rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr();
6662  } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
6663 
6664  if (lhptee == rhptee)
6666  }
6667 
6668  // General pointer incompatibility takes priority over qualifiers.
6670  }
6671  if (!S.getLangOpts().CPlusPlus &&
6672  S.IsNoReturnConversion(ltrans, rtrans, ltrans))
6674  return ConvTy;
6675 }
6676 
6677 /// checkBlockPointerTypesForAssignment - This routine determines whether two
6678 /// block pointer types are compatible or whether a block and normal pointer
6679 /// are compatible. It is more restrict than comparing two function pointer
6680 // types.
6683  QualType RHSType) {
6684  assert(LHSType.isCanonical() && "LHS not canonicalized!");
6685  assert(RHSType.isCanonical() && "RHS not canonicalized!");
6686 
6687  QualType lhptee, rhptee;
6688 
6689  // get the "pointed to" type (ignoring qualifiers at the top level)
6690  lhptee = cast<BlockPointerType>(LHSType)->getPointeeType();
6691  rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();
6692 
6693  // In C++, the types have to match exactly.
6694  if (S.getLangOpts().CPlusPlus)
6696 
6698 
6699  // For blocks we enforce that qualifiers are identical.
6700  if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers())
6702 
6703  if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
6705 
6706  return ConvTy;
6707 }
6708 
6709 /// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
6710 /// for assignment compatibility.
6713  QualType RHSType) {
6714  assert(LHSType.isCanonical() && "LHS was not canonicalized!");
6715  assert(RHSType.isCanonical() && "RHS was not canonicalized!");
6716 
6717  if (LHSType->isObjCBuiltinType()) {
6718  // Class is not compatible with ObjC object pointers.
6719  if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
6720  !RHSType->isObjCQualifiedClassType())
6722  return Sema::Compatible;
6723  }
6724  if (RHSType->isObjCBuiltinType()) {
6725  if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
6726  !LHSType->isObjCQualifiedClassType())
6728  return Sema::Compatible;
6729  }
6730  QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
6731  QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
6732 
6733  if (!lhptee.isAtLeastAsQualifiedAs(rhptee) &&
6734  // make an exception for id<P>
6735  !LHSType->isObjCQualifiedIdType())
6737 
6738  if (S.Context.typesAreCompatible(LHSType, RHSType))
6739  return Sema::Compatible;
6740  if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
6743 }
6744 
6747  QualType LHSType, QualType RHSType) {
6748  // Fake up an opaque expression. We don't actually care about what
6749  // cast operations are required, so if CheckAssignmentConstraints
6750  // adds casts to this they'll be wasted, but fortunately that doesn't
6751  // usually happen on valid code.
6752  OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
6753  ExprResult RHSPtr = &RHSExpr;
6754  CastKind K = CK_Invalid;
6755 
6756  return CheckAssignmentConstraints(LHSType, RHSPtr, K);
6757 }
6758 
6759 /// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
6760 /// has code to accommodate several GCC extensions when type checking
6761 /// pointers. Here are some objectionable examples that GCC considers warnings:
6762 ///
6763 /// int a, *pint;
6764 /// short *pshort;
6765 /// struct foo *pfoo;
6766 ///
6767 /// pint = pshort; // warning: assignment from incompatible pointer type
6768 /// a = pint; // warning: assignment makes integer from pointer without a cast
6769 /// pint = a; // warning: assignment makes pointer from integer without a cast
6770 /// pint = pfoo; // warning: assignment from incompatible pointer type
6771 ///
6772 /// As a result, the code for dealing with pointers is more complex than the
6773 /// C99 spec dictates.
6774 ///
6775 /// Sets 'Kind' for any result kind except Incompatible.
6778  CastKind &Kind) {
6779  QualType RHSType = RHS.get()->getType();
6780  QualType OrigLHSType = LHSType;
6781 
6782  // Get canonical types. We're not formatting these types, just comparing
6783  // them.
6784  LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType();
6785  RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();
6786 
6787  // Common case: no conversion required.
6788  if (LHSType == RHSType) {
6789  Kind = CK_NoOp;
6790  return Compatible;
6791  }
6792 
6793  // If we have an atomic type, try a non-atomic assignment, then just add an
6794  // atomic qualification step.
6795  if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
6796  Sema::AssignConvertType result =
6797  CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind);
6798  if (result != Compatible)
6799  return result;
6800  if (Kind != CK_NoOp)
6801  RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind);
6802  Kind = CK_NonAtomicToAtomic;
6803  return Compatible;
6804  }
6805 
6806  // If the left-hand side is a reference type, then we are in a
6807  // (rare!) case where we've allowed the use of references in C,
6808  // e.g., as a parameter type in a built-in function. In this case,
6809  // just make sure that the type referenced is compatible with the
6810  // right-hand side type. The caller is responsible for adjusting
6811  // LHSType so that the resulting expression does not have reference
6812  // type.
6813  if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) {
6814  if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
6815  Kind = CK_LValueBitCast;
6816  return Compatible;
6817  }
6818  return Incompatible;
6819  }
6820 
6821  // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
6822  // to the same ExtVector type.
6823  if (LHSType->isExtVectorType()) {
6824  if (RHSType->isExtVectorType())
6825  return Incompatible;
6826  if (RHSType->isArithmeticType()) {
6827  // CK_VectorSplat does T -> vector T, so first cast to the
6828  // element type.
6829  QualType elType = cast<ExtVectorType>(LHSType)->getElementType();
6830  if (elType != RHSType) {
6831  Kind = PrepareScalarCast(RHS, elType);
6832  RHS = ImpCastExprToType(RHS.get(), elType, Kind);
6833  }
6834  Kind = CK_VectorSplat;
6835  return Compatible;
6836  }
6837  }
6838 
6839  // Conversions to or from vector type.
6840  if (LHSType->isVectorType() || RHSType->isVectorType()) {
6841  if (LHSType->isVectorType() && RHSType->isVectorType()) {
6842  // Allow assignments of an AltiVec vector type to an equivalent GCC
6843  // vector type and vice versa
6844  if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
6845  Kind = CK_BitCast;
6846  return Compatible;
6847  }
6848 
6849  // If we are allowing lax vector conversions, and LHS and RHS are both
6850  // vectors, the total size only needs to be the same. This is a bitcast;
6851  // no bits are changed but the result type is different.
6852  if (isLaxVectorConversion(RHSType, LHSType)) {
6853  Kind = CK_BitCast;
6854  return IncompatibleVectors;
6855  }
6856  }
6857  return Incompatible;
6858  }
6859 
6860  // Arithmetic conversions.
6861  if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
6862  !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
6863  Kind = PrepareScalarCast(RHS, LHSType);
6864  return Compatible;
6865  }
6866 
6867  // Conversions to normal pointers.
6868  if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
6869  // U* -> T*
6870  if (isa<PointerType>(RHSType)) {
6871  unsigned AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
6872  unsigned AddrSpaceR = RHSType->getPointeeType().getAddressSpace();
6873  Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
6874  return checkPointerTypesForAssignment(*this, LHSType, RHSType);
6875  }
6876 
6877  // int -> T*
6878  if (RHSType->isIntegerType()) {
6879  Kind = CK_IntegralToPointer; // FIXME: null?
6880  return IntToPointer;
6881  }
6882 
6883  // C pointers are not compatible with ObjC object pointers,
6884  // with two exceptions:
6885  if (isa<ObjCObjectPointerType>(RHSType)) {
6886  // - conversions to void*
6887  if (LHSPointer->getPointeeType()->isVoidType()) {
6888  Kind = CK_BitCast;
6889  return Compatible;
6890  }
6891 
6892  // - conversions from 'Class' to the redefinition type
6893  if (RHSType->isObjCClassType() &&
6894  Context.hasSameType(LHSType,
6896  Kind = CK_BitCast;
6897  return Compatible;
6898  }
6899 
6900  Kind = CK_BitCast;
6901  return IncompatiblePointer;
6902  }
6903 
6904  // U^ -> void*
6905  if (RHSType->getAs<BlockPointerType>()) {
6906  if (LHSPointer->getPointeeType()->isVoidType()) {
6907  Kind = CK_BitCast;
6908  return Compatible;
6909  }
6910  }
6911 
6912  return Incompatible;
6913  }
6914 
6915  // Conversions to block pointers.
6916  if (isa<BlockPointerType>(LHSType)) {
6917  // U^ -> T^
6918  if (RHSType->isBlockPointerType()) {
6919  Kind = CK_BitCast;
6920  return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
6921  }
6922 
6923  // int or null -> T^
6924  if (RHSType->isIntegerType()) {
6925  Kind = CK_IntegralToPointer; // FIXME: null
6926  return IntToBlockPointer;
6927  }
6928 
6929  // id -> T^
6930  if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) {
6932  return Compatible;
6933  }
6934 
6935  // void* -> T^
6936  if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
6937  if (RHSPT->getPointeeType()->isVoidType()) {
6939  return Compatible;
6940  }
6941 
6942  return Incompatible;
6943  }
6944 
6945  // Conversions to Objective-C pointers.
6946  if (isa<ObjCObjectPointerType>(LHSType)) {
6947  // A* -> B*
6948  if (RHSType->isObjCObjectPointerType()) {
6949  Kind = CK_BitCast;
6950  Sema::AssignConvertType result =
6951  checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
6952  if (getLangOpts().ObjCAutoRefCount &&
6953  result == Compatible &&
6954  !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
6955  result = IncompatibleObjCWeakRef;
6956  return result;
6957  }
6958 
6959  // int or null -> A*
6960  if (RHSType->isIntegerType()) {
6961  Kind = CK_IntegralToPointer; // FIXME: null
6962  return IntToPointer;
6963  }
6964 
6965  // In general, C pointers are not compatible with ObjC object pointers,
6966  // with two exceptions:
6967  if (isa<PointerType>(RHSType)) {
6969 
6970  // - conversions from 'void*'
6971  if (RHSType->isVoidPointerType()) {
6972  return Compatible;
6973  }
6974 
6975  // - conversions to 'Class' from its redefinition type
6976  if (LHSType->isObjCClassType() &&
6977  Context.hasSameType(RHSType,
6979  return Compatible;
6980  }
6981 
6982  return IncompatiblePointer;
6983  }
6984 
6985  // Only under strict condition T^ is compatible with an Objective-C pointer.
6986  if (RHSType->isBlockPointerType() &&
6988  maybeExtendBlockObject(RHS);
6990  return Compatible;
6991  }
6992 
6993  return Incompatible;
6994  }
6995 
6996  // Conversions from pointers that are not covered by the above.
6997  if (isa<PointerType>(RHSType)) {
6998  // T* -> _Bool
6999  if (LHSType == Context.BoolTy) {
7000  Kind = CK_PointerToBoolean;
7001  return Compatible;
7002  }
7003 
7004  // T* -> int
7005  if (LHSType->isIntegerType()) {
7006  Kind = CK_PointerToIntegral;
7007  return PointerToInt;
7008  }
7009 
7010  return Incompatible;
7011  }
7012 
7013  // Conversions from Objective-C pointers that are not covered by the above.
7014  if (isa<ObjCObjectPointerType>(RHSType)) {
7015  // T* -> _Bool
7016  if (LHSType == Context.BoolTy) {
7017  Kind = CK_PointerToBoolean;
7018  return Compatible;
7019  }
7020 
7021  // T* -> int
7022  if (LHSType->isIntegerType()) {
7023  Kind = CK_PointerToIntegral;
7024  return PointerToInt;
7025  }
7026 
7027  return Incompatible;
7028  }
7029 
7030  // struct A -> struct B
7031  if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
7032  if (Context.typesAreCompatible(LHSType, RHSType)) {
7033  Kind = CK_NoOp;
7034  return Compatible;
7035  }
7036  }
7037 
7038  return Incompatible;
7039 }
7040 
7041 /// \brief Constructs a transparent union from an expression that is
7042 /// used to initialize the transparent union.
7044  ExprResult &EResult, QualType UnionType,
7045  FieldDecl *Field) {
7046  // Build an initializer list that designates the appropriate member
7047  // of the transparent union.
7048  Expr *E = EResult.get();
7049  InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
7050  E, SourceLocation());
7051  Initializer->setType(UnionType);
7052  Initializer->setInitializedFieldInUnion(Field);
7053 
7054  // Build a compound literal constructing a value of the transparent
7055  // union type from this initializer list.
7056  TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
7057  EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
7058  VK_RValue, Initializer, false);
7059 }
7060 
7063  ExprResult &RHS) {
7064  QualType RHSType = RHS.get()->getType();
7065 
7066  // If the ArgType is a Union type, we want to handle a potential
7067  // transparent_union GCC extension.
7068  const RecordType *UT = ArgType->getAsUnionType();
7069  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
7070  return Incompatible;
7071 
7072  // The field to initialize within the transparent union.
7073  RecordDecl *UD = UT->getDecl();
7074  FieldDecl *InitField = nullptr;
7075  // It's compatible if the expression matches any of the fields.
7076  for (auto *it : UD->fields()) {
7077  if (it->getType()->isPointerType()) {
7078  // If the transparent union contains a pointer type, we allow:
7079  // 1) void pointer
7080  // 2) null pointer constant
7081  if (RHSType->isPointerType())
7082  if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
7083  RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast);
7084  InitField = it;
7085  break;
7086  }
7087 
7088  if (RHS.get()->isNullPointerConstant(Context,
7090  RHS = ImpCastExprToType(RHS.get(), it->getType(),
7092  InitField = it;
7093  break;
7094  }
7095  }
7096 
7098  if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
7099  == Compatible) {
7100  RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind);
7101  InitField = it;
7102  break;
7103  }
7104  }
7105 
7106  if (!InitField)
7107  return Incompatible;
7108 
7109  ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField);
7110  return Compatible;
7111 }
7112 
7115  bool Diagnose,
7116  bool DiagnoseCFAudited) {
7117  if (getLangOpts().CPlusPlus) {
7118  if (!LHSType->isRecordType() && !LHSType->isAtomicType()) {
7119  // C++ 5.17p3: If the left operand is not of class type, the
7120  // expression is implicitly converted (C++ 4) to the
7121  // cv-unqualified type of the left operand.
7122  ExprResult Res;
7123  if (Diagnose) {
7124  Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
7125  AA_Assigning);
7126  } else {
7128  TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
7129  /*SuppressUserConversions=*/false,
7130  /*AllowExplicit=*/false,
7131  /*InOverloadResolution=*/false,
7132  /*CStyle=*/false,
7133  /*AllowObjCWritebackConversion=*/false);
7134  if (ICS.isFailure())
7135  return Incompatible;
7136  Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
7137  ICS, AA_Assigning);
7138  }
7139  if (Res.isInvalid())
7140  return Incompatible;
7141  Sema::AssignConvertType result = Compatible;
7142  if (getLangOpts().ObjCAutoRefCount &&
7143  !CheckObjCARCUnavailableWeakConversion(LHSType,
7144  RHS.get()->getType()))
7145  result = IncompatibleObjCWeakRef;
7146  RHS = Res;
7147  return result;
7148  }
7149 
7150  // FIXME: Currently, we fall through and treat C++ classes like C
7151  // structures.
7152  // FIXME: We also fall through for atomics; not sure what should
7153  // happen there, though.
7154  }
7155 
7156  // C99 6.5.16.1p1: the left operand is a pointer and the right is
7157  // a null pointer constant.
7158  if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
7159  LHSType->isBlockPointerType()) &&
7162  CastKind Kind;
7163  CXXCastPath Path;
7164  CheckPointerConversion(RHS.get(), LHSType, Kind, Path, false);
7165  RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path);
7166  return Compatible;
7167  }
7168 
7169  // This check seems unnatural, however it is necessary to ensure the proper
7170  // conversion of functions/arrays. If the conversion were done for all
7171  // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
7172  // expressions that suppress this implicit conversion (&, sizeof).
7173  //
7174  // Suppress this for references: C++ 8.5.3p5.
7175  if (!LHSType->isReferenceType()) {
7176  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
7177  if (RHS.isInvalid())
7178  return Incompatible;
7179  }
7180 
7181  Expr *PRE = RHS.get()->IgnoreParenCasts();
7182  if (ObjCProtocolExpr *OPE = dyn_cast<ObjCProtocolExpr>(PRE)) {
7183  ObjCProtocolDecl *PDecl = OPE->getProtocol();
7184  if (PDecl && !PDecl->hasDefinition()) {
7185  Diag(PRE->getExprLoc(), diag::warn_atprotocol_protocol) << PDecl->getName();
7186  Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl;
7187  }
7188  }
7189 
7191  Sema::AssignConvertType result =
7192  CheckAssignmentConstraints(LHSType, RHS, Kind);
7193 
7194  // C99 6.5.16.1p2: The value of the right operand is converted to the
7195  // type of the assignment expression.
7196  // CheckAssignmentConstraints allows the left-hand side to be a reference,
7197  // so that we can use references in built-in functions even in C.
7198  // The getNonReferenceType() call makes sure that the resulting expression
7199  // does not have reference type.
7200  if (result != Incompatible && RHS.get()->getType() != LHSType) {
7201  QualType Ty = LHSType.getNonLValueExprType(Context);
7202  Expr *E = RHS.get();
7203  if (getLangOpts().ObjCAutoRefCount)
7204  CheckObjCARCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion,
7205  DiagnoseCFAudited);
7206  if (getLangOpts().ObjC1 &&
7207  (CheckObjCBridgeRelatedConversions(E->getLocStart(),
7208  LHSType, E->getType(), E) ||
7209  ConversionToObjCStringLiteralCheck(LHSType, E))) {
7210  RHS = E;
7211  return Compatible;
7212  }
7213 
7214  RHS = ImpCastExprToType(E, Ty, Kind);
7215  }
7216  return result;
7217 }
7218 
7220  ExprResult &RHS) {
7221  Diag(Loc, diag::err_typecheck_invalid_operands)
7222  << LHS.get()->getType() << RHS.get()->getType()
7223  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7224  return QualType();
7225 }
7226 
7227 /// Try to convert a value of non-vector type to a vector type by converting
7228 /// the type to the element type of the vector and then performing a splat.
7229 /// If the language is OpenCL, we only use conversions that promote scalar
7230 /// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
7231 /// for float->int.
7232 ///
7233 /// \param scalar - if non-null, actually perform the conversions
7234 /// \return true if the operation fails (but without diagnosing the failure)
7235 static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
7236  QualType scalarTy,
7237  QualType vectorEltTy,
7238  QualType vectorTy) {
7239  // The conversion to apply to the scalar before splatting it,
7240  // if necessary.
7241  CastKind scalarCast = CK_Invalid;
7242 
7243  if (vectorEltTy->isIntegralType(S.Context)) {
7244  if (!scalarTy->isIntegralType(S.Context))
7245  return true;
7246  if (S.getLangOpts().OpenCL &&
7247  S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0)
7248  return true;
7249  scalarCast = CK_IntegralCast;
7250  } else if (vectorEltTy->isRealFloatingType()) {
7251  if (scalarTy->isRealFloatingType()) {
7252  if (S.getLangOpts().OpenCL &&
7253  S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0)
7254  return true;
7255  scalarCast = CK_FloatingCast;
7256  }
7257  else if (scalarTy->isIntegralType(S.Context))
7258  scalarCast = CK_IntegralToFloating;
7259  else
7260  return true;
7261  } else {
7262  return true;
7263  }
7264 
7265  // Adjust scalar if desired.
7266  if (scalar) {
7267  if (scalarCast != CK_Invalid)
7268  *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast);
7269  *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat);
7270  }
7271  return false;
7272 }
7273 
7275  SourceLocation Loc, bool IsCompAssign,
7276  bool AllowBothBool,
7277  bool AllowBoolConversions) {
7278  if (!IsCompAssign) {
7279  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
7280  if (LHS.isInvalid())
7281  return QualType();
7282  }
7283  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
7284  if (RHS.isInvalid())
7285  return QualType();
7286 
7287  // For conversion purposes, we ignore any qualifiers.
7288  // For example, "const float" and "float" are equivalent.
7289  QualType LHSType = LHS.get()->getType().getUnqualifiedType();
7290  QualType RHSType = RHS.get()->getType().getUnqualifiedType();
7291 
7292  const VectorType *LHSVecType = LHSType->getAs<VectorType>();
7293  const VectorType *RHSVecType = RHSType->getAs<VectorType>();
7294  assert(LHSVecType || RHSVecType);
7295 
7296  // AltiVec-style "vector bool op vector bool" combinations are allowed
7297  // for some operators but not others.
7298  if (!AllowBothBool &&
7299  LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
7300  RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
7301  return InvalidOperands(Loc, LHS, RHS);
7302 
7303  // If the vector types are identical, return.
7304  if (Context.hasSameType(LHSType, RHSType))
7305  return LHSType;
7306 
7307  // If we have compatible AltiVec and GCC vector types, use the AltiVec type.
7308  if (LHSVecType && RHSVecType &&
7309  Context.areCompatibleVectorTypes(LHSType, RHSType)) {
7310  if (isa<ExtVectorType>(LHSVecType)) {
7311  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
7312  return LHSType;
7313  }
7314 
7315  if (!IsCompAssign)
7316  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
7317  return RHSType;
7318  }
7319 
7320  // AllowBoolConversions says that bool and non-bool AltiVec vectors
7321  // can be mixed, with the result being the non-bool type. The non-bool
7322  // operand must have integer element type.
7323  if (AllowBoolConversions && LHSVecType && RHSVecType &&
7324  LHSVecType->getNumElements() == RHSVecType->getNumElements() &&
7325  (Context.getTypeSize(LHSVecType->getElementType()) ==
7326  Context.getTypeSize(RHSVecType->getElementType()))) {
7327  if (LHSVecType->getVectorKind() == VectorType::AltiVecVector &&
7328  LHSVecType->getElementType()->isIntegerType() &&
7329  RHSVecType->getVectorKind() == VectorType::AltiVecBool) {
7330  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
7331  return LHSType;
7332  }
7333  if (!IsCompAssign &&
7334  LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
7335  RHSVecType->getVectorKind() == VectorType::AltiVecVector &&
7336  RHSVecType->getElementType()->isIntegerType()) {
7337  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
7338  return RHSType;
7339  }
7340  }
7341 
7342  // If there's an ext-vector type and a scalar, try to convert the scalar to
7343  // the vector element type and splat.
7344  if (!RHSVecType && isa<ExtVectorType>(LHSVecType)) {
7345  if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
7346  LHSVecType->getElementType(), LHSType))
7347  return LHSType;
7348  }
7349  if (!LHSVecType && isa<ExtVectorType>(RHSVecType)) {
7350  if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
7351  LHSType, RHSVecType->getElementType(),
7352  RHSType))
7353  return RHSType;
7354  }
7355 
7356  // If we're allowing lax vector conversions, only the total (data) size
7357  // needs to be the same.
7358  // FIXME: Should we really be allowing this?
7359  // FIXME: We really just pick the LHS type arbitrarily?
7360  if (isLaxVectorConversion(RHSType, LHSType)) {
7361  QualType resultType = LHSType;
7362  RHS = ImpCastExprToType(RHS.get(), resultType, CK_BitCast);
7363  return resultType;
7364  }
7365 
7366  // Okay, the expression is invalid.
7367 
7368  // If there's a non-vector, non-real operand, diagnose that.
7369  if ((!RHSVecType && !RHSType->isRealType()) ||
7370  (!LHSVecType && !LHSType->isRealType())) {
7371  Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
7372  << LHSType << RHSType
7373  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7374  return QualType();
7375  }
7376 
7377  // Otherwise, use the generic diagnostic.
7378  Diag(Loc, diag::err_typecheck_vector_not_convertable)
7379  << LHSType << RHSType
7380  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7381  return QualType();
7382 }
7383 
7384 // checkArithmeticNull - Detect when a NULL constant is used improperly in an
7385 // expression. These are mainly cases where the null pointer is used as an
7386 // integer instead of a pointer.
7387 static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
7388  SourceLocation Loc, bool IsCompare) {
7389  // The canonical way to check for a GNU null is with isNullPointerConstant,
7390  // but we use a bit of a hack here for speed; this is a relatively
7391  // hot path, and isNullPointerConstant is slow.
7392  bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts());
7393  bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts());
7394 
7395  QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType();
7396 
7397  // Avoid analyzing cases where the result will either be invalid (and
7398  // diagnosed as such) or entirely valid and not something to warn about.
7399  if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() ||
7400  NonNullType->isMemberPointerType() || NonNullType->isFunctionType())
7401  return;
7402 
7403  // Comparison operations would not make sense with a null pointer no matter
7404  // what the other expression is.
7405  if (!IsCompare) {
7406  S.Diag(Loc, diag::warn_null_in_arithmetic_operation)
7407  << (LHSNull ? LHS.get()->getSourceRange() : SourceRange())
7408  << (RHSNull ? RHS.get()->getSourceRange() : SourceRange());
7409  return;
7410  }
7411 
7412  // The rest of the operations only make sense with a null pointer
7413  // if the other expression is a pointer.
7414  if (LHSNull == RHSNull || NonNullType->isAnyPointerType() ||
7415  NonNullType->canDecayToPointerType())
7416  return;
7417 
7418  S.Diag(Loc, diag::warn_null_in_comparison_operation)
7419  << LHSNull /* LHS is NULL */ << NonNullType
7420  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7421 }
7422 
7424  SourceLocation Loc,
7425  bool IsCompAssign, bool IsDiv) {
7426  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7427 
7428  if (LHS.get()->getType()->isVectorType() ||
7429  RHS.get()->getType()->isVectorType())
7430  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
7431  /*AllowBothBool*/getLangOpts().AltiVec,
7432  /*AllowBoolConversions*/false);
7433 
7434  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
7435  if (LHS.isInvalid() || RHS.isInvalid())
7436  return QualType();
7437 
7438 
7439  if (compType.isNull() || !compType->isArithmeticType())
7440  return InvalidOperands(Loc, LHS, RHS);
7441 
7442  // Check for division by zero.
7443  llvm::APSInt RHSValue;
7444  if (IsDiv && !RHS.get()->isValueDependent() &&
7445  RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0)
7446  DiagRuntimeBehavior(Loc, RHS.get(),
7447  PDiag(diag::warn_division_by_zero)
7448  << RHS.get()->getSourceRange());
7449 
7450  return compType;
7451 }
7452 
7454  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
7455  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7456 
7457  if (LHS.get()->getType()->isVectorType() ||
7458  RHS.get()->getType()->isVectorType()) {
7459  if (LHS.get()->getType()->hasIntegerRepresentation() &&
7460  RHS.get()->getType()->hasIntegerRepresentation())
7461  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
7462  /*AllowBothBool*/getLangOpts().AltiVec,
7463  /*AllowBoolConversions*/false);
7464  return InvalidOperands(Loc, LHS, RHS);
7465  }
7466 
7467  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
7468  if (LHS.isInvalid() || RHS.isInvalid())
7469  return QualType();
7470 
7471  if (compType.isNull() || !compType->isIntegerType())
7472  return InvalidOperands(Loc, LHS, RHS);
7473 
7474  // Check for remainder by zero.
7475  llvm::APSInt RHSValue;
7476  if (!RHS.get()->isValueDependent() &&
7477  RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0)
7478  DiagRuntimeBehavior(Loc, RHS.get(),
7479  PDiag(diag::warn_remainder_by_zero)
7480  << RHS.get()->getSourceRange());
7481 
7482  return compType;
7483 }
7484 
7485 /// \brief Diagnose invalid arithmetic on two void pointers.
7487  Expr *LHSExpr, Expr *RHSExpr) {
7488  S.Diag(Loc, S.getLangOpts().CPlusPlus
7489  ? diag::err_typecheck_pointer_arith_void_type
7490  : diag::ext_gnu_void_ptr)
7491  << 1 /* two pointers */ << LHSExpr->getSourceRange()
7492  << RHSExpr->getSourceRange();
7493 }
7494 
7495 /// \brief Diagnose invalid arithmetic on a void pointer.
7497  Expr *Pointer) {
7498  S.Diag(Loc, S.getLangOpts().CPlusPlus
7499  ? diag::err_typecheck_pointer_arith_void_type
7500  : diag::ext_gnu_void_ptr)
7501  << 0 /* one pointer */ << Pointer->getSourceRange();
7502 }
7503 
7504 /// \brief Diagnose invalid arithmetic on two function pointers.
7506  Expr *LHS, Expr *RHS) {
7507  assert(LHS->getType()->isAnyPointerType());
7508  assert(RHS->getType()->isAnyPointerType());
7509  S.Diag(Loc, S.getLangOpts().CPlusPlus
7510  ? diag::err_typecheck_pointer_arith_function_type
7511  : diag::ext_gnu_ptr_func_arith)
7512  << 1 /* two pointers */ << LHS->getType()->getPointeeType()
7513  // We only show the second type if it differs from the first.
7515  RHS->getType())
7516  << RHS->getType()->getPointeeType()
7517  << LHS->getSourceRange() << RHS->getSourceRange();
7518 }
7519 
7520 /// \brief Diagnose invalid arithmetic on a function pointer.
7522  Expr *Pointer) {
7523  assert(Pointer->getType()->isAnyPointerType());
7524  S.Diag(Loc, S.getLangOpts().CPlusPlus
7525  ? diag::err_typecheck_pointer_arith_function_type
7526  : diag::ext_gnu_ptr_func_arith)
7527  << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
7528  << 0 /* one pointer, so only one type */
7529  << Pointer->getSourceRange();
7530 }
7531 
7532 /// \brief Emit error if Operand is incomplete pointer type
7533 ///
7534 /// \returns True if pointer has incomplete type
7536  Expr *Operand) {
7537  QualType ResType = Operand->getType();
7538  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
7539  ResType = ResAtomicType->getValueType();
7540 
7541  assert(ResType->isAnyPointerType() && !ResType->isDependentType());
7542  QualType PointeeTy = ResType->getPointeeType();
7543  return S.RequireCompleteType(Loc, PointeeTy,
7544  diag::err_typecheck_arithmetic_incomplete_type,
7545  PointeeTy, Operand->getSourceRange());
7546 }
7547 
7548 /// \brief Check the validity of an arithmetic pointer operand.
7549 ///
7550 /// If the operand has pointer type, this code will check for pointer types
7551 /// which are invalid in arithmetic operations. These will be diagnosed
7552 /// appropriately, including whether or not the use is supported as an
7553 /// extension.
7554 ///
7555 /// \returns True when the operand is valid to use (even if as an extension).
7557  Expr *Operand) {
7558  QualType ResType = Operand->getType();
7559  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
7560  ResType = ResAtomicType->getValueType();
7561 
7562  if (!ResType->isAnyPointerType()) return true;
7563 
7564  QualType PointeeTy = ResType->getPointeeType();
7565  if (PointeeTy->isVoidType()) {
7566  diagnoseArithmeticOnVoidPointer(S, Loc, Operand);
7567  return !S.getLangOpts().CPlusPlus;
7568  }
7569  if (PointeeTy->isFunctionType()) {
7570  diagnoseArithmeticOnFunctionPointer(S, Loc, Operand);
7571  return !S.getLangOpts().CPlusPlus;
7572  }
7573 
7574  if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;
7575 
7576  return true;
7577 }
7578 
7579 /// \brief Check the validity of a binary arithmetic operation w.r.t. pointer
7580 /// operands.
7581 ///
7582 /// This routine will diagnose any invalid arithmetic on pointer operands much
7583 /// like \see checkArithmeticOpPointerOperand. However, it has special logic
7584 /// for emitting a single diagnostic even for operations where both LHS and RHS
7585 /// are (potentially problematic) pointers.
7586 ///
7587 /// \returns True when the operand is valid to use (even if as an extension).
7589  Expr *LHSExpr, Expr *RHSExpr) {
7590  bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
7591  bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
7592  if (!isLHSPointer && !isRHSPointer) return true;
7593 
7594  QualType LHSPointeeTy, RHSPointeeTy;
7595  if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
7596  if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
7597 
7598  // if both are pointers check if operation is valid wrt address spaces
7599  if (isLHSPointer && isRHSPointer) {
7600  const PointerType *lhsPtr = LHSExpr->getType()->getAs<PointerType>();
7601  const PointerType *rhsPtr = RHSExpr->getType()->getAs<PointerType>();
7602  if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
7603  S.Diag(Loc,
7604  diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
7605  << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
7606  << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
7607  return false;
7608  }
7609  }
7610 
7611  // Check for arithmetic on pointers to incomplete types.
7612  bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
7613  bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
7614  if (isLHSVoidPtr || isRHSVoidPtr) {
7615  if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
7616  else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
7617  else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
7618 
7619  return !S.getLangOpts().CPlusPlus;
7620  }
7621 
7622  bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
7623  bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
7624  if (isLHSFuncPtr || isRHSFuncPtr) {
7625  if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
7626  else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
7627  RHSExpr);
7628  else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
7629 
7630  return !S.getLangOpts().CPlusPlus;
7631  }
7632 
7633  if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
7634  return false;
7635  if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
7636  return false;
7637 
7638  return true;
7639 }
7640 
7641 /// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
7642 /// literal.
7643 static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
7644  Expr *LHSExpr, Expr *RHSExpr) {
7645  StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
7646  Expr* IndexExpr = RHSExpr;
7647  if (!StrExpr) {
7648  StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
7649  IndexExpr = LHSExpr;
7650  }
7651 
7652  bool IsStringPlusInt = StrExpr &&
7654  if (!IsStringPlusInt || IndexExpr->isValueDependent())
7655  return;
7656 
7657  llvm::APSInt index;
7658  if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) {
7659  unsigned StrLenWithNull = StrExpr->getLength() + 1;
7660  if (index.isNonNegative() &&
7661  index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull),
7662  index.isUnsigned()))
7663  return;
7664  }
7665 
7666  SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
7667  Self.Diag(OpLoc, diag::warn_string_plus_int)
7668  << DiagRange << IndexExpr->IgnoreImpCasts()->getType();
7669 
7670  // Only print a fixit for "str" + int, not for int + "str".
7671  if (IndexExpr == RHSExpr) {
7672  SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd());
7673  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
7674  << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&")
7676  << FixItHint::CreateInsertion(EndLoc, "]");
7677  } else
7678  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
7679 }
7680 
7681 /// \brief Emit a warning when adding a char literal to a string.
7682 static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
7683  Expr *LHSExpr, Expr *RHSExpr) {
7684  const Expr *StringRefExpr = LHSExpr;
7685  const CharacterLiteral *CharExpr =
7686  dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts());
7687 
7688  if (!CharExpr) {
7689  CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts());
7690  StringRefExpr = RHSExpr;
7691  }
7692 
7693  if (!CharExpr || !StringRefExpr)
7694  return;
7695 
7696  const QualType StringType = StringRefExpr->getType();
7697 
7698  // Return if not a PointerType.
7699  if (!StringType->isAnyPointerType())
7700  return;
7701 
7702  // Return if not a CharacterType.
7703  if (!StringType->getPointeeType()->isAnyCharacterType())
7704  return;
7705 
7706  ASTContext &Ctx = Self.getASTContext();
7707  SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
7708 
7709  const QualType CharType = CharExpr->getType();
7710  if (!CharType->isAnyCharacterType() &&
7711  CharType->isIntegerType() &&
7712  llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
7713  Self.Diag(OpLoc, diag::warn_string_plus_char)
7714  << DiagRange << Ctx.CharTy;
7715  } else {
7716  Self.Diag(OpLoc, diag::warn_string_plus_char)
7717  << DiagRange << CharExpr->getType();
7718  }
7719 
7720  // Only print a fixit for str + char, not for char + str.
7721  if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) {
7722  SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd());
7723  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
7724  << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&")
7726  << FixItHint::CreateInsertion(EndLoc, "]");
7727  } else {
7728  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
7729  }
7730 }
7731 
7732 /// \brief Emit error when two pointers are incompatible.
7734  Expr *LHSExpr, Expr *RHSExpr) {
7735  assert(LHSExpr->getType()->isAnyPointerType());
7736  assert(RHSExpr->getType()->isAnyPointerType());
7737  S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
7738  << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
7739  << RHSExpr->getSourceRange();
7740 }
7741 
7743  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc,
7744  QualType* CompLHSTy) {
7745  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7746 
7747  if (LHS.get()->getType()->isVectorType() ||
7748  RHS.get()->getType()->isVectorType()) {
7749  QualType compType = CheckVectorOperands(
7750  LHS, RHS, Loc, CompLHSTy,
7751  /*AllowBothBool*/getLangOpts().AltiVec,
7752  /*AllowBoolConversions*/getLangOpts().ZVector);
7753  if (CompLHSTy) *CompLHSTy = compType;
7754  return compType;
7755  }
7756 
7757  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
7758  if (LHS.isInvalid() || RHS.isInvalid())
7759  return QualType();
7760 
7761  // Diagnose "string literal" '+' int and string '+' "char literal".
7762  if (Opc == BO_Add) {
7763  diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
7764  diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
7765  }
7766 
7767  // handle the common case first (both operands are arithmetic).
7768  if (!compType.isNull() && compType->isArithmeticType()) {
7769  if (CompLHSTy) *CompLHSTy = compType;
7770  return compType;
7771  }
7772 
7773  // Type-checking. Ultimately the pointer's going to be in PExp;
7774  // note that we bias towards the LHS being the pointer.
7775  Expr *PExp = LHS.get(), *IExp = RHS.get();
7776 
7777  bool isObjCPointer;
7778  if (PExp->getType()->isPointerType()) {
7779  isObjCPointer = false;
7780  } else if (PExp->getType()->isObjCObjectPointerType()) {
7781  isObjCPointer = true;
7782  } else {
7783  std::swap(PExp, IExp);
7784  if (PExp->getType()->isPointerType()) {
7785  isObjCPointer = false;
7786  } else if (PExp->getType()->isObjCObjectPointerType()) {
7787  isObjCPointer = true;
7788  } else {
7789  return InvalidOperands(Loc, LHS, RHS);
7790  }
7791  }
7792  assert(PExp->getType()->isAnyPointerType());
7793 
7794  if (!IExp->getType()->isIntegerType())
7795  return InvalidOperands(Loc, LHS, RHS);
7796 
7797  if (!checkArithmeticOpPointerOperand(*this, Loc, PExp))
7798  return QualType();
7799 
7800  if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp))
7801  return QualType();
7802 
7803  // Check array bounds for pointer arithemtic
7804  CheckArrayAccess(PExp, IExp);
7805 
7806  if (CompLHSTy) {
7807  QualType LHSTy = Context.isPromotableBitField(LHS.get());
7808  if (LHSTy.isNull()) {
7809  LHSTy = LHS.get()->getType();
7810  if (LHSTy->isPromotableIntegerType())
7811  LHSTy = Context.getPromotedIntegerType(LHSTy);
7812  }
7813  *CompLHSTy = LHSTy;
7814  }
7815 
7816  return PExp->getType();
7817 }
7818 
7819 // C99 6.5.6
7821  SourceLocation Loc,
7822  QualType* CompLHSTy) {
7823  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7824 
7825  if (LHS.get()->getType()->isVectorType() ||
7826  RHS.get()->getType()->isVectorType()) {
7827  QualType compType = CheckVectorOperands(
7828  LHS, RHS, Loc, CompLHSTy,
7829  /*AllowBothBool*/getLangOpts().AltiVec,
7830  /*AllowBoolConversions*/getLangOpts().ZVector);
7831  if (CompLHSTy) *CompLHSTy = compType;
7832  return compType;
7833  }
7834 
7835  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
7836  if (LHS.isInvalid() || RHS.isInvalid())
7837  return QualType();
7838 
7839  // Enforce type constraints: C99 6.5.6p3.
7840 
7841  // Handle the common case first (both operands are arithmetic).
7842  if (!compType.isNull() && compType->isArithmeticType()) {
7843  if (CompLHSTy) *CompLHSTy = compType;
7844  return compType;
7845  }
7846 
7847  // Either ptr - int or ptr - ptr.
7848  if (LHS.get()->getType()->isAnyPointerType()) {
7849  QualType lpointee = LHS.get()->getType()->getPointeeType();
7850 
7851  // Diagnose bad cases where we step over interface counts.
7852  if (LHS.get()->getType()->isObjCObjectPointerType() &&
7853  checkArithmeticOnObjCPointer(*this, Loc, LHS.get()))
7854  return QualType();
7855 
7856  // The result type of a pointer-int computation is the pointer type.
7857  if (RHS.get()->getType()->isIntegerType()) {
7858  if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get()))
7859  return QualType();
7860 
7861  // Check array bounds for pointer arithemtic
7862  CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr,
7863  /*AllowOnePastEnd*/true, /*IndexNegated*/true);
7864 
7865  if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
7866  return LHS.get()->getType();
7867  }
7868 
7869  // Handle pointer-pointer subtractions.
7870  if (const PointerType *RHSPTy
7871  = RHS.get()->getType()->getAs<PointerType>()) {
7872  QualType rpointee = RHSPTy->getPointeeType();
7873 
7874  if (getLangOpts().CPlusPlus) {
7875  // Pointee types must be the same: C++ [expr.add]
7876  if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
7877  diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
7878  }
7879  } else {
7880  // Pointee types must be compatible C99 6.5.6p3
7884  diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
7885  return QualType();
7886  }
7887  }
7888 
7889  if (!checkArithmeticBinOpPointerOperands(*this, Loc,
7890  LHS.get(), RHS.get()))
7891  return QualType();
7892 
7893  // The pointee type may have zero size. As an extension, a structure or
7894  // union may have zero size or an array may have zero length. In this
7895  // case subtraction does not make sense.
7896  if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
7897  CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
7898  if (ElementSize.isZero()) {
7899  Diag(Loc,diag::warn_sub_ptr_zero_size_types)
7900  << rpointee.getUnqualifiedType()
7901  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7902  }
7903  }
7904 
7905  if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
7906  return Context.getPointerDiffType();
7907  }
7908  }
7909 
7910  return InvalidOperands(Loc, LHS, RHS);
7911 }
7912 
7914  if (const EnumType *ET = T->getAs<EnumType>())
7915  return ET->getDecl()->isScoped();
7916  return false;
7917 }
7918 
7920  SourceLocation Loc, unsigned Opc,
7921  QualType LHSType) {
7922  // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
7923  // so skip remaining warnings as we don't want to modify values within Sema.
7924  if (S.getLangOpts().OpenCL)
7925  return;
7926 
7927  llvm::APSInt Right;
7928  // Check right/shifter operand
7929  if (RHS.get()->isValueDependent() ||
7930  !RHS.get()->EvaluateAsInt(Right, S.Context))
7931  return;
7932 
7933  if (Right.isNegative()) {
7934  S.DiagRuntimeBehavior(Loc, RHS.get(),
7935  S.PDiag(diag::warn_shift_negative)
7936  << RHS.get()->getSourceRange());
7937  return;
7938  }
7939  llvm::APInt LeftBits(Right.getBitWidth(),
7940  S.Context.getTypeSize(LHS.get()->getType()));
7941  if (Right.uge(LeftBits)) {
7942  S.DiagRuntimeBehavior(Loc, RHS.get(),
7943  S.PDiag(diag::warn_shift_gt_typewidth)
7944  << RHS.get()->getSourceRange());
7945  return;
7946  }
7947  if (Opc != BO_Shl)
7948  return;
7949 
7950  // When left shifting an ICE which is signed, we can check for overflow which
7951  // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned
7952  // integers have defined behavior modulo one more than the maximum value
7953  // representable in the result type, so never warn for those.
7954  llvm::APSInt Left;
7955  if (LHS.get()->isValueDependent() ||
7956  LHSType->hasUnsignedIntegerRepresentation() ||
7957  !LHS.get()->EvaluateAsInt(Left, S.Context))
7958  return;
7959 
7960  // If LHS does not have a signed type and non-negative value
7961  // then, the behavior is undefined. Warn about it.
7962  if (Left.isNegative()) {
7963  S.DiagRuntimeBehavior(Loc, LHS.get(),
7964  S.PDiag(diag::warn_shift_lhs_negative)
7965  << LHS.get()->getSourceRange());
7966  return;
7967  }
7968 
7969  llvm::APInt ResultBits =
7970  static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits();
7971  if (LeftBits.uge(ResultBits))
7972  return;
7973  llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue());
7974  Result = Result.shl(Right);
7975 
7976  // Print the bit representation of the signed integer as an unsigned
7977  // hexadecimal number.
7978  SmallString<40> HexResult;
7979  Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true);
7980 
7981  // If we are only missing a sign bit, this is less likely to result in actual
7982  // bugs -- if the result is cast back to an unsigned type, it will have the
7983  // expected value. Thus we place this behind a different warning that can be
7984  // turned off separately if needed.
7985  if (LeftBits == ResultBits - 1) {
7986  S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
7987  << HexResult << LHSType
7988  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7989  return;
7990  }
7991 
7992  S.Diag(Loc, diag::warn_shift_result_gt_typewidth)
7993  << HexResult.str() << Result.getMinSignedBits() << LHSType
7994  << Left.getBitWidth() << LHS.get()->getSourceRange()
7995  << RHS.get()->getSourceRange();
7996 }
7997 
7998 /// \brief Return the resulting type when an OpenCL vector is shifted
7999 /// by a scalar or vector shift amount.
8001  ExprResult &LHS, ExprResult &RHS,
8002  SourceLocation Loc, bool IsCompAssign) {
8003  // OpenCL v1.1 s6.3.j says RHS can be a vector only if LHS is a vector.
8004  if (!LHS.get()->getType()->isVectorType()) {
8005  S.Diag(Loc, diag::err_shift_rhs_only_vector)
8006  << RHS.get()->getType() << LHS.get()->getType()
8007  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8008  return QualType();
8009  }
8010 
8011  if (!IsCompAssign) {
8012  LHS = S.UsualUnaryConversions(LHS.get());
8013  if (LHS.isInvalid()) return QualType();
8014  }
8015 
8016  RHS = S.UsualUnaryConversions(RHS.get());
8017  if (RHS.isInvalid()) return QualType();
8018 
8019  QualType LHSType = LHS.get()->getType();
8020  const VectorType *LHSVecTy = LHSType->getAs<VectorType>();
8021  QualType LHSEleType = LHSVecTy->getElementType();
8022 
8023  // Note that RHS might not be a vector.
8024  QualType RHSType = RHS.get()->getType();
8025  const VectorType *RHSVecTy = RHSType->getAs<VectorType>();
8026  QualType RHSEleType = RHSVecTy ? RHSVecTy->getElementType() : RHSType;
8027 
8028  // OpenCL v1.1 s6.3.j says that the operands need to be integers.
8029  if (!LHSEleType->isIntegerType()) {
8030  S.Diag(Loc, diag::err_typecheck_expect_int)
8031  << LHS.get()->getType() << LHS.get()->getSourceRange();
8032  return QualType();
8033  }
8034 
8035  if (!RHSEleType->isIntegerType()) {
8036  S.Diag(Loc, diag::err_typecheck_expect_int)
8037  << RHS.get()->getType() << RHS.get()->getSourceRange();
8038  return QualType();
8039  }
8040 
8041  if (RHSVecTy) {
8042  // OpenCL v1.1 s6.3.j says that for vector types, the operators
8043  // are applied component-wise. So if RHS is a vector, then ensure
8044  // that the number of elements is the same as LHS...
8045  if (RHSVecTy->getNumElements() != LHSVecTy->getNumElements()) {
8046  S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
8047  << LHS.get()->getType() << RHS.get()->getType()
8048  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8049  return QualType();
8050  }
8051  } else {
8052  // ...else expand RHS to match the number of elements in LHS.
8053  QualType VecTy =
8054  S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
8055  RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
8056  }
8057 
8058  return LHSType;
8059 }
8060 
8061 // C99 6.5.7
8063  SourceLocation Loc, unsigned Opc,
8064  bool IsCompAssign) {
8065  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
8066 
8067  // Vector shifts promote their scalar inputs to vector type.
8068  if (LHS.get()->getType()->isVectorType() ||
8069  RHS.get()->getType()->isVectorType()) {
8070  if (LangOpts.OpenCL)
8071  return checkOpenCLVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
8072  if (LangOpts.ZVector) {
8073  // The shift operators for the z vector extensions work basically
8074  // like OpenCL shifts, except that neither the LHS nor the RHS is
8075  // allowed to be a "vector bool".
8076  if (auto LHSVecType = LHS.get()->getType()->getAs<VectorType>())
8077  if (LHSVecType->getVectorKind() == VectorType::AltiVecBool)
8078  return InvalidOperands(Loc, LHS, RHS);
8079  if (auto RHSVecType = RHS.get()->getType()->getAs<VectorType>())
8080  if (RHSVecType->getVectorKind() == VectorType::AltiVecBool)
8081  return InvalidOperands(Loc, LHS, RHS);
8082  return checkOpenCLVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
8083  }
8084  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
8085  /*AllowBothBool*/true,
8086  /*AllowBoolConversions*/false);
8087  }
8088 
8089  // Shifts don't perform usual arithmetic conversions, they just do integer
8090  // promotions on each operand. C99 6.5.7p3
8091 
8092  // For the LHS, do usual unary conversions, but then reset them away
8093  // if this is a compound assignment.
8094  ExprResult OldLHS = LHS;
8095  LHS = UsualUnaryConversions(LHS.get());
8096  if (LHS.isInvalid())
8097  return QualType();
8098  QualType LHSType = LHS.get()->getType();
8099  if (IsCompAssign) LHS = OldLHS;
8100 
8101  // The RHS is simpler.
8102  RHS = UsualUnaryConversions(RHS.get());
8103  if (RHS.isInvalid())
8104  return QualType();
8105  QualType RHSType = RHS.get()->getType();
8106 
8107  // C99 6.5.7p2: Each of the operands shall have integer type.
8108  if (!LHSType->hasIntegerRepresentation() ||
8109  !RHSType->hasIntegerRepresentation())
8110  return InvalidOperands(Loc, LHS, RHS);
8111 
8112  // C++0x: Don't allow scoped enums. FIXME: Use something better than
8113  // hasIntegerRepresentation() above instead of this.
8114  if (isScopedEnumerationType(LHSType) ||
8115  isScopedEnumerationType(RHSType)) {
8116  return InvalidOperands(Loc, LHS, RHS);
8117  }
8118  // Sanity-check shift operands
8119  DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);
8120 
8121  // "The type of the result is that of the promoted left operand."
8122  return LHSType;
8123 }
8124 
8126  if (DeclContext *DC = D->getDeclContext()) {
8127  if (isa<ClassTemplateSpecializationDecl>(DC))
8128  return true;
8129  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
8130  return FD->isFunctionTemplateSpecialization();
8131  }
8132  return false;
8133 }
8134 
8135 /// If two different enums are compared, raise a warning.
8136 static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
8137  Expr *RHS) {
8138  QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType();
8139  QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType();
8140 
8141  const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>();
8142  if (!LHSEnumType)
8143  return;
8144  const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>();
8145  if (!RHSEnumType)
8146  return;
8147 
8148  // Ignore anonymous enums.
8149  if (!LHSEnumType->getDecl()->getIdentifier())
8150  return;
8151  if (!RHSEnumType->getDecl()->getIdentifier())
8152  return;
8153 
8154  if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType))
8155  return;
8156 
8157  S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types)
8158  << LHSStrippedType << RHSStrippedType
8159  << LHS->getSourceRange() << RHS->getSourceRange();
8160 }
8161 
8162 /// \brief Diagnose bad pointer comparisons.
8164  ExprResult &LHS, ExprResult &RHS,
8165  bool IsError) {
8166  S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
8167  : diag::ext_typecheck_comparison_of_distinct_pointers)
8168  << LHS.get()->getType() << RHS.get()->getType()
8169  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8170 }
8171 
8172 /// \brief Returns false if the pointers are converted to a composite type,
8173 /// true otherwise.
8175  ExprResult &LHS, ExprResult &RHS) {
8176  // C++ [expr.rel]p2:
8177  // [...] Pointer conversions (4.10) and qualification
8178  // conversions (4.4) are performed on pointer operands (or on
8179  // a pointer operand and a null pointer constant) to bring
8180  // them to their composite pointer type. [...]
8181  //
8182  // C++ [expr.eq]p1 uses the same notion for (in)equality
8183  // comparisons of pointers.
8184 
8185  // C++ [expr.eq]p2:
8186  // In addition, pointers to members can be compared, or a pointer to
8187  // member and a null pointer constant. Pointer to member conversions
8188  // (4.11) and qualification conversions (4.4) are performed to bring
8189  // them to a common type. If one operand is a null pointer constant,
8190  // the common type is the type of the other operand. Otherwise, the
8191  // common type is a pointer to member type similar (4.4) to the type
8192  // of one of the operands, with a cv-qualification signature (4.4)
8193  // that is the union of the cv-qualification signatures of the operand
8194  // types.
8195 
8196  QualType LHSType = LHS.get()->getType();
8197  QualType RHSType = RHS.get()->getType();
8198  assert((LHSType->isPointerType() && RHSType->isPointerType()) ||
8199  (LHSType->isMemberPointerType() && RHSType->isMemberPointerType()));
8200 
8201  bool NonStandardCompositeType = false;
8202  bool *BoolPtr = S.isSFINAEContext() ? nullptr : &NonStandardCompositeType;
8203  QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr);
8204  if (T.isNull()) {
8205  diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
8206  return true;
8207  }
8208 
8209  if (NonStandardCompositeType)
8210  S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard)
8211  << LHSType << RHSType << T << LHS.get()->getSourceRange()
8212  << RHS.get()->getSourceRange();
8213 
8214  LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast);
8215  RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast);
8216  return false;
8217 }
8218 
8220  ExprResult &LHS,
8221  ExprResult &RHS,
8222  bool IsError) {
8223  S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
8224  : diag::ext_typecheck_comparison_of_fptr_to_void)
8225  << LHS.get()->getType() << RHS.get()->getType()
8226  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8227 }
8228 
8230  switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) {
8231  case Stmt::ObjCArrayLiteralClass:
8232  case Stmt::ObjCDictionaryLiteralClass:
8233  case Stmt::ObjCStringLiteralClass:
8234  case Stmt::ObjCBoxedExprClass:
8235  return true;
8236  default:
8237  // Note that ObjCBoolLiteral is NOT an object literal!
8238  return false;
8239  }
8240 }
8241 
8242 static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
8243  const ObjCObjectPointerType *Type =
8244  LHS->getType()->getAs<ObjCObjectPointerType>();
8245 
8246  // If this is not actually an Objective-C object, bail out.
8247  if (!Type)
8248  return false;
8249 
8250  // Get the LHS object's interface type.
8251  QualType InterfaceType = Type->getPointeeType();
8252 
8253  // If the RHS isn't an Objective-C object, bail out.
8254  if (!RHS->getType()->isObjCObjectPointerType())
8255  return false;
8256 
8257  // Try to find the -isEqual: method.
8258  Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector();
8259  ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel,
8260  InterfaceType,
8261  /*instance=*/true);
8262  if (!Method) {
8263  if (Type->isObjCIdType()) {
8264  // For 'id', just check the global pool.
8265  Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(),
8266  /*receiverId=*/true);
8267  } else {
8268  // Check protocols.
8269  Method = S.LookupMethodInQualifiedType(IsEqualSel, Type,
8270  /*instance=*/true);
8271  }
8272  }
8273 
8274  if (!Method)
8275  return false;
8276 
8277  QualType T = Method->parameters()[0]->getType();
8278  if (!T->isObjCObjectPointerType())
8279  return false;
8280 
8281  QualType R = Method->getReturnType();
8282  if (!R->isScalarType())
8283  return false;
8284 
8285  return true;
8286 }
8287 
8289  FromE = FromE->IgnoreParenImpCasts();
8290  switch (FromE->getStmtClass()) {
8291  default:
8292  break;
8293  case Stmt::ObjCStringLiteralClass:
8294  // "string literal"
8295  return LK_String;
8296  case Stmt::ObjCArrayLiteralClass:
8297  // "array literal"
8298  return LK_Array;
8299  case Stmt::ObjCDictionaryLiteralClass:
8300  // "dictionary literal"
8301  return LK_Dictionary;
8302  case Stmt::BlockExprClass:
8303  return LK_Block;
8304  case Stmt::ObjCBoxedExprClass: {
8305  Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
8306  switch (Inner->getStmtClass()) {
8307  case Stmt::IntegerLiteralClass:
8308  case Stmt::FloatingLiteralClass:
8309  case Stmt::CharacterLiteralClass:
8310  case Stmt::ObjCBoolLiteralExprClass:
8311  case Stmt::CXXBoolLiteralExprClass:
8312  // "numeric literal"
8313  return LK_Numeric;
8314  case Stmt::ImplicitCastExprClass: {
8315  CastKind CK = cast<CastExpr>(Inner)->getCastKind();
8316  // Boolean literals can be represented by implicit casts.
8317  if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
8318  return LK_Numeric;
8319  break;
8320  }
8321  default:
8322  break;
8323  }
8324  return LK_Boxed;
8325  }
8326  }
8327  return LK_None;
8328 }
8329 
8331  ExprResult &LHS, ExprResult &RHS,
8333  Expr *Literal;
8334  Expr *Other;
8335  if (isObjCObjectLiteral(LHS)) {
8336  Literal = LHS.get();
8337  Other = RHS.get();
8338  } else {
8339  Literal = RHS.get();
8340  Other = LHS.get();
8341  }
8342 
8343  // Don't warn on comparisons against nil.
8344  Other = Other->IgnoreParenCasts();
8345  if (Other->isNullPointerConstant(S.getASTContext(),
8347  return;
8348 
8349  // This should be kept in sync with warn_objc_literal_comparison.
8350  // LK_String should always be after the other literals, since it has its own
8351  // warning flag.
8352  Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal);
8353  assert(LiteralKind != Sema::LK_Block);
8354  if (LiteralKind == Sema::LK_None) {
8355  llvm_unreachable("Unknown Objective-C object literal kind");
8356  }
8357 
8358  if (LiteralKind == Sema::LK_String)
8359  S.Diag(Loc, diag::warn_objc_string_literal_comparison)
8360  << Literal->getSourceRange();
8361  else
8362  S.Diag(Loc, diag::warn_objc_literal_comparison)
8363  << LiteralKind << Literal->getSourceRange();
8364 
8365  if (BinaryOperator::isEqualityOp(Opc) &&
8366  hasIsEqualMethod(S, LHS.get(), RHS.get())) {
8367  SourceLocation Start = LHS.get()->getLocStart();
8368  SourceLocation End = S.PP.getLocForEndOfToken(RHS.get()->getLocEnd());
8369  CharSourceRange OpRange =
8371 
8372  S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
8373  << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
8374  << FixItHint::CreateReplacement(OpRange, " isEqual:")
8375  << FixItHint::CreateInsertion(End, "]");
8376  }
8377 }
8378 
8380  ExprResult &RHS,
8381  SourceLocation Loc,
8382  unsigned OpaqueOpc) {
8383  // This checking requires bools.
8384  if (!S.getLangOpts().Bool) return;
8385 
8386  // Check that left hand side is !something.
8387  UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
8388  if (!UO || UO->getOpcode() != UO_LNot) return;
8389 
8390  // Only check if the right hand side is non-bool arithmetic type.
8391  if (RHS.get()->getType()->isBooleanType()) return;
8392 
8393  // Make sure that the something in !something is not bool.
8394  Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
8395  if (SubExpr->getType()->isBooleanType()) return;
8396 
8397  // Emit warning.
8398  S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_comparison)
8399  << Loc;
8400 
8401  // First note suggest !(x < y)
8402  SourceLocation FirstOpen = SubExpr->getLocStart();
8403  SourceLocation FirstClose = RHS.get()->getLocEnd();
8404  FirstClose = S.getPreprocessor().getLocForEndOfToken(FirstClose);
8405  if (FirstClose.isInvalid())
8406  FirstOpen = SourceLocation();
8407  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
8408  << FixItHint::CreateInsertion(FirstOpen, "(")
8409  << FixItHint::CreateInsertion(FirstClose, ")");
8410 
8411  // Second note suggests (!x) < y
8412  SourceLocation SecondOpen = LHS.get()->getLocStart();
8413  SourceLocation SecondClose = LHS.get()->getLocEnd();
8414  SecondClose = S.getPreprocessor().getLocForEndOfToken(SecondClose);
8415  if (SecondClose.isInvalid())
8416  SecondOpen = SourceLocation();
8417  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens)
8418  << FixItHint::CreateInsertion(SecondOpen, "(")
8419  << FixItHint::CreateInsertion(SecondClose, ")");
8420 }
8421 
8422 // Get the decl for a simple expression: a reference to a variable,
8423 // an implicit C++ field reference, or an implicit ObjC ivar reference.
8425  if (DeclRefExpr* DR = dyn_cast<DeclRefExpr>(E))
8426  return DR->getDecl();
8427  if (ObjCIvarRefExpr* Ivar = dyn_cast<ObjCIvarRefExpr>(E)) {
8428  if (Ivar->isFreeIvar())
8429  return Ivar->getDecl();
8430  }
8431  if (MemberExpr* Mem = dyn_cast<MemberExpr>(E)) {
8432  if (Mem->isImplicitAccess())
8433  return Mem->getMemberDecl();
8434  }
8435  return nullptr;
8436 }
8437 
8438 // C99 6.5.8, C++ [expr.rel]
8440  SourceLocation Loc, unsigned OpaqueOpc,
8441  bool IsRelational) {
8442  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true);
8443 
8444  BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc;
8445 
8446  // Handle vector comparisons separately.
8447  if (LHS.get()->getType()->isVectorType() ||
8448  RHS.get()->getType()->isVectorType())
8449  return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational);
8450 
8451  QualType LHSType = LHS.get()->getType();
8452  QualType RHSType = RHS.get()->getType();
8453 
8454  Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts();
8455  Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
8456 
8457  checkEnumComparison(*this, Loc, LHS.get(), RHS.get());
8458  diagnoseLogicalNotOnLHSofComparison(*this, LHS, RHS, Loc, OpaqueOpc);
8459 
8460  if (!LHSType->hasFloatingRepresentation() &&
8461  !(LHSType->isBlockPointerType() && IsRelational) &&
8462  !LHS.get()->getLocStart().isMacroID() &&
8463  !RHS.get()->getLocStart().isMacroID() &&
8464  ActiveTemplateInstantiations.empty()) {
8465  // For non-floating point types, check for self-comparisons of the form
8466  // x == x, x != x, x < x, etc. These always evaluate to a constant, and
8467  // often indicate logic errors in the program.
8468  //
8469  // NOTE: Don't warn about comparison expressions resulting from macro
8470  // expansion. Also don't warn about comparisons which are only self
8471  // comparisons within a template specialization. The warnings should catch
8472  // obvious cases in the definition of the template anyways. The idea is to
8473  // warn when the typed comparison operator will always evaluate to the same
8474  // result.
8475  ValueDecl *DL = getCompareDecl(LHSStripped);
8476  ValueDecl *DR = getCompareDecl(RHSStripped);
8477  if (DL && DR && DL == DR && !IsWithinTemplateSpecialization(DL)) {
8478  DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always)
8479  << 0 // self-
8480  << (Opc == BO_EQ
8481  || Opc == BO_LE
8482  || Opc == BO_GE));
8483  } else if (DL && DR && LHSType->isArrayType() && RHSType->isArrayType() &&
8484  !DL->getType()->isReferenceType() &&
8485  !DR->getType()->isReferenceType()) {
8486  // what is it always going to eval to?
8487  char always_evals_to;
8488  switch(Opc) {
8489  case BO_EQ: // e.g. array1 == array2
8490  always_evals_to = 0; // false
8491  break;
8492  case BO_NE: // e.g. array1 != array2
8493  always_evals_to = 1; // true
8494  break;
8495  default:
8496  // best we can say is 'a constant'
8497  always_evals_to = 2; // e.g. array1 <= array2
8498  break;
8499  }
8500  DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always)
8501  << 1 // array
8502  << always_evals_to);
8503  }
8504 
8505  if (isa<CastExpr>(LHSStripped))
8506  LHSStripped = LHSStripped->IgnoreParenCasts();
8507  if (isa<CastExpr>(RHSStripped))
8508  RHSStripped = RHSStripped->IgnoreParenCasts();
8509 
8510  // Warn about comparisons against a string constant (unless the other
8511  // operand is null), the user probably wants strcmp.
8512  Expr *literalString = nullptr;
8513  Expr *literalStringStripped = nullptr;
8514  if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
8515  !RHSStripped->isNullPointerConstant(Context,
8517  literalString = LHS.get();
8518  literalStringStripped = LHSStripped;
8519  } else if ((isa<StringLiteral>(RHSStripped) ||
8520  isa<ObjCEncodeExpr>(RHSStripped)) &&
8521  !LHSStripped->isNullPointerConstant(Context,
8523  literalString = RHS.get();
8524  literalStringStripped = RHSStripped;
8525  }
8526 
8527  if (literalString) {
8528  DiagRuntimeBehavior(Loc, nullptr,
8529  PDiag(diag::warn_stringcompare)
8530  << isa<ObjCEncodeExpr>(literalStringStripped)
8531  << literalString->getSourceRange());
8532  }
8533  }
8534 
8535  // C99 6.5.8p3 / C99 6.5.9p4
8536  UsualArithmeticConversions(LHS, RHS);
8537  if (LHS.isInvalid() || RHS.isInvalid())
8538  return QualType();
8539 
8540  LHSType = LHS.get()->getType();
8541  RHSType = RHS.get()->getType();
8542 
8543  // The result of comparisons is 'bool' in C++, 'int' in C.
8545 
8546  if (IsRelational) {
8547  if (LHSType->isRealType() && RHSType->isRealType())
8548  return ResultTy;
8549  } else {
8550  // Check for comparisons of floating point operands using != and ==.
8551  if (LHSType->hasFloatingRepresentation())
8552  CheckFloatComparison(Loc, LHS.get(), RHS.get());
8553 
8554  if (LHSType->isArithmeticType() && RHSType->isArithmeticType())
8555  return ResultTy;
8556  }
8557 
8558  const Expr::NullPointerConstantKind LHSNullKind =
8560  const Expr::NullPointerConstantKind RHSNullKind =
8562  bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
8563  bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
8564 
8565  if (!IsRelational && LHSIsNull != RHSIsNull) {
8566  bool IsEquality = Opc == BO_EQ;
8567  if (RHSIsNull)
8568  DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality,
8569  RHS.get()->getSourceRange());
8570  else
8571  DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality,
8572  LHS.get()->getSourceRange());
8573  }
8574 
8575  // All of the following pointer-related warnings are GCC extensions, except
8576  // when handling null pointer constants.
8577  if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2
8578  QualType LCanPointeeTy =
8579  LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
8580  QualType RCanPointeeTy =
8581  RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
8582 
8583  if (getLangOpts().CPlusPlus) {
8584  if (LCanPointeeTy == RCanPointeeTy)
8585  return ResultTy;
8586  if (!IsRelational &&
8587  (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
8588  // Valid unless comparison between non-null pointer and function pointer
8589  // This is a gcc extension compatibility comparison.
8590  // In a SFINAE context, we treat this as a hard error to maintain
8591  // conformance with the C++ standard.
8592  if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
8593  && !LHSIsNull && !RHSIsNull) {
8595  *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext());
8596 
8597  if (isSFINAEContext())
8598  return QualType();
8599 
8600  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
8601  return ResultTy;
8602  }
8603  }
8604 
8605  if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
8606  return QualType();
8607  else
8608  return ResultTy;
8609  }
8610  // C99 6.5.9p2 and C99 6.5.8p2
8611  if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
8612  RCanPointeeTy.getUnqualifiedType())) {
8613  // Valid unless a relational comparison of function pointers
8614  if (IsRelational && LCanPointeeTy->isFunctionType()) {
8615  Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
8616  << LHSType << RHSType << LHS.get()->getSourceRange()
8617  << RHS.get()->getSourceRange();
8618  }
8619  } else if (!IsRelational &&
8620  (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
8621  // Valid unless comparison between non-null pointer and function pointer
8622  if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
8623  && !LHSIsNull && !RHSIsNull)
8624  diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
8625  /*isError*/false);
8626  } else {
8627  // Invalid
8628  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
8629  }
8630  if (LCanPointeeTy != RCanPointeeTy) {
8631  const PointerType *lhsPtr = LHSType->getAs<PointerType>();
8632  if (!lhsPtr->isAddressSpaceOverlapping(*RHSType->getAs<PointerType>())) {
8633  Diag(Loc,
8634  diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
8635  << LHSType << RHSType << 0 /* comparison */
8636  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8637  }
8638  unsigned AddrSpaceL = LCanPointeeTy.getAddressSpace();
8639  unsigned AddrSpaceR = RCanPointeeTy.getAddressSpace();
8640  CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
8641  : CK_BitCast;
8642  if (LHSIsNull && !RHSIsNull)
8643  LHS = ImpCastExprToType(LHS.get(), RHSType, Kind);
8644  else
8645  RHS = ImpCastExprToType(RHS.get(), LHSType, Kind);
8646  }
8647  return ResultTy;
8648  }
8649 
8650  if (getLangOpts().CPlusPlus) {
8651  // Comparison of nullptr_t with itself.
8652  if (LHSType->isNullPtrType() && RHSType->isNullPtrType())
8653  return ResultTy;
8654 
8655  // Comparison of pointers with null pointer constants and equality
8656  // comparisons of member pointers to null pointer constants.
8657  if (RHSIsNull &&
8658  ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) ||
8659  (!IsRelational &&
8660  (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) {
8661  RHS = ImpCastExprToType(RHS.get(), LHSType,
8662  LHSType->isMemberPointerType()
8664  : CK_NullToPointer);
8665  return ResultTy;
8666  }
8667  if (LHSIsNull &&
8668  ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) ||
8669  (!IsRelational &&
8670  (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) {
8671  LHS = ImpCastExprToType(LHS.get(), RHSType,
8672  RHSType->isMemberPointerType()
8674  : CK_NullToPointer);
8675  return ResultTy;
8676  }
8677 
8678  // Comparison of member pointers.
8679  if (!IsRelational &&
8680  LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) {
8681  if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
8682  return QualType();
8683  else
8684  return ResultTy;
8685  }
8686 
8687  // Handle scoped enumeration types specifically, since they don't promote
8688  // to integers.
8689  if (LHS.get()->getType()->isEnumeralType() &&
8691  RHS.get()->getType()))
8692  return ResultTy;
8693  }
8694 
8695  // Handle block pointer types.
8696  if (!IsRelational && LHSType->isBlockPointerType() &&
8697  RHSType->isBlockPointerType()) {
8698  QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType();
8699  QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();
8700 
8701  if (!LHSIsNull && !RHSIsNull &&
8702  !Context.typesAreCompatible(lpointee, rpointee)) {
8703  Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
8704  << LHSType << RHSType << LHS.get()->getSourceRange()
8705  << RHS.get()->getSourceRange();
8706  }
8707  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
8708  return ResultTy;
8709  }
8710 
8711  // Allow block pointers to be compared with null pointer constants.
8712  if (!IsRelational
8713  && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
8714  || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
8715  if (!LHSIsNull && !RHSIsNull) {
8716  if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
8717  ->getPointeeType()->isVoidType())
8718  || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
8719  ->getPointeeType()->isVoidType())))
8720  Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
8721  << LHSType << RHSType << LHS.get()->getSourceRange()
8722  << RHS.get()->getSourceRange();
8723  }
8724  if (LHSIsNull && !RHSIsNull)
8725  LHS = ImpCastExprToType(LHS.get(), RHSType,
8726  RHSType->isPointerType() ? CK_BitCast
8728  else
8729  RHS = ImpCastExprToType(RHS.get(), LHSType,
8730  LHSType->isPointerType() ? CK_BitCast
8732  return ResultTy;
8733  }
8734 
8735  if (LHSType->isObjCObjectPointerType() ||
8736  RHSType->isObjCObjectPointerType()) {
8737  const PointerType *LPT = LHSType->getAs<PointerType>();
8738  const PointerType *RPT = RHSType->getAs<PointerType>();
8739  if (LPT || RPT) {
8740  bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false;
8741  bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false;
8742 
8743  if (!LPtrToVoid && !RPtrToVoid &&
8744  !Context.typesAreCompatible(LHSType, RHSType)) {
8745  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
8746  /*isError*/false);
8747  }
8748  if (LHSIsNull && !RHSIsNull) {
8749  Expr *E = LHS.get();
8750  if (getLangOpts().ObjCAutoRefCount)
8751  CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion);
8752  LHS = ImpCastExprToType(E, RHSType,
8754  }
8755  else {
8756  Expr *E = RHS.get();
8757  if (getLangOpts().ObjCAutoRefCount)
8758  CheckObjCARCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion, false,
8759  Opc);
8760  RHS = ImpCastExprToType(E, LHSType,
8762  }
8763  return ResultTy;
8764  }
8765  if (LHSType->isObjCObjectPointerType() &&
8766  RHSType->isObjCObjectPointerType()) {
8767  if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
8768  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
8769  /*isError*/false);
8770  if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
8771  diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);
8772 
8773  if (LHSIsNull && !RHSIsNull)
8774  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
8775  else
8776  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
8777  return ResultTy;
8778  }
8779  }
8780  if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
8781  (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
8782  unsigned DiagID = 0;
8783  bool isError = false;
8784  if (LangOpts.DebuggerSupport) {
8785  // Under a debugger, allow the comparison of pointers to integers,
8786  // since users tend to want to compare addresses.
8787  } else if ((LHSIsNull && LHSType->isIntegerType()) ||
8788  (RHSIsNull && RHSType->isIntegerType())) {
8789  if (IsRelational && !getLangOpts().CPlusPlus)
8790  DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
8791  } else if (IsRelational && !getLangOpts().CPlusPlus)
8792  DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
8793  else if (getLangOpts().CPlusPlus) {
8794  DiagID = diag::err_typecheck_comparison_of_pointer_integer;
8795  isError = true;
8796  } else
8797  DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
8798 
8799  if (DiagID) {
8800  Diag(Loc, DiagID)
8801  << LHSType << RHSType << LHS.get()->getSourceRange()
8802  << RHS.get()->getSourceRange();
8803  if (isError)
8804  return QualType();
8805  }
8806 
8807  if (LHSType->isIntegerType())
8808  LHS = ImpCastExprToType(LHS.get(), RHSType,
8809  LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
8810  else
8811  RHS = ImpCastExprToType(RHS.get(), LHSType,
8812  RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
8813  return ResultTy;
8814  }
8815 
8816  // Handle block pointers.
8817  if (!IsRelational && RHSIsNull
8818  && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
8819  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
8820  return ResultTy;
8821  }
8822  if (!IsRelational && LHSIsNull
8823  && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
8824  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
8825  return ResultTy;
8826  }
8827 
8828  return InvalidOperands(Loc, LHS, RHS);
8829 }
8830 
8831 
8832 // Return a signed type that is of identical size and number of elements.
8833 // For floating point vectors, return an integer type of identical size
8834 // and number of elements.
8836  const VectorType *VTy = V->getAs<VectorType>();
8837  unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
8838  if (TypeSize == Context.getTypeSize(Context.CharTy))
8840  else if (TypeSize == Context.getTypeSize(Context.ShortTy))
8842  else if (TypeSize == Context.getTypeSize(Context.IntTy))
8844  else if (TypeSize == Context.getTypeSize(Context.LongTy))
8846  assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
8847  "Unhandled vector element size in vector compare");
8849 }
8850 
8851 /// CheckVectorCompareOperands - vector comparisons are a clang extension that
8852 /// operates on extended vector types. Instead of producing an IntTy result,
8853 /// like a scalar comparison, a vector comparison produces a vector of integer
8854 /// types.
8856  SourceLocation Loc,
8857  bool IsRelational) {
8858  // Check to make sure we're operating on vectors of the same type and width,
8859  // Allowing one side to be a scalar of element type.
8860  QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false,
8861  /*AllowBothBool*/true,
8862  /*AllowBoolConversions*/getLangOpts().ZVector);
8863  if (vType.isNull())
8864  return vType;
8865 
8866  QualType LHSType = LHS.get()->getType();
8867 
8868  // If AltiVec, the comparison results in a numeric type, i.e.
8869  // bool for C++, int for C
8870  if (getLangOpts().AltiVec &&
8873 
8874  // For non-floating point types, check for self-comparisons of the form
8875  // x == x, x != x, x < x, etc. These always evaluate to a constant, and
8876  // often indicate logic errors in the program.
8877  if (!LHSType->hasFloatingRepresentation() &&
8878  ActiveTemplateInstantiations.empty()) {
8879  if (DeclRefExpr* DRL
8880  = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts()))
8881  if (DeclRefExpr* DRR
8882  = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts()))
8883  if (DRL->getDecl() == DRR->getDecl())
8884  DiagRuntimeBehavior(Loc, nullptr,
8885  PDiag(diag::warn_comparison_always)
8886  << 0 // self-
8887  << 2 // "a constant"
8888  );
8889  }
8890 
8891  // Check for comparisons of floating point operands using != and ==.
8892  if (!IsRelational && LHSType->hasFloatingRepresentation()) {
8893  assert (RHS.get()->getType()->hasFloatingRepresentation());
8894  CheckFloatComparison(Loc, LHS.get(), RHS.get());
8895  }
8896 
8897  // Return a signed type for the vector.
8898  return GetSignedVectorType(LHSType);
8899 }
8900 
8902  SourceLocation Loc) {
8903  // Ensure that either both operands are of the same vector type, or
8904  // one operand is of a vector type and the other is of its element type.
8905  QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
8906  /*AllowBothBool*/true,
8907  /*AllowBoolConversions*/false);
8908  if (vType.isNull())
8909  return InvalidOperands(Loc, LHS, RHS);
8910  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 &&
8911  vType->hasFloatingRepresentation())
8912  return InvalidOperands(Loc, LHS, RHS);
8913 
8914  return GetSignedVectorType(LHS.get()->getType());
8915 }
8916 
8918  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
8919  checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
8920 
8921  if (LHS.get()->getType()->isVectorType() ||
8922  RHS.get()->getType()->isVectorType()) {
8923  if (LHS.get()->getType()->hasIntegerRepresentation() &&
8924  RHS.get()->getType()->hasIntegerRepresentation())
8925  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
8926  /*AllowBothBool*/true,
8927  /*AllowBoolConversions*/getLangOpts().ZVector);
8928  return InvalidOperands(Loc, LHS, RHS);
8929  }
8930 
8931  ExprResult LHSResult = LHS, RHSResult = RHS;
8932  QualType compType = UsualArithmeticConversions(LHSResult, RHSResult,
8933  IsCompAssign);
8934  if (LHSResult.isInvalid() || RHSResult.isInvalid())
8935  return QualType();
8936  LHS = LHSResult.get();
8937  RHS = RHSResult.get();
8938 
8939  if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType())
8940  return compType;
8941  return InvalidOperands(Loc, LHS, RHS);
8942 }
8943 
8944 inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
8945  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) {
8946 
8947  // Check vector operands differently.
8948  if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType())
8949  return CheckVectorLogicalOperands(LHS, RHS, Loc);
8950 
8951  // Diagnose cases where the user write a logical and/or but probably meant a
8952  // bitwise one. We do this when the LHS is a non-bool integer and the RHS
8953  // is a constant.
8954  if (LHS.get()->getType()->isIntegerType() &&
8955  !LHS.get()->getType()->isBooleanType() &&
8956  RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() &&
8957  // Don't warn in macros or template instantiations.
8958  !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) {
8959  // If the RHS can be constant folded, and if it constant folds to something
8960  // that isn't 0 or 1 (which indicate a potential logical operation that
8961  // happened to fold to true/false) then warn.
8962  // Parens on the RHS are ignored.
8963  llvm::APSInt Result;
8964  if (RHS.get()->EvaluateAsInt(Result, Context))
8965  if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType() &&
8966  !RHS.get()->getExprLoc().isMacroID()) ||
8967  (Result != 0 && Result != 1)) {
8968  Diag(Loc, diag::warn_logical_instead_of_bitwise)
8969  << RHS.get()->getSourceRange()
8970  << (Opc == BO_LAnd ? "&&" : "||");
8971  // Suggest replacing the logical operator with the bitwise version
8972  Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
8973  << (Opc == BO_LAnd ? "&" : "|")
8975  Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(),
8976  getLangOpts())),
8977  Opc == BO_LAnd ? "&" : "|");
8978  if (Opc == BO_LAnd)
8979  // Suggest replacing "Foo() && kNonZero" with "Foo()"
8980  Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
8982  SourceRange(
8983  Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(),
8984  0, getSourceManager(),
8985  getLangOpts()),
8986  RHS.get()->getLocEnd()));
8987  }
8988  }
8989 
8990  if (!Context.getLangOpts().CPlusPlus) {
8991  // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do
8992  // not operate on the built-in scalar and vector float types.
8993  if (Context.getLangOpts().OpenCL &&
8994  Context.getLangOpts().OpenCLVersion < 120) {
8995  if (LHS.get()->getType()->isFloatingType() ||
8996  RHS.get()->getType()->isFloatingType())
8997  return InvalidOperands(Loc, LHS, RHS);
8998  }
8999 
9000  LHS = UsualUnaryConversions(LHS.get());
9001  if (LHS.isInvalid())
9002  return QualType();
9003 
9004  RHS = UsualUnaryConversions(RHS.get());
9005  if (RHS.isInvalid())
9006  return QualType();
9007 
9008  if (!LHS.get()->getType()->isScalarType() ||
9009  !RHS.get()->getType()->isScalarType())
9010  return InvalidOperands(Loc, LHS, RHS);
9011 
9012  return Context.IntTy;
9013  }
9014 
9015  // The following is safe because we only use this method for
9016  // non-overloadable operands.
9017 
9018  // C++ [expr.log.and]p1
9019  // C++ [expr.log.or]p1
9020  // The operands are both contextually converted to type bool.
9021  ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get());
9022  if (LHSRes.isInvalid())
9023  return InvalidOperands(Loc, LHS, RHS);
9024  LHS = LHSRes;
9025 
9026  ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get());
9027  if (RHSRes.isInvalid())
9028  return InvalidOperands(Loc, LHS, RHS);
9029  RHS = RHSRes;
9030 
9031  // C++ [expr.log.and]p2
9032  // C++ [expr.log.or]p2
9033  // The result is a bool.
9034  return Context.BoolTy;
9035 }
9036 
9037 static bool IsReadonlyMessage(Expr *E, Sema &S) {
9038  const MemberExpr *ME = dyn_cast<MemberExpr>(E);
9039  if (!ME) return false;
9040  if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
9042  dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts());
9043  if (!Base) return false;
9044  return Base->getMethodDecl() != nullptr;
9045 }
9046 
9047 /// Is the given expression (which must be 'const') a reference to a
9048 /// variable which was originally non-const, but which has become
9049 /// 'const' due to being captured within a block?
9052  assert(E->isLValue() && E->getType().isConstQualified());
9053  E = E->IgnoreParens();
9054 
9055  // Must be a reference to a declaration from an enclosing scope.
9056  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
9057  if (!DRE) return NCCK_None;
9058  if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None;
9059 
9060  // The declaration must be a variable which is not declared 'const'.
9061  VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
9062  if (!var) return NCCK_None;
9063  if (var->getType().isConstQualified()) return NCCK_None;
9064  assert(var->hasLocalStorage() && "capture added 'const' to non-local?");
9065 
9066  // Decide whether the first capture was for a block or a lambda.
9067  DeclContext *DC = S.CurContext, *Prev = nullptr;
9068  while (DC != var->getDeclContext()) {
9069  Prev = DC;
9070  DC = DC->getParent();
9071  }
9072  // Unless we have an init-capture, we've gone one step too far.
9073  if (!var->isInitCapture())
9074  DC = Prev;
9075  return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda);
9076 }
9077 
9078 static bool IsTypeModifiable(QualType Ty, bool IsDereference) {
9079  Ty = Ty.getNonReferenceType();
9080  if (IsDereference && Ty->isPointerType())
9081  Ty = Ty->getPointeeType();
9082  return !Ty.isConstQualified();
9083 }
9084 
9085 /// Emit the "read-only variable not assignable" error and print notes to give
9086 /// more information about why the variable is not assignable, such as pointing
9087 /// to the declaration of a const variable, showing that a method is const, or
9088 /// that the function is returning a const reference.
9089 static void DiagnoseConstAssignment(Sema &S, const Expr *E,
9090  SourceLocation Loc) {
9091  // Update err_typecheck_assign_const and note_typecheck_assign_const
9092  // when this enum is changed.
9093  enum {
9094  ConstFunction,
9095  ConstVariable,
9096  ConstMember,
9097  ConstMethod,
9098  ConstUnknown, // Keep as last element
9099  };
9100 
9101  SourceRange ExprRange = E->getSourceRange();
9102 
9103  // Only emit one error on the first const found. All other consts will emit
9104  // a note to the error.
9105  bool DiagnosticEmitted = false;
9106 
9107  // Track if the current expression is the result of a derefence, and if the
9108  // next checked expression is the result of a derefence.
9109  bool IsDereference = false;
9110  bool NextIsDereference = false;
9111 
9112  // Loop to process MemberExpr chains.
9113  while (true) {
9114  IsDereference = NextIsDereference;
9115  NextIsDereference = false;
9116 
9117  E = E->IgnoreParenImpCasts();
9118  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
9119  NextIsDereference = ME->isArrow();
9120  const ValueDecl *VD = ME->getMemberDecl();
9121  if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
9122  // Mutable fields can be modified even if the class is const.
9123  if (Field->isMutable()) {
9124  assert(DiagnosticEmitted && "Expected diagnostic not emitted.");
9125  break;
9126  }
9127 
9128  if (!IsTypeModifiable(Field->getType(), IsDereference)) {
9129  if (!DiagnosticEmitted) {
9130  S.Diag(Loc, diag::err_typecheck_assign_const)
9131  << ExprRange << ConstMember << false /*static*/ << Field
9132  << Field->getType();
9133  DiagnosticEmitted = true;
9134  }
9135  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
9136  << ConstMember << false /*static*/ << Field << Field->getType()
9137  << Field->getSourceRange();
9138  }
9139  E = ME->getBase();
9140  continue;
9141  } else if (const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
9142  if (VDecl->getType().isConstQualified()) {
9143  if (!DiagnosticEmitted) {
9144  S.Diag(Loc, diag::err_typecheck_assign_const)
9145  << ExprRange << ConstMember << true /*static*/ << VDecl
9146  << VDecl->getType();
9147  DiagnosticEmitted = true;
9148  }
9149  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
9150  << ConstMember << true /*static*/ << VDecl << VDecl->getType()
9151  << VDecl->getSourceRange();
9152  }
9153  // Static fields do not inherit constness from parents.
9154  break;
9155  }
9156  break;
9157  } // End MemberExpr
9158  break;
9159  }
9160 
9161  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
9162  // Function calls
9163  const FunctionDecl *FD = CE->getDirectCallee();
9164  if (!IsTypeModifiable(FD->getReturnType(), IsDereference)) {
9165  if (!DiagnosticEmitted) {
9166  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
9167  << ConstFunction << FD;
9168  DiagnosticEmitted = true;
9169  }
9171  diag::note_typecheck_assign_const)
9172  << ConstFunction << FD << FD->getReturnType()
9173  << FD->getReturnTypeSourceRange();
9174  }
9175  } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
9176  // Point to variable declaration.
9177  if (const ValueDecl *VD = DRE->getDecl()) {
9178  if (!IsTypeModifiable(VD->getType(), IsDereference)) {
9179  if (!DiagnosticEmitted) {
9180  S.Diag(Loc, diag::err_typecheck_assign_const)
9181  << ExprRange << ConstVariable << VD << VD->getType();
9182  DiagnosticEmitted = true;
9183  }
9184  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
9185  << ConstVariable << VD << VD->getType() << VD->getSourceRange();
9186  }
9187  }
9188  } else if (isa<CXXThisExpr>(E)) {
9189  if (const DeclContext *DC = S.getFunctionLevelDeclContext()) {
9190  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
9191  if (MD->isConst()) {
9192  if (!DiagnosticEmitted) {
9193  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
9194  << ConstMethod << MD;
9195  DiagnosticEmitted = true;
9196  }
9197  S.Diag(MD->getLocation(), diag::note_typecheck_assign_const)
9198  << ConstMethod << MD << MD->getSourceRange();
9199  }
9200  }
9201  }
9202  }
9203 
9204  if (DiagnosticEmitted)
9205  return;
9206 
9207  // Can't determine a more specific message, so display the generic error.
9208  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
9209 }
9210 
9211 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
9212 /// emit an error and return true. If so, return false.
9214  assert(!E->hasPlaceholderType(BuiltinType::PseudoObject));
9215  SourceLocation OrigLoc = Loc;
9217  &Loc);
9218  if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
9220  if (IsLV == Expr::MLV_Valid)
9221  return false;
9222 
9223  unsigned DiagID = 0;
9224  bool NeedType = false;
9225  switch (IsLV) { // C99 6.5.16p2
9227  // Use a specialized diagnostic when we're assigning to an object
9228  // from an enclosing function or block.
9230  if (NCCK == NCCK_Block)
9231  DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
9232  else
9233  DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
9234  break;
9235  }
9236 
9237  // In ARC, use some specialized diagnostics for occasions where we
9238  // infer 'const'. These are always pseudo-strong variables.
9239  if (S.getLangOpts().ObjCAutoRefCount) {
9240  DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts());
9241  if (declRef && isa<VarDecl>(declRef->getDecl())) {
9242  VarDecl *var = cast<VarDecl>(declRef->getDecl());
9243 
9244  // Use the normal diagnostic if it's pseudo-__strong but the
9245  // user actually wrote 'const'.
9246  if (var->isARCPseudoStrong() &&
9247  (!var->getTypeSourceInfo() ||
9248  !var->getTypeSourceInfo()->getType().isConstQualified())) {
9249  // There are two pseudo-strong cases:
9250  // - self
9251  ObjCMethodDecl *method = S.getCurMethodDecl();
9252  if (method && var == method->getSelfDecl())
9253  DiagID = method->isClassMethod()
9254  ? diag::err_typecheck_arc_assign_self_class_method
9255  : diag::err_typecheck_arc_assign_self;
9256 
9257  // - fast enumeration variables
9258  else
9259  DiagID = diag::err_typecheck_arr_assign_enumeration;
9260 
9261  SourceRange Assign;
9262  if (Loc != OrigLoc)
9263  Assign = SourceRange(OrigLoc, OrigLoc);
9264  S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
9265  // We need to preserve the AST regardless, so migration tool
9266  // can do its job.
9267  return false;
9268  }
9269  }
9270  }
9271 
9272  // If none of the special cases above are triggered, then this is a
9273  // simple const assignment.
9274  if (DiagID == 0) {
9275  DiagnoseConstAssignment(S, E, Loc);
9276  return true;
9277  }
9278 
9279  break;
9281  DiagnoseConstAssignment(S, E, Loc);
9282  return true;
9283  case Expr::MLV_ArrayType:
9285  DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
9286  NeedType = true;
9287  break;
9289  DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
9290  NeedType = true;
9291  break;
9292  case Expr::MLV_LValueCast:
9293  DiagID = diag::err_typecheck_lvalue_casts_not_supported;
9294  break;
9295  case Expr::MLV_Valid:
9296  llvm_unreachable("did not take early return for MLV_Valid");
9300  DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
9301  break;
9304  return S.RequireCompleteType(Loc, E->getType(),
9305  diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
9307  DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
9308  break;
9310  llvm_unreachable("readonly properties should be processed differently");
9312  DiagID = diag::error_readonly_message_assignment;
9313  break;
9315  DiagID = diag::error_no_subobject_property_setting;
9316  break;
9317  }
9318 
9319  SourceRange Assign;
9320  if (Loc != OrigLoc)
9321  Assign = SourceRange(OrigLoc, OrigLoc);
9322  if (NeedType)
9323  S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign;
9324  else
9325  S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
9326  return true;
9327 }
9328 
9329 static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
9330  SourceLocation Loc,
9331  Sema &Sema) {
9332  // C / C++ fields
9333  MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
9334  MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
9335  if (ML && MR && ML->getMemberDecl() == MR->getMemberDecl()) {
9336  if (isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase()))
9337  Sema.Diag(Loc, diag::warn_identity_field_assign) << 0;
9338  }
9339 
9340  // Objective-C instance variables
9341  ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr);
9342  ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr);
9343  if (OL && OR && OL->getDecl() == OR->getDecl()) {
9344  DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts());
9345  DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts());
9346  if (RL && RR && RL->getDecl() == RR->getDecl())
9347  Sema.Diag(Loc, diag::warn_identity_field_assign) << 1;
9348  }
9349 }
9350 
9351 // C99 6.5.16.1
9353  SourceLocation Loc,
9354  QualType CompoundType) {
9355  assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject));
9356 
9357  // Verify that LHS is a modifiable lvalue, and emit error if not.
9358  if (CheckForModifiableLvalue(LHSExpr, Loc, *this))
9359  return QualType();
9360 
9361  QualType LHSType = LHSExpr->getType();
9362  QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
9363  CompoundType;
9364  AssignConvertType ConvTy;
9365  if (CompoundType.isNull()) {
9366  Expr *RHSCheck = RHS.get();
9367 
9368  CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this);
9369 
9370  QualType LHSTy(LHSType);
9371  ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
9372  if (RHS.isInvalid())
9373  return QualType();
9374  // Special case of NSObject attributes on c-style pointer types.
9375  if (ConvTy == IncompatiblePointer &&
9376  ((Context.isObjCNSObjectType(LHSType) &&
9377  RHSType->isObjCObjectPointerType()) ||
9378  (Context.isObjCNSObjectType(RHSType) &&
9379  LHSType->isObjCObjectPointerType())))
9380  ConvTy = Compatible;
9381 
9382  if (ConvTy == Compatible &&
9383  LHSType->isObjCObjectType())
9384  Diag(Loc, diag::err_objc_object_assignment)
9385  << LHSType;
9386 
9387  // If the RHS is a unary plus or minus, check to see if they = and + are
9388  // right next to each other. If so, the user may have typo'd "x =+ 4"
9389  // instead of "x += 4".
9390  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
9391  RHSCheck = ICE->getSubExpr();
9392  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
9393  if ((UO->getOpcode() == UO_Plus ||
9394  UO->getOpcode() == UO_Minus) &&
9395  Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
9396  // Only if the two operators are exactly adjacent.
9397  Loc.getLocWithOffset(1) == UO->getOperatorLoc() &&
9398  // And there is a space or other character before the subexpr of the
9399  // unary +/-. We don't want to warn on "x=-1".
9400  Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
9401  UO->getSubExpr()->getLocStart().isFileID()) {
9402  Diag(Loc, diag::warn_not_compound_assign)
9403  << (UO->getOpcode() == UO_Plus ? "+" : "-")
9404  << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
9405  }
9406  }
9407 
9408  if (ConvTy == Compatible) {
9409  if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) {
9410  // Warn about retain cycles where a block captures the LHS, but
9411  // not if the LHS is a simple variable into which the block is
9412  // being stored...unless that variable can be captured by reference!
9413  const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
9414  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
9415  if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>())
9416  checkRetainCycles(LHSExpr, RHS.get());
9417 
9418  // It is safe to assign a weak reference into a strong variable.
9419  // Although this code can still have problems:
9420  // id x = self.weakProp;
9421  // id y = self.weakProp;
9422  // we do not warn to warn spuriously when 'x' and 'y' are on separate
9423  // paths through the function. This should be revisited if
9424  // -Wrepeated-use-of-weak is made flow-sensitive.
9425  if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
9426  RHS.get()->getLocStart()))
9427  getCurFunction()->markSafeWeakUse(RHS.get());
9428 
9429  } else if (getLangOpts().ObjCAutoRefCount) {
9430  checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get());
9431  }
9432  }
9433  } else {
9434  // Compound assignment "x += y"
9435  ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
9436  }
9437 
9438  if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
9439  RHS.get(), AA_Assigning))
9440  return QualType();
9441 
9442  CheckForNullPointerDereference(*this, LHSExpr);
9443 
9444  // C99 6.5.16p3: The type of an assignment expression is the type of the
9445  // left operand unless the left operand has qualified type, in which case
9446  // it is the unqualified version of the type of the left operand.
9447  // C99 6.5.16.1p2: In simple assignment, the value of the right operand
9448  // is converted to the type of the assignment expression (above).
9449  // C++ 5.17p1: the type of the assignment expression is that of its left
9450  // operand.
9451  return (getLangOpts().CPlusPlus
9452  ? LHSType : LHSType.getUnqualifiedType());
9453 }
9454 
9455 // C99 6.5.17
9457  SourceLocation Loc) {
9458  LHS = S.CheckPlaceholderExpr(LHS.get());
9459  RHS = S.CheckPlaceholderExpr(RHS.get());
9460  if (LHS.isInvalid() || RHS.isInvalid())
9461  return QualType();
9462 
9463  // C's comma performs lvalue conversion (C99 6.3.2.1) on both its
9464  // operands, but not unary promotions.
9465  // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
9466 
9467  // So we treat the LHS as a ignored value, and in C++ we allow the
9468  // containing site to determine what should be done with the RHS.
9469  LHS = S.IgnoredValueConversions(LHS.get());
9470  if (LHS.isInvalid())
9471  return QualType();
9472 
9473  S.DiagnoseUnusedExprResult(LHS.get());
9474 
9475  if (!S.getLangOpts().CPlusPlus) {
9477  if (RHS.isInvalid())
9478  return QualType();
9479  if (!RHS.get()->getType()->isVoidType())
9480  S.RequireCompleteType(Loc, RHS.get()->getType(),
9481  diag::err_incomplete_type);
9482  }
9483 
9484  return RHS.get()->getType();
9485 }
9486 
9487 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
9488 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
9490  ExprValueKind &VK,
9491  ExprObjectKind &OK,
9492  SourceLocation OpLoc,
9493  bool IsInc, bool IsPrefix) {
9494  if (Op->isTypeDependent())
9495  return S.Context.DependentTy;
9496 
9497  QualType ResType = Op->getType();
9498  // Atomic types can be used for increment / decrement where the non-atomic
9499  // versions can, so ignore the _Atomic() specifier for the purpose of
9500  // checking.
9501  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
9502  ResType = ResAtomicType->getValueType();
9503 
9504  assert(!ResType.isNull() && "no type for increment/decrement expression");
9505 
9506  if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {
9507  // Decrement of bool is not allowed.
9508  if (!IsInc) {
9509  S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
9510  return QualType();
9511  }
9512  // Increment of bool sets it to true, but is deprecated.
9513  S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
9514  } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
9515  // Error on enum increments and decrements in C++ mode
9516  S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
9517  return QualType();
9518  } else if (ResType->isRealType()) {
9519  // OK!
9520  } else if (ResType->isPointerType()) {
9521  // C99 6.5.2.4p2, 6.5.6p2
9522  if (!checkArithmeticOpPointerOperand(S, OpLoc, Op))
9523  return QualType();
9524  } else if (ResType->isObjCObjectPointerType()) {
9525  // On modern runtimes, ObjC pointer arithmetic is forbidden.
9526  // Otherwise, we just need a complete type.
9527  if (checkArithmeticIncompletePointerType(S, OpLoc, Op) ||
9528  checkArithmeticOnObjCPointer(S, OpLoc, Op))
9529  return QualType();
9530  } else if (ResType->isAnyComplexType()) {
9531  // C99 does not support ++/-- on complex types, we allow as an extension.
9532  S.Diag(OpLoc, diag::ext_integer_increment_complex)
9533  << ResType << Op->getSourceRange();
9534  } else if (ResType->isPlaceholderType()) {
9535  ExprResult PR = S.CheckPlaceholderExpr(Op);
9536  if (PR.isInvalid()) return QualType();
9537  return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc,
9538  IsInc, IsPrefix);
9539  } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
9540  // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
9541  } else if (S.getLangOpts().ZVector && ResType->isVectorType() &&
9542  (ResType->getAs<VectorType>()->getVectorKind() !=
9544  // The z vector extensions allow ++ and -- for non-bool vectors.
9545  } else if(S.getLangOpts().OpenCL && ResType->isVectorType() &&
9546  ResType->getAs<VectorType>()->getElementType()->isIntegerType()) {
9547  // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
9548  } else {
9549  S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
9550  << ResType << int(IsInc) << Op->getSourceRange();
9551  return QualType();
9552  }
9553  // At this point, we know we have a real, complex or pointer type.
9554  // Now make sure the operand is a modifiable lvalue.
9555  if (CheckForModifiableLvalue(Op, OpLoc, S))
9556  return QualType();
9557  // In C++, a prefix increment is the same type as the operand. Otherwise
9558  // (in C or with postfix), the increment is the unqualified type of the
9559  // operand.
9560  if (IsPrefix && S.getLangOpts().CPlusPlus) {
9561  VK = VK_LValue;
9562  OK = Op->getObjectKind();
9563  return ResType;
9564  } else {
9565  VK = VK_RValue;
9566  return ResType.getUnqualifiedType();
9567  }
9568 }
9569 
9570 
9571 /// getPrimaryDecl - Helper function for CheckAddressOfOperand().
9572 /// This routine allows us to typecheck complex/recursive expressions
9573 /// where the declaration is needed for type checking. We only need to
9574 /// handle cases when the expression references a function designator
9575 /// or is an lvalue. Here are some examples:
9576 /// - &(x) => x
9577 /// - &*****f => f for f a function designator.
9578 /// - &s.xx => s
9579 /// - &s.zz[1].yy -> s, if zz is an array
9580 /// - *(x + 1) -> x, if x is an array
9581 /// - &"123"[2] -> 0
9582 /// - & __real__ x -> x
9584  switch (E->getStmtClass()) {
9585  case Stmt::DeclRefExprClass:
9586  return cast<DeclRefExpr>(E)->getDecl();
9587  case Stmt::MemberExprClass:
9588  // If this is an arrow operator, the address is an offset from
9589  // the base's value, so the object the base refers to is
9590  // irrelevant.
9591  if (cast<MemberExpr>(E)->isArrow())
9592  return nullptr;
9593  // Otherwise, the expression refers to a part of the base
9594  return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
9595  case Stmt::ArraySubscriptExprClass: {
9596  // FIXME: This code shouldn't be necessary! We should catch the implicit
9597  // promotion of register arrays earlier.
9598  Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
9599  if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
9600  if (ICE->getSubExpr()->getType()->isArrayType())
9601  return getPrimaryDecl(ICE->getSubExpr());
9602  }
9603  return nullptr;
9604  }
9605  case Stmt::UnaryOperatorClass: {
9606  UnaryOperator *UO = cast<UnaryOperator>(E);
9607 
9608  switch(UO->getOpcode()) {
9609  case UO_Real:
9610  case UO_Imag:
9611  case UO_Extension:
9612  return getPrimaryDecl(UO->getSubExpr());
9613  default:
9614  return nullptr;
9615  }
9616  }
9617  case Stmt::ParenExprClass:
9618  return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
9619  case Stmt::ImplicitCastExprClass:
9620  // If the result of an implicit cast is an l-value, we care about
9621  // the sub-expression; otherwise, the result here doesn't matter.
9622  return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
9623  default:
9624  return nullptr;
9625  }
9626 }
9627 
9628 namespace {
9629  enum {
9630  AO_Bit_Field = 0,
9631  AO_Vector_Element = 1,
9632  AO_Property_Expansion = 2,
9633  AO_Register_Variable = 3,
9634  AO_No_Error = 4
9635  };
9636 }
9637 /// \brief Diagnose invalid operand for address of operations.
9638 ///
9639 /// \param Type The type of operand which cannot have its address taken.
9641  Expr *E, unsigned Type) {
9642  S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
9643 }
9644 
9645 /// CheckAddressOfOperand - The operand of & must be either a function
9646 /// designator or an lvalue designating an object. If it is an lvalue, the
9647 /// object cannot be declared with storage class register or be a bit field.
9648 /// Note: The usual conversions are *not* applied to the operand of the &
9649 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
9650 /// In C++, the operand might be an overloaded function name, in which case
9651 /// we allow the '&' but retain the overloaded-function type.
9653  if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
9654  if (PTy->getKind() == BuiltinType::Overload) {
9655  Expr *E = OrigOp.get()->IgnoreParens();
9656  if (!isa<OverloadExpr>(E)) {
9657  assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
9658  Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
9659  << OrigOp.get()->getSourceRange();
9660  return QualType();
9661  }
9662 
9663  OverloadExpr *Ovl = cast<OverloadExpr>(E);
9664  if (isa<UnresolvedMemberExpr>(Ovl))
9665  if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
9666  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
9667  << OrigOp.get()->getSourceRange();
9668  return QualType();
9669  }
9670 
9671  return Context.OverloadTy;
9672  }
9673 
9674  if (PTy->getKind() == BuiltinType::UnknownAny)
9675  return Context.UnknownAnyTy;
9676 
9677  if (PTy->getKind() == BuiltinType::BoundMember) {
9678  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
9679  << OrigOp.get()->getSourceRange();
9680  return QualType();
9681  }
9682 
9683  OrigOp = CheckPlaceholderExpr(OrigOp.get());
9684  if (OrigOp.isInvalid()) return QualType();
9685  }
9686 
9687  if (OrigOp.get()->isTypeDependent())
9688  return Context.DependentTy;
9689 
9690  assert(!OrigOp.get()->getType()->isPlaceholderType());
9691 
9692  // Make sure to ignore parentheses in subsequent checks
9693  Expr *op = OrigOp.get()->IgnoreParens();
9694 
9695  // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
9696  if (LangOpts.OpenCL && op->getType()->isFunctionType()) {
9697  Diag(op->getExprLoc(), diag::err_opencl_taking_function_address);
9698  return QualType();
9699  }
9700 
9701  if (getLangOpts().C99) {
9702  // Implement C99-only parts of addressof rules.
9703  if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
9704  if (uOp->getOpcode() == UO_Deref)
9705  // Per C99 6.5.3.2, the address of a deref always returns a valid result
9706  // (assuming the deref expression is valid).
9707  return uOp->getSubExpr()->getType();
9708  }
9709  // Technically, there should be a check for array subscript
9710  // expressions here, but the result of one is always an lvalue anyway.
9711  }
9712  ValueDecl *dcl = getPrimaryDecl(op);
9714  unsigned AddressOfError = AO_No_Error;
9715 
9716  if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
9717  bool sfinae = (bool)isSFINAEContext();
9718  Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary
9719  : diag::ext_typecheck_addrof_temporary)
9720  << op->getType() << op->getSourceRange();
9721  if (sfinae)
9722  return QualType();
9723  // Materialize the temporary as an lvalue so that we can take its address.
9724  OrigOp = op = new (Context)
9725  MaterializeTemporaryExpr(op->getType(), OrigOp.get(), true);
9726  } else if (isa<ObjCSelectorExpr>(op)) {
9727  return Context.getPointerType(op->getType());
9728  } else if (lval == Expr::LV_MemberFunction) {
9729  // If it's an instance method, make a member pointer.
9730  // The expression must have exactly the form &A::foo.
9731 
9732  // If the underlying expression isn't a decl ref, give up.
9733  if (!isa<DeclRefExpr>(op)) {
9734  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
9735  << OrigOp.get()->getSourceRange();
9736  return QualType();
9737  }
9738  DeclRefExpr *DRE = cast<DeclRefExpr>(op);
9739  CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
9740 
9741  // The id-expression was parenthesized.
9742  if (OrigOp.get() != DRE) {
9743  Diag(OpLoc, diag::err_parens_pointer_member_function)
9744  << OrigOp.get()->getSourceRange();
9745 
9746  // The method was named without a qualifier.
9747  } else if (!DRE->getQualifier()) {
9748  if (MD->getParent()->getName().empty())
9749  Diag(OpLoc, diag::err_unqualified_pointer_member_function)
9750  << op->getSourceRange();
9751  else {
9752  SmallString<32> Str;
9753  StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str);
9754  Diag(OpLoc, diag::err_unqualified_pointer_member_function)
9755  << op->getSourceRange()
9756  << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual);
9757  }
9758  }
9759 
9760  // Taking the address of a dtor is illegal per C++ [class.dtor]p2.
9761  if (isa<CXXDestructorDecl>(MD))
9762  Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();
9763 
9765  op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
9767  RequireCompleteType(OpLoc, MPTy, 0);
9768  return MPTy;
9769  } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
9770  // C99 6.5.3.2p1
9771  // The operand must be either an l-value or a function designator
9772  if (!op->getType()->isFunctionType()) {
9773  // Use a special diagnostic for loads from property references.
9774  if (isa<PseudoObjectExpr>(op)) {
9775  AddressOfError = AO_Property_Expansion;
9776  } else {
9777  Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
9778  << op->getType() << op->getSourceRange();
9779  return QualType();
9780  }
9781  }
9782  } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1
9783  // The operand cannot be a bit-field
9784  AddressOfError = AO_Bit_Field;
9785  } else if (op->getObjectKind() == OK_VectorComponent) {
9786  // The operand cannot be an element of a vector
9787  AddressOfError = AO_Vector_Element;
9788  } else if (dcl) { // C99 6.5.3.2p1
9789  // We have an lvalue with a decl. Make sure the decl is not declared
9790  // with the register storage-class specifier.
9791  if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
9792  // in C++ it is not error to take address of a register
9793  // variable (c++03 7.1.1P3)
9794  if (vd->getStorageClass() == SC_Register &&
9795  !getLangOpts().CPlusPlus) {
9796  AddressOfError = AO_Register_Variable;
9797  }
9798  } else if (isa<MSPropertyDecl>(dcl)) {
9799  AddressOfError = AO_Property_Expansion;
9800  } else if (isa<FunctionTemplateDecl>(dcl)) {
9801  return Context.OverloadTy;
9802  } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
9803  // Okay: we can take the address of a field.
9804  // Could be a pointer to member, though, if there is an explicit
9805  // scope qualifier for the class.
9806  if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
9807  DeclContext *Ctx = dcl->getDeclContext();
9808  if (Ctx && Ctx->isRecord()) {
9809  if (dcl->getType()->isReferenceType()) {
9810  Diag(OpLoc,
9811  diag::err_cannot_form_pointer_to_member_of_reference_type)
9812  << dcl->getDeclName() << dcl->getType();
9813  return QualType();
9814  }
9815 
9816  while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
9817  Ctx = Ctx->getParent();
9818 
9820  op->getType(),
9821  Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
9823  RequireCompleteType(OpLoc, MPTy, 0);
9824  return MPTy;
9825  }
9826  }
9827  } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl))
9828  llvm_unreachable("Unknown/unexpected decl type");
9829  }
9830 
9831  if (AddressOfError != AO_No_Error) {
9832  diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError);
9833  return QualType();
9834  }
9835 
9836  if (lval == Expr::LV_IncompleteVoidType) {
9837  // Taking the address of a void variable is technically illegal, but we
9838  // allow it in cases which are otherwise valid.
9839  // Example: "extern void x; void* y = &x;".
9840  Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
9841  }
9842 
9843  // If the operand has type "type", the result has type "pointer to type".
9844  if (op->getType()->isObjCObjectType())
9846  return Context.getPointerType(op->getType());
9847 }
9848 
9849 static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
9850  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
9851  if (!DRE)
9852  return;
9853  const Decl *D = DRE->getDecl();
9854  if (!D)
9855  return;
9856  const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
9857  if (!Param)
9858  return;
9859  if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
9860  if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
9861  return;
9862  if (FunctionScopeInfo *FD = S.getCurFunction())
9863  if (!FD->ModifiedNonNullParams.count(Param))
9864  FD->ModifiedNonNullParams.insert(Param);
9865 }
9866 
9867 /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
9869  SourceLocation OpLoc) {
9870  if (Op->isTypeDependent())
9871  return S.Context.DependentTy;
9872 
9873  ExprResult ConvResult = S.UsualUnaryConversions(Op);
9874  if (ConvResult.isInvalid())
9875  return QualType();
9876  Op = ConvResult.get();
9877  QualType OpTy = Op->getType();
9878  QualType Result;
9879 
9880  if (isa<CXXReinterpretCastExpr>(Op)) {
9881  QualType OpOrigType = Op->IgnoreParenCasts()->getType();
9882  S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
9883  Op->getSourceRange());
9884  }
9885 
9886  if (const PointerType *PT = OpTy->getAs<PointerType>())
9887  Result = PT->getPointeeType();
9888  else if (const ObjCObjectPointerType *OPT =
9889  OpTy->getAs<ObjCObjectPointerType>())
9890  Result = OPT->getPointeeType();
9891  else {
9892  ExprResult PR = S.CheckPlaceholderExpr(Op);
9893  if (PR.isInvalid()) return QualType();
9894  if (PR.get() != Op)
9895  return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
9896  }
9897 
9898  if (Result.isNull()) {
9899  S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
9900  << OpTy << Op->getSourceRange();
9901  return QualType();
9902  }
9903 
9904  // Note that per both C89 and C99, indirection is always legal, even if Result
9905  // is an incomplete type or void. It would be possible to warn about
9906  // dereferencing a void pointer, but it's completely well-defined, and such a
9907  // warning is unlikely to catch any mistakes. In C++, indirection is not valid
9908  // for pointers to 'void' but is fine for any other pointer type:
9909  //
9910  // C++ [expr.unary.op]p1:
9911  // [...] the expression to which [the unary * operator] is applied shall
9912  // be a pointer to an object type, or a pointer to a function type
9913  if (S.getLangOpts().CPlusPlus && Result->isVoidType())
9914  S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
9915  << OpTy << Op->getSourceRange();
9916 
9917  // Dereferences are usually l-values...
9918  VK = VK_LValue;
9919 
9920  // ...except that certain expressions are never l-values in C.
9921  if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
9922  VK = VK_RValue;
9923 
9924  return Result;
9925 }
9926 
9927 BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
9928  BinaryOperatorKind Opc;
9929  switch (Kind) {
9930  default: llvm_unreachable("Unknown binop!");
9931  case tok::periodstar: Opc = BO_PtrMemD; break;
9932  case tok::arrowstar: Opc = BO_PtrMemI; break;
9933  case tok::star: Opc = BO_Mul; break;
9934  case tok::slash: Opc = BO_Div; break;
9935  case tok::percent: Opc = BO_Rem; break;
9936  case tok::plus: Opc = BO_Add; break;
9937  case tok::minus: Opc = BO_Sub; break;
9938  case tok::lessless: Opc = BO_Shl; break;
9939  case tok::greatergreater: Opc = BO_Shr; break;
9940  case tok::lessequal: Opc = BO_LE; break;
9941  case tok::less: Opc = BO_LT; break;
9942  case tok::greaterequal: Opc = BO_GE; break;
9943  case tok::greater: Opc = BO_GT; break;
9944  case tok::exclaimequal: Opc = BO_NE; break;
9945  case tok::equalequal: Opc = BO_EQ; break;
9946  case tok::amp: Opc = BO_And; break;
9947  case tok::caret: Opc = BO_Xor; break;
9948  case tok::pipe: Opc = BO_Or; break;
9949  case tok::ampamp: Opc = BO_LAnd; break;
9950  case tok::pipepipe: Opc = BO_LOr; break;
9951  case tok::equal: Opc = BO_Assign; break;
9952  case tok::starequal: Opc = BO_MulAssign; break;
9953  case tok::slashequal: Opc = BO_DivAssign; break;
9954  case tok::percentequal: Opc = BO_RemAssign; break;
9955  case tok::plusequal: Opc = BO_AddAssign; break;
9956  case tok::minusequal: Opc = BO_SubAssign; break;
9957  case tok::lesslessequal: Opc = BO_ShlAssign; break;
9958  case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
9959  case tok::ampequal: Opc = BO_AndAssign; break;
9960  case tok::caretequal: Opc = BO_XorAssign; break;
9961  case tok::pipeequal: Opc = BO_OrAssign; break;
9962  case tok::comma: Opc = BO_Comma; break;
9963  }
9964  return Opc;
9965 }
9966 
9968  tok::TokenKind Kind) {
9969  UnaryOperatorKind Opc;
9970  switch (Kind) {
9971  default: llvm_unreachable("Unknown unary op!");
9972  case tok::plusplus: Opc = UO_PreInc; break;
9973  case tok::minusminus: Opc = UO_PreDec; break;
9974  case tok::amp: Opc = UO_AddrOf; break;
9975  case tok::star: Opc = UO_Deref; break;
9976  case tok::plus: Opc = UO_Plus; break;
9977  case tok::minus: Opc = UO_Minus; break;
9978  case tok::tilde: Opc = UO_Not; break;
9979  case tok::exclaim: Opc = UO_LNot; break;
9980  case tok::kw___real: Opc = UO_Real; break;
9981  case tok::kw___imag: Opc = UO_Imag; break;
9982  case tok::kw___extension__: Opc = UO_Extension; break;
9983  }
9984  return Opc;
9985 }
9986 
9987 /// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
9988 /// This warning is only emitted for builtin assignment operations. It is also
9989 /// suppressed in the event of macro expansions.
9990 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
9991  SourceLocation OpLoc) {
9992  if (!S.ActiveTemplateInstantiations.empty())
9993  return;
9994  if (OpLoc.isInvalid() || OpLoc.isMacroID())
9995  return;
9996  LHSExpr = LHSExpr->IgnoreParenImpCasts();
9997  RHSExpr = RHSExpr->IgnoreParenImpCasts();
9998  const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
9999  const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
10000  if (!LHSDeclRef || !RHSDeclRef ||
10001  LHSDeclRef->getLocation().isMacroID() ||
10002  RHSDeclRef->getLocation().isMacroID())
10003  return;
10004  const ValueDecl *LHSDecl =
10005  cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
10006  const ValueDecl *RHSDecl =
10007  cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
10008  if (LHSDecl != RHSDecl)
10009  return;
10010  if (LHSDecl->getType().isVolatileQualified())
10011  return;
10012  if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
10013  if (RefTy->getPointeeType().isVolatileQualified())
10014  return;
10015 
10016  S.Diag(OpLoc, diag::warn_self_assignment)
10017  << LHSDeclRef->getType()
10018  << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
10019 }
10020 
10021 /// Check if a bitwise-& is performed on an Objective-C pointer. This
10022 /// is usually indicative of introspection within the Objective-C pointer.
10024  SourceLocation OpLoc) {
10025  if (!S.getLangOpts().ObjC1)
10026  return;
10027 
10028  const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr;
10029  const Expr *LHS = L.get();
10030  const Expr *RHS = R.get();
10031 
10033  ObjCPointerExpr = LHS;
10034  OtherExpr = RHS;
10035  }
10036  else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
10037  ObjCPointerExpr = RHS;
10038  OtherExpr = LHS;
10039  }
10040 
10041  // This warning is deliberately made very specific to reduce false
10042  // positives with logic that uses '&' for hashing. This logic mainly
10043  // looks for code trying to introspect into tagged pointers, which
10044  // code should generally never do.
10045  if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
10046  unsigned Diag = diag::warn_objc_pointer_masking;
10047  // Determine if we are introspecting the result of performSelectorXXX.
10048  const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
10049  // Special case messages to -performSelector and friends, which
10050  // can return non-pointer values boxed in a pointer value.
10051  // Some clients may wish to silence warnings in this subcase.
10052  if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) {
10053  Selector S = ME->getSelector();
10054  StringRef SelArg0 = S.getNameForSlot(0);
10055  if (SelArg0.startswith("performSelector"))
10056  Diag = diag::warn_objc_pointer_masking_performSelector;
10057  }
10058 
10059  S.Diag(OpLoc, Diag)
10060  << ObjCPointerExpr->getSourceRange();
10061  }
10062 }
10063 
10065  if (!E)
10066  return nullptr;
10067  if (auto *DRE = dyn_cast<DeclRefExpr>(E))
10068  return DRE->getDecl();
10069  if (auto *ME = dyn_cast<MemberExpr>(E))
10070  return ME->getMemberDecl();
10071  if (auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
10072  return IRE->getDecl();
10073  return nullptr;
10074 }
10075 
10076 /// CreateBuiltinBinOp - Creates a new built-in binary operation with
10077 /// operator @p Opc at location @c TokLoc. This routine only supports
10078 /// built-in operations; ActOnBinOp handles overloaded operators.
10080  BinaryOperatorKind Opc,
10081  Expr *LHSExpr, Expr *RHSExpr) {
10082  if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) {
10083  // The syntax only allows initializer lists on the RHS of assignment,
10084  // so we don't need to worry about accepting invalid code for
10085  // non-assignment operators.
10086  // C++11 5.17p9:
10087  // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning
10088  // of x = {} is x = T().
10089  InitializationKind Kind =
10090  InitializationKind::CreateDirectList(RHSExpr->getLocStart());
10091  InitializedEntity Entity =
10093  InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr);
10094  ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr);
10095  if (Init.isInvalid())
10096  return Init;
10097  RHSExpr = Init.get();
10098  }
10099 
10100  ExprResult LHS = LHSExpr, RHS = RHSExpr;
10101  QualType ResultTy; // Result type of the binary operator.
10102  // The following two variables are used for compound assignment operators
10103  QualType CompLHSTy; // Type of LHS after promotions for computation
10104  QualType CompResultTy; // Type of computation result
10105  ExprValueKind VK = VK_RValue;
10107 
10108  if (!getLangOpts().CPlusPlus) {
10109  // C cannot handle TypoExpr nodes on either side of a binop because it
10110  // doesn't handle dependent types properly, so make sure any TypoExprs have
10111  // been dealt with before checking the operands.
10112  LHS = CorrectDelayedTyposInExpr(LHSExpr);
10113  RHS = CorrectDelayedTyposInExpr(RHSExpr, [Opc, LHS](Expr *E) {
10114  if (Opc != BO_Assign)
10115  return ExprResult(E);
10116  // Avoid correcting the RHS to the same Expr as the LHS.
10117  Decl *D = getDeclFromExpr(E);
10118  return (D && D == getDeclFromExpr(LHS.get())) ? ExprError() : E;
10119  });
10120  if (!LHS.isUsable() || !RHS.isUsable())
10121  return ExprError();
10122  }
10123 
10124  switch (Opc) {
10125  case BO_Assign:
10126  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
10127  if (getLangOpts().CPlusPlus &&
10128  LHS.get()->getObjectKind() != OK_ObjCProperty) {
10129  VK = LHS.get()->getValueKind();
10130  OK = LHS.get()->getObjectKind();
10131  }
10132  if (!ResultTy.isNull()) {
10133  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc);
10134  DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc);
10135  }
10136  RecordModifiableNonNullParam(*this, LHS.get());
10137  break;
10138  case BO_PtrMemD:
10139  case BO_PtrMemI:
10140  ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
10141  Opc == BO_PtrMemI);
10142  break;
10143  case BO_Mul:
10144  case BO_Div:
10145  ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false,
10146  Opc == BO_Div);
10147  break;
10148  case BO_Rem:
10149  ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc);
10150  break;
10151  case BO_Add:
10152  ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc);
10153  break;
10154  case BO_Sub:
10155  ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc);
10156  break;
10157  case BO_Shl:
10158  case BO_Shr:
10159  ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc);
10160  break;
10161  case BO_LE:
10162  case BO_LT:
10163  case BO_GE:
10164  case BO_GT:
10165  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true);
10166  break;
10167  case BO_EQ:
10168  case BO_NE:
10169  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false);
10170  break;
10171  case BO_And:
10172  checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
10173  case BO_Xor:
10174  case BO_Or:
10175  ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc);
10176  break;
10177  case BO_LAnd:
10178  case BO_LOr:
10179  ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc);
10180  break;
10181  case BO_MulAssign:
10182  case BO_DivAssign:
10183  CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true,
10184  Opc == BO_DivAssign);
10185  CompLHSTy = CompResultTy;
10186  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10187  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10188  break;
10189  case BO_RemAssign:
10190  CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true);
10191  CompLHSTy = CompResultTy;
10192  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10193  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10194  break;
10195  case BO_AddAssign:
10196  CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy);
10197  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10198  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10199  break;
10200  case BO_SubAssign:
10201  CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy);
10202  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10203  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10204  break;
10205  case BO_ShlAssign:
10206  case BO_ShrAssign:
10207  CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true);
10208  CompLHSTy = CompResultTy;
10209  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10210  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10211  break;
10212  case BO_AndAssign:
10213  case BO_OrAssign: // fallthrough
10214  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc);
10215  case BO_XorAssign:
10216  CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true);
10217  CompLHSTy = CompResultTy;
10218  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
10219  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
10220  break;
10221  case BO_Comma:
10222  ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc);
10223  if (getLangOpts().CPlusPlus && !RHS.isInvalid()) {
10224  VK = RHS.get()->getValueKind();
10225  OK = RHS.get()->getObjectKind();
10226  }
10227  break;
10228  }
10229  if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid())
10230  return ExprError();
10231 
10232  // Check for array bounds violations for both sides of the BinaryOperator
10233  CheckArrayAccess(LHS.get());
10234  CheckArrayAccess(RHS.get());
10235 
10236  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
10237  NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
10238  &Context.Idents.get("object_setClass"),
10239  SourceLocation(), LookupOrdinaryName);
10240  if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
10241  SourceLocation RHSLocEnd = PP.getLocForEndOfToken(RHS.get()->getLocEnd());
10242  Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign) <<
10243  FixItHint::CreateInsertion(LHS.get()->getLocStart(), "object_setClass(") <<
10244  FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc), ",") <<
10245  FixItHint::CreateInsertion(RHSLocEnd, ")");
10246  }
10247  else
10248  Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
10249  }
10250  else if (const ObjCIvarRefExpr *OIRE =
10251  dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
10252  DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
10253 
10254  if (CompResultTy.isNull())
10255  return new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK,
10256  OK, OpLoc, FPFeatures.fp_contract);
10257  if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
10258  OK_ObjCProperty) {
10259  VK = VK_LValue;
10260  OK = LHS.get()->getObjectKind();
10261  }
10262  return new (Context) CompoundAssignOperator(
10263  LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy,
10264  OpLoc, FPFeatures.fp_contract);
10265 }
10266 
10267 /// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
10268 /// operators are mixed in a way that suggests that the programmer forgot that
10269 /// comparison operators have higher precedence. The most typical example of
10270 /// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
10272  SourceLocation OpLoc, Expr *LHSExpr,
10273  Expr *RHSExpr) {
10274  BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
10275  BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr);
10276 
10277  // Check that one of the sides is a comparison operator.
10278  bool isLeftComp = LHSBO && LHSBO->isComparisonOp();
10279  bool isRightComp = RHSBO && RHSBO->isComparisonOp();
10280  if (!isLeftComp && !isRightComp)
10281  return;
10282 
10283  // Bitwise operations are sometimes used as eager logical ops.
10284  // Don't diagnose this.
10285  bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp();
10286  bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp();
10287  if ((isLeftComp || isLeftBitwise) && (isRightComp || isRightBitwise))
10288  return;
10289 
10290  SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(),
10291  OpLoc)
10292  : SourceRange(OpLoc, RHSExpr->getLocEnd());
10293  StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr();
10294  SourceRange ParensRange = isLeftComp ?
10295  SourceRange(LHSBO->getRHS()->getLocStart(), RHSExpr->getLocEnd())
10296  : SourceRange(LHSExpr->getLocStart(), RHSBO->getLHS()->getLocEnd());
10297 
10298  Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
10299  << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
10300  SuggestParentheses(Self, OpLoc,
10301  Self.PDiag(diag::note_precedence_silence) << OpStr,
10302  (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
10303  SuggestParentheses(Self, OpLoc,
10304  Self.PDiag(diag::note_precedence_bitwise_first)
10306  ParensRange);
10307 }
10308 
10309 /// \brief It accepts a '&' expr that is inside a '|' one.
10310 /// Emit a diagnostic together with a fixit hint that wraps the '&' expression
10311 /// in parentheses.
10312 static void
10314  BinaryOperator *Bop) {
10315  assert(Bop->getOpcode() == BO_And);
10316  Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or)
10317  << Bop->getSourceRange() << OpLoc;
10318  SuggestParentheses(Self, Bop->getOperatorLoc(),
10319  Self.PDiag(diag::note_precedence_silence)
10320  << Bop->getOpcodeStr(),
10321  Bop->getSourceRange());
10322 }
10323 
10324 /// \brief It accepts a '&&' expr that is inside a '||' one.
10325 /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
10326 /// in parentheses.
10327 static void
10329  BinaryOperator *Bop) {
10330  assert(Bop->getOpcode() == BO_LAnd);
10331  Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
10332  << Bop->getSourceRange() << OpLoc;
10333  SuggestParentheses(Self, Bop->getOperatorLoc(),
10334  Self.PDiag(diag::note_precedence_silence)
10335  << Bop->getOpcodeStr(),
10336  Bop->getSourceRange());
10337 }
10338 
10339 /// \brief Returns true if the given expression can be evaluated as a constant
10340 /// 'true'.
10341 static bool EvaluatesAsTrue(Sema &S, Expr *E) {
10342  bool Res;
10343  return !E->isValueDependent() &&
10344  E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res;
10345 }
10346 
10347 /// \brief Returns true if the given expression can be evaluated as a constant
10348 /// 'false'.
10349 static bool EvaluatesAsFalse(Sema &S, Expr *E) {
10350  bool Res;
10351  return !E->isValueDependent() &&
10352  E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
10353 }
10354 
10355 /// \brief Look for '&&' in the left hand of a '||' expr.
10357  Expr *LHSExpr, Expr *RHSExpr) {
10358  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) {
10359  if (Bop->getOpcode() == BO_LAnd) {
10360  // If it's "a && b || 0" don't warn since the precedence doesn't matter.
10361  if (EvaluatesAsFalse(S, RHSExpr))
10362  return;
10363  // If it's "1 && a || b" don't warn since the precedence doesn't matter.
10364  if (!EvaluatesAsTrue(S, Bop->getLHS()))
10365  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
10366  } else if (Bop->getOpcode() == BO_LOr) {
10367  if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
10368  // If it's "a || b && 1 || c" we didn't warn earlier for
10369  // "a || b && 1", but warn now.
10370  if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS()))
10371  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
10372  }
10373  }
10374  }
10375 }
10376 
10377 /// \brief Look for '&&' in the right hand of a '||' expr.
10379  Expr *LHSExpr, Expr *RHSExpr) {
10380  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) {
10381  if (Bop->getOpcode() == BO_LAnd) {
10382  // If it's "0 || a && b" don't warn since the precedence doesn't matter.
10383  if (EvaluatesAsFalse(S, LHSExpr))
10384  return;
10385  // If it's "a || b && 1" don't warn since the precedence doesn't matter.
10386  if (!EvaluatesAsTrue(S, Bop->getRHS()))
10387  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
10388  }
10389  }
10390 }
10391 
10392 /// \brief Look for '&' in the left or right hand of a '|' expr.
10394  Expr *OrArg) {
10395  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) {
10396  if (Bop->getOpcode() == BO_And)
10397  return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop);
10398  }
10399 }
10400 
10402  Expr *SubExpr, StringRef Shift) {
10403  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
10404  if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
10405  StringRef Op = Bop->getOpcodeStr();
10406  S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
10407  << Bop->getSourceRange() << OpLoc << Shift << Op;
10408  SuggestParentheses(S, Bop->getOperatorLoc(),
10409  S.PDiag(diag::note_precedence_silence) << Op,
10410  Bop->getSourceRange());
10411  }
10412  }
10413 }
10414 
10416  Expr *LHSExpr, Expr *RHSExpr) {
10417  CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
10418  if (!OCE)
10419  return;
10420 
10421  FunctionDecl *FD = OCE->getDirectCallee();
10422  if (!FD || !FD->isOverloadedOperator())
10423  return;
10424 
10426  if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
10427  return;
10428 
10429  S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
10430  << LHSExpr->getSourceRange() << RHSExpr->getSourceRange()
10431  << (Kind == OO_LessLess);
10433  S.PDiag(diag::note_precedence_silence)
10434  << (Kind == OO_LessLess ? "<<" : ">>"),
10435  OCE->getSourceRange());
10436  SuggestParentheses(S, OpLoc,
10437  S.PDiag(diag::note_evaluate_comparison_first),
10438  SourceRange(OCE->getArg(1)->getLocStart(),
10439  RHSExpr->getLocEnd()));
10440 }
10441 
10442 /// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
10443 /// precedence.
10445  SourceLocation OpLoc, Expr *LHSExpr,
10446  Expr *RHSExpr){
10447  // Diagnose "arg1 'bitwise' arg2 'eq' arg3".
10448  if (BinaryOperator::isBitwiseOp(Opc))
10449  DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);
10450 
10451  // Diagnose "arg1 & arg2 | arg3"
10452  if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) {
10453  DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr);
10454  DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr);
10455  }
10456 
10457  // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
10458  // We don't warn for 'assert(a || b && "bad")' since this is safe.
10459  if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
10460  DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
10461  DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
10462  }
10463 
10464  if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
10465  || Opc == BO_Shr) {
10466  StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
10467  DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
10468  DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
10469  }
10470 
10471  // Warn on overloaded shift operators and comparisons, such as:
10472  // cout << 5 == 4;
10474  DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
10475 }
10476 
10477 // Binary Operators. 'Tok' is the token for the operator.
10479  tok::TokenKind Kind,
10480  Expr *LHSExpr, Expr *RHSExpr) {
10481  BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
10482  assert(LHSExpr && "ActOnBinOp(): missing left expression");
10483  assert(RHSExpr && "ActOnBinOp(): missing right expression");
10484 
10485  // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
10486  DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);
10487 
10488  return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
10489 }
10490 
10491 /// Build an overloaded binary operator expression in the given scope.
10493  BinaryOperatorKind Opc,
10494  Expr *LHS, Expr *RHS) {
10495  // Find all of the overloaded operators visible from this
10496  // point. We perform both an operator-name lookup from the local
10497  // scope and an argument-dependent lookup based on the types of
10498  // the arguments.
10499  UnresolvedSet<16> Functions;
10500  OverloadedOperatorKind OverOp
10502  if (Sc && OverOp != OO_None && OverOp != OO_Equal)
10503  S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(),
10504  RHS->getType(), Functions);
10505 
10506  // Build the (potentially-overloaded, potentially-dependent)
10507  // binary operation.
10508  return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
10509 }
10510 
10512  BinaryOperatorKind Opc,
10513  Expr *LHSExpr, Expr *RHSExpr) {
10514  // We want to end up calling one of checkPseudoObjectAssignment
10515  // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if
10516  // both expressions are overloadable or either is type-dependent),
10517  // or CreateBuiltinBinOp (in any other case). We also want to get
10518  // any placeholder types out of the way.
10519 
10520  // Handle pseudo-objects in the LHS.
10521  if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) {
10522  // Assignments with a pseudo-object l-value need special analysis.
10523  if (pty->getKind() == BuiltinType::PseudoObject &&
10525  return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr);
10526 
10527  // Don't resolve overloads if the other type is overloadable.
10528  if (pty->getKind() == BuiltinType::Overload) {
10529  // We can't actually test that if we still have a placeholder,
10530  // though. Fortunately, none of the exceptions we see in that
10531  // code below are valid when the LHS is an overload set. Note
10532  // that an overload set can be dependently-typed, but it never
10533  // instantiates to having an overloadable type.
10534  ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
10535  if (resolvedRHS.isInvalid()) return ExprError();
10536  RHSExpr = resolvedRHS.get();
10537 
10538  if (RHSExpr->isTypeDependent() ||
10539  RHSExpr->getType()->isOverloadableType())
10540  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10541  }
10542 
10543  ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
10544  if (LHS.isInvalid()) return ExprError();
10545  LHSExpr = LHS.get();
10546  }
10547 
10548  // Handle pseudo-objects in the RHS.
10549  if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) {
10550  // An overload in the RHS can potentially be resolved by the type
10551  // being assigned to.
10552  if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
10553  if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
10554  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10555 
10556  if (LHSExpr->getType()->isOverloadableType())
10557  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10558 
10559  return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
10560  }
10561 
10562  // Don't resolve overloads if the other type is overloadable.
10563  if (pty->getKind() == BuiltinType::Overload &&
10564  LHSExpr->getType()->isOverloadableType())
10565  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10566 
10567  ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
10568  if (!resolvedRHS.isUsable()) return ExprError();
10569  RHSExpr = resolvedRHS.get();
10570  }
10571 
10572  if (getLangOpts().CPlusPlus) {
10573  // If either expression is type-dependent, always build an
10574  // overloaded op.
10575  if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
10576  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10577 
10578  // Otherwise, build an overloaded op if either expression has an
10579  // overloadable type.
10580  if (LHSExpr->getType()->isOverloadableType() ||
10581  RHSExpr->getType()->isOverloadableType())
10582  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
10583  }
10584 
10585  // Build a built-in binary operation.
10586  return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
10587 }
10588 
10590  UnaryOperatorKind Opc,
10591  Expr *InputExpr) {
10592  ExprResult Input = InputExpr;
10593  ExprValueKind VK = VK_RValue;
10595  QualType resultType;
10596  switch (Opc) {
10597  case UO_PreInc:
10598  case UO_PreDec:
10599  case UO_PostInc:
10600  case UO_PostDec:
10601  resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OK,
10602  OpLoc,
10603  Opc == UO_PreInc ||
10604  Opc == UO_PostInc,
10605  Opc == UO_PreInc ||
10606  Opc == UO_PreDec);
10607  break;
10608  case UO_AddrOf:
10609  resultType = CheckAddressOfOperand(Input, OpLoc);
10610  RecordModifiableNonNullParam(*this, InputExpr);
10611  break;
10612  case UO_Deref: {
10613  Input = DefaultFunctionArrayLvalueConversion(Input.get());
10614  if (Input.isInvalid()) return ExprError();
10615  resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc);
10616  break;
10617  }
10618  case UO_Plus:
10619  case UO_Minus:
10620  Input = UsualUnaryConversions(Input.get());
10621  if (Input.isInvalid()) return ExprError();
10622  resultType = Input.get()->getType();
10623  if (resultType->isDependentType())
10624  break;
10625  if (resultType->isArithmeticType()) // C99 6.5.3.3p1
10626  break;
10627  else if (resultType->isVectorType() &&
10628  // The z vector extensions don't allow + or - with bool vectors.
10629  (!Context.getLangOpts().ZVector ||
10630  resultType->getAs<VectorType>()->getVectorKind() !=
10632  break;
10633  else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
10634  Opc == UO_Plus &&
10635  resultType->isPointerType())
10636  break;
10637 
10638  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10639  << resultType << Input.get()->getSourceRange());
10640 
10641  case UO_Not: // bitwise complement
10642  Input = UsualUnaryConversions(Input.get());
10643  if (Input.isInvalid())
10644  return ExprError();
10645  resultType = Input.get()->getType();
10646  if (resultType->isDependentType())
10647  break;
10648  // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
10649  if (resultType->isComplexType() || resultType->isComplexIntegerType())
10650  // C99 does not support '~' for complex conjugation.
10651  Diag(OpLoc, diag::ext_integer_complement_complex)
10652  << resultType << Input.get()->getSourceRange();
10653  else if (resultType->hasIntegerRepresentation())
10654  break;
10655  else if (resultType->isExtVectorType()) {
10656  if (Context.getLangOpts().OpenCL) {
10657  // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate
10658  // on vector float types.
10659  QualType T = resultType->getAs<ExtVectorType>()->getElementType();
10660  if (!T->isIntegerType())
10661  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10662  << resultType << Input.get()->getSourceRange());
10663  }
10664  break;
10665  } else {
10666  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10667  << resultType << Input.get()->getSourceRange());
10668  }
10669  break;
10670 
10671  case UO_LNot: // logical negation
10672  // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
10673  Input = DefaultFunctionArrayLvalueConversion(Input.get());
10674  if (Input.isInvalid()) return ExprError();
10675  resultType = Input.get()->getType();
10676 
10677  // Though we still have to promote half FP to float...
10678  if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) {
10679  Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get();
10680  resultType = Context.FloatTy;
10681  }
10682 
10683  if (resultType->isDependentType())
10684  break;
10685  if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
10686  // C99 6.5.3.3p1: ok, fallthrough;
10687  if (Context.getLangOpts().CPlusPlus) {
10688  // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
10689  // operand contextually converted to bool.
10690  Input = ImpCastExprToType(Input.get(), Context.BoolTy,
10691  ScalarTypeToBooleanCastKind(resultType));
10692  } else if (Context.getLangOpts().OpenCL &&
10693  Context.getLangOpts().OpenCLVersion < 120) {
10694  // OpenCL v1.1 6.3.h: The logical operator not (!) does not
10695  // operate on scalar float types.
10696  if (!resultType->isIntegerType())
10697  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10698  << resultType << Input.get()->getSourceRange());
10699  }
10700  } else if (resultType->isExtVectorType()) {
10701  if (Context.getLangOpts().OpenCL &&
10702  Context.getLangOpts().OpenCLVersion < 120) {
10703  // OpenCL v1.1 6.3.h: The logical operator not (!) does not
10704  // operate on vector float types.
10705  QualType T = resultType->getAs<ExtVectorType>()->getElementType();
10706  if (!T->isIntegerType())
10707  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10708  << resultType << Input.get()->getSourceRange());
10709  }
10710  // Vector logical not returns the signed variant of the operand type.
10711  resultType = GetSignedVectorType(resultType);
10712  break;
10713  } else {
10714  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
10715  << resultType << Input.get()->getSourceRange());
10716  }
10717 
10718  // LNot always has type int. C99 6.5.3.3p5.
10719  // In C++, it's bool. C++ 5.3.1p8
10720  resultType = Context.getLogicalOperationType();
10721  break;
10722  case UO_Real:
10723  case UO_Imag:
10724  resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real);
10725  // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary
10726  // complex l-values to ordinary l-values and all other values to r-values.
10727  if (Input.isInvalid()) return ExprError();
10728  if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) {
10729  if (Input.get()->getValueKind() != VK_RValue &&
10730  Input.get()->getObjectKind() == OK_Ordinary)
10731  VK = Input.get()->getValueKind();
10732  } else if (!getLangOpts().CPlusPlus) {
10733  // In C, a volatile scalar is read by __imag. In C++, it is not.
10734  Input = DefaultLvalueConversion(Input.get());
10735  }
10736  break;
10737  case UO_Extension:
10738  resultType = Input.get()->getType();
10739  VK = Input.get()->getValueKind();
10740  OK = Input.get()->getObjectKind();
10741  break;
10742  }
10743  if (resultType.isNull() || Input.isInvalid())
10744  return ExprError();
10745 
10746  // Check for array bounds violations in the operand of the UnaryOperator,
10747  // except for the '*' and '&' operators that have to be handled specially
10748  // by CheckArrayAccess (as there are special cases like &array[arraysize]
10749  // that are explicitly defined as valid by the standard).
10750  if (Opc != UO_AddrOf && Opc != UO_Deref)
10751  CheckArrayAccess(Input.get());
10752 
10753  return new (Context)
10754  UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc);
10755 }
10756 
10757 /// \brief Determine whether the given expression is a qualified member
10758 /// access expression, of a form that could be turned into a pointer to member
10759 /// with the address-of operator.
10761  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
10762  if (!DRE->getQualifier())
10763  return false;
10764 
10765  ValueDecl *VD = DRE->getDecl();
10766  if (!VD->isCXXClassMember())
10767  return false;
10768 
10769  if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
10770  return true;
10771  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD))
10772  return Method->isInstance();
10773 
10774  return false;
10775  }
10776 
10777  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
10778  if (!ULE->getQualifier())
10779  return false;
10780 
10781  for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(),
10782  DEnd = ULE->decls_end();
10783  D != DEnd; ++D) {
10784  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) {
10785  if (Method->isInstance())
10786  return true;
10787  } else {
10788  // Overload set does not contain methods.
10789  break;
10790  }
10791  }
10792 
10793  return false;
10794  }
10795 
10796  return false;
10797 }
10798 
10800  UnaryOperatorKind Opc, Expr *Input) {
10801  // First things first: handle placeholders so that the
10802  // overloaded-operator check considers the right type.
10803  if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
10804  // Increment and decrement of pseudo-object references.
10805  if (pty->getKind() == BuiltinType::PseudoObject &&
10807  return checkPseudoObjectIncDec(S, OpLoc, Opc, Input);
10808 
10809  // extension is always a builtin operator.
10810  if (Opc == UO_Extension)
10811  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
10812 
10813  // & gets special logic for several kinds of placeholder.
10814  // The builtin code knows what to do.
10815  if (Opc == UO_AddrOf &&
10816  (pty->getKind() == BuiltinType::Overload ||
10817  pty->getKind() == BuiltinType::UnknownAny ||
10818  pty->getKind() == BuiltinType::BoundMember))
10819  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
10820 
10821  // Anything else needs to be handled now.
10822  ExprResult Result = CheckPlaceholderExpr(Input);
10823  if (Result.isInvalid()) return ExprError();
10824  Input = Result.get();
10825  }
10826 
10827  if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
10829  !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) {
10830  // Find all of the overloaded operators visible from this
10831  // point. We perform both an operator-name lookup from the local
10832  // scope and an argument-dependent lookup based on the types of
10833  // the arguments.
10834  UnresolvedSet<16> Functions;
10836  if (S && OverOp != OO_None)
10837  LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
10838  Functions);
10839 
10840  return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
10841  }
10842 
10843  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
10844 }
10845 
10846 // Unary Operators. 'Tok' is the token for the operator.
10848  tok::TokenKind Op, Expr *Input) {
10849  return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
10850 }
10851 
10852 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
10854  LabelDecl *TheDecl) {
10855  TheDecl->markUsed(Context);
10856  // Create the AST node. The address of a label always has type 'void*'.
10857  return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
10859 }
10860 
10861 /// Given the last statement in a statement-expression, check whether
10862 /// the result is a producing expression (like a call to an
10863 /// ns_returns_retained function) and, if so, rebuild it to hoist the
10864 /// release out of the full-expression. Otherwise, return null.
10865 /// Cannot fail.
10867  // Should always be wrapped with one of these.
10868  ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement);
10869  if (!cleanups) return nullptr;
10870 
10871  ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr());
10872  if (!cast || cast->getCastKind() != CK_ARCConsumeObject)
10873  return nullptr;
10874 
10875  // Splice out the cast. This shouldn't modify any interesting
10876  // features of the statement.
10877  Expr *producer = cast->getSubExpr();
10878  assert(producer->getType() == cast->getType());
10879  assert(producer->getValueKind() == cast->getValueKind());
10880  cleanups->setSubExpr(producer);
10881  return cleanups;
10882 }
10883 
10885  PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
10886 }
10887 
10889  // Note that function is also called by TreeTransform when leaving a
10890  // StmtExpr scope without rebuilding anything.
10891 
10892  DiscardCleanupsInEvaluationContext();
10893  PopExpressionEvaluationContext();
10894 }
10895 
10896 ExprResult
10898  SourceLocation RPLoc) { // "({..})"
10899  assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
10900  CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
10901 
10902  if (hasAnyUnrecoverableErrorsInThisFunction())
10903  DiscardCleanupsInEvaluationContext();
10904  assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!");
10905  PopExpressionEvaluationContext();
10906 
10907  // FIXME: there are a variety of strange constraints to enforce here, for
10908  // example, it is not possible to goto into a stmt expression apparently.
10909  // More semantic analysis is needed.
10910 
10911  // If there are sub-stmts in the compound stmt, take the type of the last one
10912  // as the type of the stmtexpr.
10913  QualType Ty = Context.VoidTy;
10914  bool StmtExprMayBindToTemp = false;
10915  if (!Compound->body_empty()) {
10916  Stmt *LastStmt = Compound->body_back();
10917  LabelStmt *LastLabelStmt = nullptr;
10918  // If LastStmt is a label, skip down through into the body.
10919  while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) {
10920  LastLabelStmt = Label;
10921  LastStmt = Label->getSubStmt();
10922  }
10923 
10924  if (Expr *LastE = dyn_cast<Expr>(LastStmt)) {
10925  // Do function/array conversion on the last expression, but not
10926  // lvalue-to-rvalue. However, initialize an unqualified type.
10927  ExprResult LastExpr = DefaultFunctionArrayConversion(LastE);
10928  if (LastExpr.isInvalid())
10929  return ExprError();
10930  Ty = LastExpr.get()->getType().getUnqualifiedType();
10931 
10932  if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) {
10933  // In ARC, if the final expression ends in a consume, splice
10934  // the consume out and bind it later. In the alternate case
10935  // (when dealing with a retainable type), the result
10936  // initialization will create a produce. In both cases the
10937  // result will be +1, and we'll need to balance that out with
10938  // a bind.
10939  if (Expr *rebuiltLastStmt
10940  = maybeRebuildARCConsumingStmt(LastExpr.get())) {
10941  LastExpr = rebuiltLastStmt;
10942  } else {
10943  LastExpr = PerformCopyInitialization(
10945  Ty,
10946  false),
10947  SourceLocation(),
10948  LastExpr);
10949  }
10950 
10951  if (LastExpr.isInvalid())
10952  return ExprError();
10953  if (LastExpr.get() != nullptr) {
10954  if (!LastLabelStmt)
10955  Compound->setLastStmt(LastExpr.get());
10956  else
10957  LastLabelStmt->setSubStmt(LastExpr.get());
10958  StmtExprMayBindToTemp = true;
10959  }
10960  }
10961  }
10962  }
10963 
10964  // FIXME: Check that expression type is complete/non-abstract; statement
10965  // expressions are not lvalues.
10966  Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
10967  if (StmtExprMayBindToTemp)
10968  return MaybeBindToTemporary(ResStmtExpr);
10969  return ResStmtExpr;
10970 }
10971 
10973  TypeSourceInfo *TInfo,
10974  OffsetOfComponent *CompPtr,
10975  unsigned NumComponents,
10976  SourceLocation RParenLoc) {
10977  QualType ArgTy = TInfo->getType();
10978  bool Dependent = ArgTy->isDependentType();
10979  SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange();
10980 
10981  // We must have at least one component that refers to the type, and the first
10982  // one is known to be a field designator. Verify that the ArgTy represents
10983  // a struct/union/class.
10984  if (!Dependent && !ArgTy->isRecordType())
10985  return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
10986  << ArgTy << TypeRange);
10987 
10988  // Type must be complete per C99 7.17p3 because a declaring a variable
10989  // with an incomplete type would be ill-formed.
10990  if (!Dependent
10991  && RequireCompleteType(BuiltinLoc, ArgTy,
10992  diag::err_offsetof_incomplete_type, TypeRange))
10993  return ExprError();
10994 
10995  // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
10996  // GCC extension, diagnose them.
10997  // FIXME: This diagnostic isn't actually visible because the location is in
10998  // a system header!
10999  if (NumComponents != 1)
11000  Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
11001  << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
11002 
11003  bool DidWarnAboutNonPOD = false;
11004  QualType CurrentType = ArgTy;
11005  typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
11007  SmallVector<Expr*, 4> Exprs;
11008  for (unsigned i = 0; i != NumComponents; ++i) {
11009  const OffsetOfComponent &OC = CompPtr[i];
11010  if (OC.isBrackets) {
11011  // Offset of an array sub-field. TODO: Should we allow vector elements?
11012  if (!CurrentType->isDependentType()) {
11013  const ArrayType *AT = Context.getAsArrayType(CurrentType);
11014  if(!AT)
11015  return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
11016  << CurrentType);
11017  CurrentType = AT->getElementType();
11018  } else
11019  CurrentType = Context.DependentTy;
11020 
11021  ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
11022  if (IdxRval.isInvalid())
11023  return ExprError();
11024  Expr *Idx = IdxRval.get();
11025 
11026  // The expression must be an integral expression.
11027  // FIXME: An integral constant expression?
11028  if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
11029  !Idx->getType()->isIntegerType())
11030  return ExprError(Diag(Idx->getLocStart(),
11031  diag::err_typecheck_subscript_not_integer)
11032  << Idx->getSourceRange());
11033 
11034  // Record this array index.
11035  Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
11036  Exprs.push_back(Idx);
11037  continue;
11038  }
11039 
11040  // Offset of a field.
11041  if (CurrentType->isDependentType()) {
11042  // We have the offset of a field, but we can't look into the dependent
11043  // type. Just record the identifier of the field.
11044  Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
11045  CurrentType = Context.DependentTy;
11046  continue;
11047  }
11048 
11049  // We need to have a complete type to look into.
11050  if (RequireCompleteType(OC.LocStart, CurrentType,
11051  diag::err_offsetof_incomplete_type))
11052  return ExprError();
11053 
11054  // Look for the designated field.
11055  const RecordType *RC = CurrentType->getAs<RecordType>();
11056  if (!RC)
11057  return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
11058  << CurrentType);
11059  RecordDecl *RD = RC->getDecl();
11060 
11061  // C++ [lib.support.types]p5:
11062  // The macro offsetof accepts a restricted set of type arguments in this
11063  // International Standard. type shall be a POD structure or a POD union
11064  // (clause 9).
11065  // C++11 [support.types]p4:
11066  // If type is not a standard-layout class (Clause 9), the results are
11067  // undefined.
11068  if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
11069  bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
11070  unsigned DiagID =
11071  LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
11072  : diag::ext_offsetof_non_pod_type;
11073 
11074  if (!IsSafe && !DidWarnAboutNonPOD &&
11075  DiagRuntimeBehavior(BuiltinLoc, nullptr,
11076  PDiag(DiagID)
11077  << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
11078  << CurrentType))
11079  DidWarnAboutNonPOD = true;
11080  }
11081 
11082  // Look for the field.
11083  LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName);
11084  LookupQualifiedName(R, RD);
11085  FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
11086  IndirectFieldDecl *IndirectMemberDecl = nullptr;
11087  if (!MemberDecl) {
11088  if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
11089  MemberDecl = IndirectMemberDecl->getAnonField();
11090  }
11091 
11092  if (!MemberDecl)
11093  return ExprError(Diag(BuiltinLoc, diag::err_no_member)
11094  << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
11095  OC.LocEnd));
11096 
11097  // C99 7.17p3:
11098  // (If the specified member is a bit-field, the behavior is undefined.)
11099  //
11100  // We diagnose this as an error.
11101  if (MemberDecl->isBitField()) {
11102  Diag(OC.LocEnd, diag::err_offsetof_bitfield)
11103  << MemberDecl->getDeclName()
11104  << SourceRange(BuiltinLoc, RParenLoc);
11105  Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
11106  return ExprError();
11107  }
11108 
11109  RecordDecl *Parent = MemberDecl->getParent();
11110  if (IndirectMemberDecl)
11111  Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
11112 
11113  // If the member was found in a base class, introduce OffsetOfNodes for
11114  // the base class indirections.
11115  CXXBasePaths Paths;
11116  if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) {
11117  if (Paths.getDetectedVirtual()) {
11118  Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
11119  << MemberDecl->getDeclName()
11120  << SourceRange(BuiltinLoc, RParenLoc);
11121  return ExprError();
11122  }
11123 
11124  CXXBasePath &Path = Paths.front();
11125  for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end();
11126  B != BEnd; ++B)
11127  Comps.push_back(OffsetOfNode(B->Base));
11128  }
11129 
11130  if (IndirectMemberDecl) {
11131  for (auto *FI : IndirectMemberDecl->chain()) {
11132  assert(isa<FieldDecl>(FI));
11133  Comps.push_back(OffsetOfNode(OC.LocStart,
11134  cast<FieldDecl>(FI), OC.LocEnd));
11135  }
11136  } else
11137  Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
11138 
11139  CurrentType = MemberDecl->getType().getNonReferenceType();
11140  }
11141 
11142  return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo,
11143  Comps, Exprs, RParenLoc);
11144 }
11145 
11147  SourceLocation BuiltinLoc,
11149  ParsedType ParsedArgTy,
11150  OffsetOfComponent *CompPtr,
11151  unsigned NumComponents,
11152  SourceLocation RParenLoc) {
11153 
11154  TypeSourceInfo *ArgTInfo;
11155  QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo);
11156  if (ArgTy.isNull())
11157  return ExprError();
11158 
11159  if (!ArgTInfo)
11160  ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc);
11161 
11162  return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents,
11163  RParenLoc);
11164 }
11165 
11166 
11168  Expr *CondExpr,
11169  Expr *LHSExpr, Expr *RHSExpr,
11170  SourceLocation RPLoc) {
11171  assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
11172 
11173  ExprValueKind VK = VK_RValue;
11175  QualType resType;
11176  bool ValueDependent = false;
11177  bool CondIsTrue = false;
11178  if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
11179  resType = Context.DependentTy;
11180  ValueDependent = true;
11181  } else {
11182  // The conditional expression is required to be a constant expression.
11183  llvm::APSInt condEval(32);
11184  ExprResult CondICE
11185  = VerifyIntegerConstantExpression(CondExpr, &condEval,
11186  diag::err_typecheck_choose_expr_requires_constant, false);
11187  if (CondICE.isInvalid())
11188  return ExprError();
11189  CondExpr = CondICE.get();
11190  CondIsTrue = condEval.getZExtValue();
11191 
11192  // If the condition is > zero, then the AST type is the same as the LSHExpr.
11193  Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
11194 
11195  resType = ActiveExpr->getType();
11196  ValueDependent = ActiveExpr->isValueDependent();
11197  VK = ActiveExpr->getValueKind();
11198  OK = ActiveExpr->getObjectKind();
11199  }
11200 
11201  return new (Context)
11202  ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, VK, OK, RPLoc,
11203  CondIsTrue, resType->isDependentType(), ValueDependent);
11204 }
11205 
11206 //===----------------------------------------------------------------------===//
11207 // Clang Extensions.
11208 //===----------------------------------------------------------------------===//
11209 
11210 /// ActOnBlockStart - This callback is invoked when a block literal is started.
11211 void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {
11212  BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc);
11213 
11214  if (LangOpts.CPlusPlus) {
11215  Decl *ManglingContextDecl;
11216  if (MangleNumberingContext *MCtx =
11217  getCurrentMangleNumberContext(Block->getDeclContext(),
11218  ManglingContextDecl)) {
11219  unsigned ManglingNumber = MCtx->getManglingNumber(Block);
11220  Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
11221  }
11222  }
11223 
11224  PushBlockScope(CurScope, Block);
11225  CurContext->addDecl(Block);
11226  if (CurScope)
11227  PushDeclContext(CurScope, Block);
11228  else
11229  CurContext = Block;
11230 
11231  getCurBlock()->HasImplicitReturnType = true;
11232 
11233  // Enter a new evaluation context to insulate the block from any
11234  // cleanups from the enclosing full-expression.
11235  PushExpressionEvaluationContext(PotentiallyEvaluated);
11236 }
11237 
11239  Scope *CurScope) {
11240  assert(ParamInfo.getIdentifier() == nullptr &&
11241  "block-id should have no identifier!");
11242  assert(ParamInfo.getContext() == Declarator::BlockLiteralContext);
11243  BlockScopeInfo *CurBlock = getCurBlock();
11244 
11245  TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope);
11246  QualType T = Sig->getType();
11247 
11248  // FIXME: We should allow unexpanded parameter packs here, but that would,
11249  // in turn, make the block expression contain unexpanded parameter packs.
11250  if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) {
11251  // Drop the parameters.
11253  EPI.HasTrailingReturn = false;
11257  }
11258 
11259  // GetTypeForDeclarator always produces a function type for a block
11260  // literal signature. Furthermore, it is always a FunctionProtoType
11261  // unless the function was written with a typedef.
11262  assert(T->isFunctionType() &&
11263  "GetTypeForDeclarator made a non-function block signature");
11264 
11265  // Look for an explicit signature in that function type.
11266  FunctionProtoTypeLoc ExplicitSignature;
11267 
11268  TypeLoc tmp = Sig->getTypeLoc().IgnoreParens();
11269  if ((ExplicitSignature = tmp.getAs<FunctionProtoTypeLoc>())) {
11270 
11271  // Check whether that explicit signature was synthesized by
11272  // GetTypeForDeclarator. If so, don't save that as part of the
11273  // written signature.
11274  if (ExplicitSignature.getLocalRangeBegin() ==
11275  ExplicitSignature.getLocalRangeEnd()) {
11276  // This would be much cheaper if we stored TypeLocs instead of
11277  // TypeSourceInfos.
11278  TypeLoc Result = ExplicitSignature.getReturnLoc();
11279  unsigned Size = Result.getFullDataSize();
11280  Sig = Context.CreateTypeSourceInfo(Result.getType(), Size);
11281  Sig->getTypeLoc().initializeFullCopy(Result, Size);
11282 
11283  ExplicitSignature = FunctionProtoTypeLoc();
11284  }
11285  }
11286 
11287  CurBlock->TheDecl->setSignatureAsWritten(Sig);
11288  CurBlock->FunctionType = T;
11289 
11290  const FunctionType *Fn = T->getAs<FunctionType>();
11291  QualType RetTy = Fn->getReturnType();
11292  bool isVariadic =
11293  (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
11294 
11295  CurBlock->TheDecl->setIsVariadic(isVariadic);
11296 
11297  // Context.DependentTy is used as a placeholder for a missing block
11298  // return type. TODO: what should we do with declarators like:
11299  // ^ * { ... }
11300  // If the answer is "apply template argument deduction"....
11301  if (RetTy != Context.DependentTy) {
11302  CurBlock->ReturnType = RetTy;
11303  CurBlock->TheDecl->setBlockMissingReturnType(false);
11304  CurBlock->HasImplicitReturnType = false;
11305  }
11306 
11307  // Push block parameters from the declarator if we had them.
11309  if (ExplicitSignature) {
11310  for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
11311  ParmVarDecl *Param = ExplicitSignature.getParam(I);
11312  if (Param->getIdentifier() == nullptr &&
11313  !Param->isImplicit() &&
11314  !Param->isInvalidDecl() &&
11315  !getLangOpts().CPlusPlus)
11316  Diag(Param->getLocation(), diag::err_parameter_name_omitted);
11317  Params.push_back(Param);
11318  }
11319 
11320  // Fake up parameter variables if we have a typedef, like
11321  // ^ fntype { ... }
11322  } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
11323  for (const auto &I : Fn->param_types()) {
11324  ParmVarDecl *Param = BuildParmVarDeclForTypedef(
11325  CurBlock->TheDecl, ParamInfo.getLocStart(), I);
11326  Params.push_back(Param);
11327  }
11328  }
11329 
11330  // Set the parameters on the block decl.
11331  if (!Params.empty()) {
11332  CurBlock->TheDecl->setParams(Params);
11333  CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(),
11334  CurBlock->TheDecl->param_end(),
11335  /*CheckParameterNames=*/false);
11336  }
11337 
11338  // Finally we can process decl attributes.
11339  ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
11340 
11341  // Put the parameter variables in scope.
11342  for (auto AI : CurBlock->TheDecl->params()) {
11343  AI->setOwningFunction(CurBlock->TheDecl);
11344 
11345  // If this has an identifier, add it to the scope stack.
11346  if (AI->getIdentifier()) {
11347  CheckShadow(CurBlock->TheScope, AI);
11348 
11349  PushOnScopeChains(AI, CurBlock->TheScope);
11350  }
11351  }
11352 }
11353 
11354 /// ActOnBlockError - If there is an error parsing a block, this callback
11355 /// is invoked to pop the information about the block from the action impl.
11356 void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
11357  // Leave the expression-evaluation context.
11358  DiscardCleanupsInEvaluationContext();
11359  PopExpressionEvaluationContext();
11360 
11361  // Pop off CurBlock, handle nested blocks.
11362  PopDeclContext();
11363  PopFunctionScopeInfo();
11364 }
11365 
11366 /// ActOnBlockStmtExpr - This is called when the body of a block statement
11367 /// literal was successfully completed. ^(int x){...}
11369  Stmt *Body, Scope *CurScope) {
11370  // If blocks are disabled, emit an error.
11371  if (!LangOpts.Blocks)
11372  Diag(CaretLoc, diag::err_blocks_disable);
11373 
11374  // Leave the expression-evaluation context.
11375  if (hasAnyUnrecoverableErrorsInThisFunction())
11376  DiscardCleanupsInEvaluationContext();
11377  assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!");
11378  PopExpressionEvaluationContext();
11379 
11380  BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
11381 
11382  if (BSI->HasImplicitReturnType)
11383  deduceClosureReturnType(*BSI);
11384 
11385  PopDeclContext();
11386 
11387  QualType RetTy = Context.VoidTy;
11388  if (!BSI->ReturnType.isNull())
11389  RetTy = BSI->ReturnType;
11390 
11391  bool NoReturn = BSI->TheDecl->hasAttr<NoReturnAttr>();
11392  QualType BlockTy;
11393 
11394  // Set the captured variables on the block.
11395  // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo!
11397  for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) {
11398  CapturingScopeInfo::Capture &Cap = BSI->Captures[i];
11399  if (Cap.isThisCapture())
11400  continue;
11401  BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(),
11402  Cap.isNested(), Cap.getInitExpr());
11403  Captures.push_back(NewCap);
11404  }
11405  BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(),
11406  BSI->CXXThisCaptureIndex != 0);
11407 
11408  // If the user wrote a function type in some form, try to use that.
11409  if (!BSI->FunctionType.isNull()) {
11410  const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>();
11411 
11412  FunctionType::ExtInfo Ext = FTy->getExtInfo();
11413  if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
11414 
11415  // Turn protoless block types into nullary block types.
11416  if (isa<FunctionNoProtoType>(FTy)) {
11418  EPI.ExtInfo = Ext;
11419  BlockTy = Context.getFunctionType(RetTy, None, EPI);
11420 
11421  // Otherwise, if we don't need to change anything about the function type,
11422  // preserve its sugar structure.
11423  } else if (FTy->getReturnType() == RetTy &&
11424  (!NoReturn || FTy->getNoReturnAttr())) {
11425  BlockTy = BSI->FunctionType;
11426 
11427  // Otherwise, make the minimal modifications to the function type.
11428  } else {
11429  const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
11431  EPI.TypeQuals = 0; // FIXME: silently?
11432  EPI.ExtInfo = Ext;
11433  BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI);
11434  }
11435 
11436  // If we don't have a function type, just build one from nothing.
11437  } else {
11439  EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
11440  BlockTy = Context.getFunctionType(RetTy, None, EPI);
11441  }
11442 
11443  DiagnoseUnusedParameters(BSI->TheDecl->param_begin(),
11444  BSI->TheDecl->param_end());
11445  BlockTy = Context.getBlockPointerType(BlockTy);
11446 
11447  // If needed, diagnose invalid gotos and switches in the block.
11448  if (getCurFunction()->NeedsScopeChecking() &&
11449  !PP.isCodeCompletionEnabled())
11450  DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
11451 
11452  BSI->TheDecl->setBody(cast<CompoundStmt>(Body));
11453 
11454  // Try to apply the named return value optimization. We have to check again
11455  // if we can do this, though, because blocks keep return statements around
11456  // to deduce an implicit return type.
11457  if (getLangOpts().CPlusPlus && RetTy->isRecordType() &&
11458  !BSI->TheDecl->isDependentContext())
11459  computeNRVO(Body, BSI);
11460 
11461  BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy);
11462  AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
11463  PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result);
11464 
11465  // If the block isn't obviously global, i.e. it captures anything at
11466  // all, then we need to do a few things in the surrounding context:
11467  if (Result->getBlockDecl()->hasCaptures()) {
11468  // First, this expression has a new cleanup object.
11469  ExprCleanupObjects.push_back(Result->getBlockDecl());
11470  ExprNeedsCleanups = true;
11471 
11472  // It also gets a branch-protected scope if any of the captured
11473  // variables needs destruction.
11474  for (const auto &CI : Result->getBlockDecl()->captures()) {
11475  const VarDecl *var = CI.getVariable();
11476  if (var->getType().isDestructedType() != QualType::DK_none) {
11477  getCurFunction()->setHasBranchProtectedScope();
11478  break;
11479  }
11480  }
11481  }
11482 
11483  return Result;
11484 }
11485 
11487  Expr *E, ParsedType Ty,
11488  SourceLocation RPLoc) {
11489  TypeSourceInfo *TInfo;
11490  GetTypeFromParser(Ty, &TInfo);
11491  return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
11492 }
11493 
11495  Expr *E, TypeSourceInfo *TInfo,
11496  SourceLocation RPLoc) {
11497  Expr *OrigExpr = E;
11498 
11499  // Get the va_list type
11500  QualType VaListType = Context.getBuiltinVaListType();
11501  if (VaListType->isArrayType()) {
11502  // Deal with implicit array decay; for example, on x86-64,
11503  // va_list is an array, but it's supposed to decay to
11504  // a pointer for va_arg.
11505  VaListType = Context.getArrayDecayedType(VaListType);
11506  // Make sure the input expression also decays appropriately.
11507  ExprResult Result = UsualUnaryConversions(E);
11508  if (Result.isInvalid())
11509  return ExprError();
11510  E = Result.get();
11511  } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) {
11512  // If va_list is a record type and we are compiling in C++ mode,
11513  // check the argument using reference binding.
11514  InitializedEntity Entity
11516  Context.getLValueReferenceType(VaListType), false);
11517  ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E);
11518  if (Init.isInvalid())
11519  return ExprError();
11520  E = Init.getAs<Expr>();
11521  } else {
11522  // Otherwise, the va_list argument must be an l-value because
11523  // it is modified by va_arg.
11524  if (!E->isTypeDependent() &&
11525  CheckForModifiableLvalue(E, BuiltinLoc, *this))
11526  return ExprError();
11527  }
11528 
11529  if (!E->isTypeDependent() &&
11530  !Context.hasSameType(VaListType, E->getType())) {
11531  return ExprError(Diag(E->getLocStart(),
11532  diag::err_first_argument_to_va_arg_not_of_type_va_list)
11533  << OrigExpr->getType() << E->getSourceRange());
11534  }
11535 
11536  if (!TInfo->getType()->isDependentType()) {
11537  if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
11538  diag::err_second_parameter_to_va_arg_incomplete,
11539  TInfo->getTypeLoc()))
11540  return ExprError();
11541 
11542  if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
11543  TInfo->getType(),
11544  diag::err_second_parameter_to_va_arg_abstract,
11545  TInfo->getTypeLoc()))
11546  return ExprError();
11547 
11548  if (!TInfo->getType().isPODType(Context)) {
11549  Diag(TInfo->getTypeLoc().getBeginLoc(),
11550  TInfo->getType()->isObjCLifetimeType()
11551  ? diag::warn_second_parameter_to_va_arg_ownership_qualified
11552  : diag::warn_second_parameter_to_va_arg_not_pod)
11553  << TInfo->getType()
11554  << TInfo->getTypeLoc().getSourceRange();
11555  }
11556 
11557  // Check for va_arg where arguments of the given type will be promoted
11558  // (i.e. this va_arg is guaranteed to have undefined behavior).
11559  QualType PromoteType;
11560  if (TInfo->getType()->isPromotableIntegerType()) {
11561  PromoteType = Context.getPromotedIntegerType(TInfo->getType());
11562  if (Context.typesAreCompatible(PromoteType, TInfo->getType()))
11563  PromoteType = QualType();
11564  }
11565  if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
11566  PromoteType = Context.DoubleTy;
11567  if (!PromoteType.isNull())
11568  DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
11569  PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
11570  << TInfo->getType()
11571  << PromoteType
11572  << TInfo->getTypeLoc().getSourceRange());
11573  }
11574 
11576  return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T);
11577 }
11578 
11580  // The type of __null will be int or long, depending on the size of
11581  // pointers on the target.
11582  QualType Ty;
11583  unsigned pw = Context.getTargetInfo().getPointerWidth(0);
11584  if (pw == Context.getTargetInfo().getIntWidth())
11585  Ty = Context.IntTy;
11586  else if (pw == Context.getTargetInfo().getLongWidth())
11587  Ty = Context.LongTy;
11588  else if (pw == Context.getTargetInfo().getLongLongWidth())
11589  Ty = Context.LongLongTy;
11590  else {
11591  llvm_unreachable("I don't know size of pointer!");
11592  }
11593 
11594  return new (Context) GNUNullExpr(Ty, TokenLoc);
11595 }
11596 
11597 bool
11599  if (!getLangOpts().ObjC1)
11600  return false;
11601 
11602  const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
11603  if (!PT)
11604  return false;
11605 
11606  if (!PT->isObjCIdType()) {
11607  // Check if the destination is the 'NSString' interface.
11608  const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();
11609  if (!ID || !ID->getIdentifier()->isStr("NSString"))
11610  return false;
11611  }
11612 
11613  // Ignore any parens, implicit casts (should only be
11614  // array-to-pointer decays), and not-so-opaque values. The last is
11615  // important for making this trigger for property assignments.
11616  Expr *SrcExpr = Exp->IgnoreParenImpCasts();
11617  if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr))
11618  if (OV->getSourceExpr())
11619  SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts();
11620 
11621  StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr);
11622  if (!SL || !SL->isAscii())
11623  return false;
11624  Diag(SL->getLocStart(), diag::err_missing_atsign_prefix)
11625  << FixItHint::CreateInsertion(SL->getLocStart(), "@");
11626  Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).get();
11627  return true;
11628 }
11629 
11631  SourceLocation Loc,
11632  QualType DstType, QualType SrcType,
11633  Expr *SrcExpr, AssignmentAction Action,
11634  bool *Complained) {
11635  if (Complained)
11636  *Complained = false;
11637 
11638  // Decode the result (notice that AST's are still created for extensions).
11639  bool CheckInferredResultType = false;
11640  bool isInvalid = false;
11641  unsigned DiagKind = 0;
11642  FixItHint Hint;
11643  ConversionFixItGenerator ConvHints;
11644  bool MayHaveConvFixit = false;
11645  bool MayHaveFunctionDiff = false;
11646  const ObjCInterfaceDecl *IFace = nullptr;
11647  const ObjCProtocolDecl *PDecl = nullptr;
11648 
11649  switch (ConvTy) {
11650  case Compatible:
11651  DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr);
11652  return false;
11653 
11654  case PointerToInt:
11655  DiagKind = diag::ext_typecheck_convert_pointer_int;
11656  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
11657  MayHaveConvFixit = true;
11658  break;
11659  case IntToPointer:
11660  DiagKind = diag::ext_typecheck_convert_int_pointer;
11661  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
11662  MayHaveConvFixit = true;
11663  break;
11664  case IncompatiblePointer:
11665  DiagKind =
11666  (Action == AA_Passing_CFAudited ?
11667  diag::err_arc_typecheck_convert_incompatible_pointer :
11668  diag::ext_typecheck_convert_incompatible_pointer);
11669  CheckInferredResultType = DstType->isObjCObjectPointerType() &&
11670  SrcType->isObjCObjectPointerType();
11671  if (Hint.isNull() && !CheckInferredResultType) {
11672  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
11673  }
11674  else if (CheckInferredResultType) {
11675  SrcType = SrcType.getUnqualifiedType();
11676  DstType = DstType.getUnqualifiedType();
11677  }
11678  MayHaveConvFixit = true;
11679  break;
11681  DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
11682  break;
11683  case FunctionVoidPointer:
11684  DiagKind = diag::ext_typecheck_convert_pointer_void_func;
11685  break;
11687  // Perform array-to-pointer decay if necessary.
11688  if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
11689 
11690  Qualifiers lhq = SrcType->getPointeeType().getQualifiers();
11691  Qualifiers rhq = DstType->getPointeeType().getQualifiers();
11692  if (lhq.getAddressSpace() != rhq.getAddressSpace()) {
11693  DiagKind = diag::err_typecheck_incompatible_address_space;
11694  break;
11695 
11696 
11697  } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) {
11698  DiagKind = diag::err_typecheck_incompatible_ownership;
11699  break;
11700  }
11701 
11702  llvm_unreachable("unknown error case for discarding qualifiers!");
11703  // fallthrough
11704  }
11706  // If the qualifiers lost were because we were applying the
11707  // (deprecated) C++ conversion from a string literal to a char*
11708  // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
11709  // Ideally, this check would be performed in
11710  // checkPointerTypesForAssignment. However, that would require a
11711  // bit of refactoring (so that the second argument is an
11712  // expression, rather than a type), which should be done as part
11713  // of a larger effort to fix checkPointerTypesForAssignment for
11714  // C++ semantics.
11715  if (getLangOpts().CPlusPlus &&
11717  return false;
11718  DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
11719  break;
11721  DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
11722  break;
11723  case IntToBlockPointer:
11724  DiagKind = diag::err_int_to_block_pointer;
11725  break;
11727  DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
11728  break;
11730  if (SrcType->isObjCQualifiedIdType()) {
11731  const ObjCObjectPointerType *srcOPT =
11732  SrcType->getAs<ObjCObjectPointerType>();
11733  for (auto *srcProto : srcOPT->quals()) {
11734  PDecl = srcProto;
11735  break;
11736  }
11737  if (const ObjCInterfaceType *IFaceT =
11739  IFace = IFaceT->getDecl();
11740  }
11741  else if (DstType->isObjCQualifiedIdType()) {
11742  const ObjCObjectPointerType *dstOPT =
11743  DstType->getAs<ObjCObjectPointerType>();
11744  for (auto *dstProto : dstOPT->quals()) {
11745  PDecl = dstProto;
11746  break;
11747  }
11748  if (const ObjCInterfaceType *IFaceT =
11750  IFace = IFaceT->getDecl();
11751  }
11752  DiagKind = diag::warn_incompatible_qualified_id;
11753  break;
11754  }
11755  case IncompatibleVectors:
11756  DiagKind = diag::warn_incompatible_vectors;
11757  break;
11759  DiagKind = diag::err_arc_weak_unavailable_assign;
11760  break;
11761  case Incompatible:
11762  DiagKind = diag::err_typecheck_convert_incompatible;
11763  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
11764  MayHaveConvFixit = true;
11765  isInvalid = true;
11766  MayHaveFunctionDiff = true;
11767  break;
11768  }
11769 
11770  QualType FirstType, SecondType;
11771  switch (Action) {
11772  case AA_Assigning:
11773  case AA_Initializing:
11774  // The destination type comes first.
11775  FirstType = DstType;
11776  SecondType = SrcType;
11777  break;
11778 
11779  case AA_Returning:
11780  case AA_Passing:
11781  case AA_Passing_CFAudited:
11782  case AA_Converting:
11783  case AA_Sending:
11784  case AA_Casting:
11785  // The source type comes first.
11786  FirstType = SrcType;
11787  SecondType = DstType;
11788  break;
11789  }
11790 
11791  PartialDiagnostic FDiag = PDiag(DiagKind);
11792  if (Action == AA_Passing_CFAudited)
11793  FDiag << FirstType << SecondType << AA_Passing << SrcExpr->getSourceRange();
11794  else
11795  FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange();
11796 
11797  // If we can fix the conversion, suggest the FixIts.
11798  assert(ConvHints.isNull() || Hint.isNull());
11799  if (!ConvHints.isNull()) {
11800  for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(),
11801  HE = ConvHints.Hints.end(); HI != HE; ++HI)
11802  FDiag << *HI;
11803  } else {
11804  FDiag << Hint;
11805  }
11806  if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
11807 
11808  if (MayHaveFunctionDiff)
11809  HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
11810 
11811  Diag(Loc, FDiag);
11812  if (DiagKind == diag::warn_incompatible_qualified_id &&
11813  PDecl && IFace && !IFace->hasDefinition())
11814  Diag(IFace->getLocation(), diag::not_incomplete_class_and_qualified_id)
11815  << IFace->getName() << PDecl->getName();
11816 
11817  if (SecondType == Context.OverloadTy)
11818  NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
11819  FirstType);
11820 
11821  if (CheckInferredResultType)
11822  EmitRelatedResultTypeNote(SrcExpr);
11823 
11824  if (Action == AA_Returning && ConvTy == IncompatiblePointer)
11826 
11827  if (Complained)
11828  *Complained = true;
11829  return isInvalid;
11830 }
11831 
11833  llvm::APSInt *Result) {
11834  class SimpleICEDiagnoser : public VerifyICEDiagnoser {
11835  public:
11836  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
11837  S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR;
11838  }
11839  } Diagnoser;
11840 
11841  return VerifyIntegerConstantExpression(E, Result, Diagnoser);
11842 }
11843 
11845  llvm::APSInt *Result,
11846  unsigned DiagID,
11847  bool AllowFold) {
11848  class IDDiagnoser : public VerifyICEDiagnoser {
11849  unsigned DiagID;
11850 
11851  public:
11852  IDDiagnoser(unsigned DiagID)
11853  : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }
11854 
11855  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
11856  S.Diag(Loc, DiagID) << SR;
11857  }
11858  } Diagnoser(DiagID);
11859 
11860  return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold);
11861 }
11862 
11864  SourceRange SR) {
11865  S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus;
11866 }
11867 
11868 ExprResult
11870  VerifyICEDiagnoser &Diagnoser,
11871  bool AllowFold) {
11872  SourceLocation DiagLoc = E->getLocStart();
11873 
11874  if (getLangOpts().CPlusPlus11) {
11875  // C++11 [expr.const]p5:
11876  // If an expression of literal class type is used in a context where an
11877  // integral constant expression is required, then that class type shall
11878  // have a single non-explicit conversion function to an integral or
11879  // unscoped enumeration type
11880  ExprResult Converted;
11881  class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
11882  public:
11883  CXX11ConvertDiagnoser(bool Silent)
11884  : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false,
11885  Silent, true) {}
11886 
11887  SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
11888  QualType T) override {
11889  return S.Diag(Loc, diag::err_ice_not_integral) << T;
11890  }
11891 
11892  SemaDiagnosticBuilder diagnoseIncomplete(
11893  Sema &S, SourceLocation Loc, QualType T) override {
11894  return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
11895  }
11896 
11897  SemaDiagnosticBuilder diagnoseExplicitConv(
11898  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
11899  return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
11900  }
11901 
11902  SemaDiagnosticBuilder noteExplicitConv(
11903  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
11904  return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
11905  << ConvTy->isEnumeralType() << ConvTy;
11906  }
11907 
11908  SemaDiagnosticBuilder diagnoseAmbiguous(
11909  Sema &S, SourceLocation Loc, QualType T) override {
11910  return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
11911  }
11912 
11913  SemaDiagnosticBuilder noteAmbiguous(
11914  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
11915  return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
11916  << ConvTy->isEnumeralType() << ConvTy;
11917  }
11918 
11919  SemaDiagnosticBuilder diagnoseConversion(
11920  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
11921  llvm_unreachable("conversion functions are permitted");
11922  }
11923  } ConvertDiagnoser(Diagnoser.Suppress);
11924 
11925  Converted = PerformContextualImplicitConversion(DiagLoc, E,
11926  ConvertDiagnoser);
11927  if (Converted.isInvalid())
11928  return Converted;
11929  E = Converted.get();
11931  return ExprError();
11932  } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
11933  // An ICE must be of integral or unscoped enumeration type.
11934  if (!Diagnoser.Suppress)
11935  Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
11936  return ExprError();
11937  }
11938 
11939  // Circumvent ICE checking in C++11 to avoid evaluating the expression twice
11940  // in the non-ICE case.
11942  if (Result)
11943  *Result = E->EvaluateKnownConstInt(Context);
11944  return E;
11945  }
11946 
11947  Expr::EvalResult EvalResult;
11949  EvalResult.Diag = &Notes;
11950 
11951  // Try to evaluate the expression, and produce diagnostics explaining why it's
11952  // not a constant expression as a side-effect.
11953  bool Folded = E->EvaluateAsRValue(EvalResult, Context) &&
11954  EvalResult.Val.isInt() && !EvalResult.HasSideEffects;
11955 
11956  // In C++11, we can rely on diagnostics being produced for any expression
11957  // which is not a constant expression. If no diagnostics were produced, then
11958  // this is a constant expression.
11959  if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
11960  if (Result)
11961  *Result = EvalResult.Val.getInt();
11962  return E;
11963  }
11964 
11965  // If our only note is the usual "invalid subexpression" note, just point
11966  // the caret at its location rather than producing an essentially
11967  // redundant note.
11968  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
11969  diag::note_invalid_subexpr_in_const_expr) {
11970  DiagLoc = Notes[0].first;
11971  Notes.clear();
11972  }
11973 
11974  if (!Folded || !AllowFold) {
11975  if (!Diagnoser.Suppress) {
11976  Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
11977  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
11978  Diag(Notes[I].first, Notes[I].second);
11979  }
11980 
11981  return ExprError();
11982  }
11983 
11984  Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange());
11985  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
11986  Diag(Notes[I].first, Notes[I].second);
11987 
11988  if (Result)
11989  *Result = EvalResult.Val.getInt();
11990  return E;
11991 }
11992 
11993 namespace {
11994  // Handle the case where we conclude a expression which we speculatively
11995  // considered to be unevaluated is actually evaluated.
11996  class TransformToPE : public TreeTransform<TransformToPE> {
11997  typedef TreeTransform<TransformToPE> BaseTransform;
11998 
11999  public:
12000  TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }
12001 
12002  // Make sure we redo semantic analysis
12003  bool AlwaysRebuild() { return true; }
12004 
12005  // Make sure we handle LabelStmts correctly.
12006  // FIXME: This does the right thing, but maybe we need a more general
12007  // fix to TreeTransform?
12008  StmtResult TransformLabelStmt(LabelStmt *S) {
12009  S->getDecl()->setStmt(nullptr);
12010  return BaseTransform::TransformLabelStmt(S);
12011  }
12012 
12013  // We need to special-case DeclRefExprs referring to FieldDecls which
12014  // are not part of a member pointer formation; normal TreeTransforming
12015  // doesn't catch this case because of the way we represent them in the AST.
12016  // FIXME: This is a bit ugly; is it really the best way to handle this
12017  // case?
12018  //
12019  // Error on DeclRefExprs referring to FieldDecls.
12020  ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
12021  if (isa<FieldDecl>(E->getDecl()) &&
12022  !SemaRef.isUnevaluatedContext())
12023  return SemaRef.Diag(E->getLocation(),
12024  diag::err_invalid_non_static_member_use)
12025  << E->getDecl() << E->getSourceRange();
12026 
12027  return BaseTransform::TransformDeclRefExpr(E);
12028  }
12029 
12030  // Exception: filter out member pointer formation
12031  ExprResult TransformUnaryOperator(UnaryOperator *E) {
12032  if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
12033  return E;
12034 
12035  return BaseTransform::TransformUnaryOperator(E);
12036  }
12037 
12038  ExprResult TransformLambdaExpr(LambdaExpr *E) {
12039  // Lambdas never need to be transformed.
12040  return E;
12041  }
12042  };
12043 }
12044 
12046  assert(isUnevaluatedContext() &&
12047  "Should only transform unevaluated expressions");
12048  ExprEvalContexts.back().Context =
12049  ExprEvalContexts[ExprEvalContexts.size()-2].Context;
12050  if (isUnevaluatedContext())
12051  return E;
12052  return TransformToPE(*this).TransformExpr(E);
12053 }
12054 
12055 void
12057  Decl *LambdaContextDecl,
12058  bool IsDecltype) {
12059  ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(),
12060  ExprNeedsCleanups, LambdaContextDecl,
12061  IsDecltype);
12062  ExprNeedsCleanups = false;
12063  if (!MaybeODRUseExprs.empty())
12064  std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
12065 }
12066 
12067 void
12070  bool IsDecltype) {
12071  Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
12072  PushExpressionEvaluationContext(NewContext, ClosureContextDecl, IsDecltype);
12073 }
12074 
12077  unsigned NumTypos = Rec.NumTypos;
12078 
12079  if (!Rec.Lambdas.empty()) {
12080  if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
12081  unsigned D;
12082  if (Rec.isUnevaluated()) {
12083  // C++11 [expr.prim.lambda]p2:
12084  // A lambda-expression shall not appear in an unevaluated operand
12085  // (Clause 5).
12086  D = diag::err_lambda_unevaluated_operand;
12087  } else {
12088  // C++1y [expr.const]p2:
12089  // A conditional-expression e is a core constant expression unless the
12090  // evaluation of e, following the rules of the abstract machine, would
12091  // evaluate [...] a lambda-expression.
12092  D = diag::err_lambda_in_constant_expression;
12093  }
12094  for (const auto *L : Rec.Lambdas)
12095  Diag(L->getLocStart(), D);
12096  } else {
12097  // Mark the capture expressions odr-used. This was deferred
12098  // during lambda expression creation.
12099  for (auto *Lambda : Rec.Lambdas) {
12100  for (auto *C : Lambda->capture_inits())
12102  }
12103  }
12104  }
12105 
12106  // When are coming out of an unevaluated context, clear out any
12107  // temporaries that we may have created as part of the evaluation of
12108  // the expression in that context: they aren't relevant because they
12109  // will never be constructed.
12110  if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
12112  ExprCleanupObjects.end());
12115  std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
12116  // Otherwise, merge the contexts together.
12117  } else {
12119  MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
12120  Rec.SavedMaybeODRUseExprs.end());
12121  }
12122 
12123  // Pop the current expression evaluation context off the stack.
12124  ExprEvalContexts.pop_back();
12125 
12126  if (!ExprEvalContexts.empty())
12127  ExprEvalContexts.back().NumTypos += NumTypos;
12128  else
12129  assert(NumTypos == 0 && "There are outstanding typos after popping the "
12130  "last ExpressionEvaluationContextRecord");
12131 }
12132 
12134  ExprCleanupObjects.erase(
12135  ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
12136  ExprCleanupObjects.end());
12137  ExprNeedsCleanups = false;
12138  MaybeODRUseExprs.clear();
12139 }
12140 
12142  if (!E->getType()->isVariablyModifiedType())
12143  return E;
12145 }
12146 
12147 static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) {
12148  // Do not mark anything as "used" within a dependent context; wait for
12149  // an instantiation.
12150  if (SemaRef.CurContext->isDependentContext())
12151  return false;
12152 
12153  switch (SemaRef.ExprEvalContexts.back().Context) {
12154  case Sema::Unevaluated:
12156  // We are in an expression that is not potentially evaluated; do nothing.
12157  // (Depending on how you read the standard, we actually do need to do
12158  // something here for null pointer constants, but the standard's
12159  // definition of a null pointer constant is completely crazy.)
12160  return false;
12161 
12164  // We are in a potentially evaluated expression (or a constant-expression
12165  // in C++03); we need to do implicit template instantiation, implicitly
12166  // define class members, and mark most declarations as used.
12167  return true;
12168 
12170  // Referenced declarations will only be used if the construct in the
12171  // containing expression is used.
12172  return false;
12173  }
12174  llvm_unreachable("Invalid context");
12175 }
12176 
12177 /// \brief Mark a function referenced, and check whether it is odr-used
12178 /// (C++ [basic.def.odr]p2, C99 6.9p3)
12180  bool OdrUse) {
12181  assert(Func && "No function?");
12182 
12183  Func->setReferenced();
12184 
12185  // C++11 [basic.def.odr]p3:
12186  // A function whose name appears as a potentially-evaluated expression is
12187  // odr-used if it is the unique lookup result or the selected member of a
12188  // set of overloaded functions [...].
12189  //
12190  // We (incorrectly) mark overload resolution as an unevaluated context, so we
12191  // can just check that here. Skip the rest of this function if we've already
12192  // marked the function as used.
12193  if (Func->isUsed(/*CheckUsedAttr=*/false) ||
12195  // C++11 [temp.inst]p3:
12196  // Unless a function template specialization has been explicitly
12197  // instantiated or explicitly specialized, the function template
12198  // specialization is implicitly instantiated when the specialization is
12199  // referenced in a context that requires a function definition to exist.
12200  //
12201  // We consider constexpr function templates to be referenced in a context
12202  // that requires a definition to exist whenever they are referenced.
12203  //
12204  // FIXME: This instantiates constexpr functions too frequently. If this is
12205  // really an unevaluated context (and we're not just in the definition of a
12206  // function template or overload resolution or other cases which we
12207  // incorrectly consider to be unevaluated contexts), and we're not in a
12208  // subexpression which we actually need to evaluate (for instance, a
12209  // template argument, array bound or an expression in a braced-init-list),
12210  // we are not permitted to instantiate this constexpr function definition.
12211  //
12212  // FIXME: This also implicitly defines special members too frequently. They
12213  // are only supposed to be implicitly defined if they are odr-used, but they
12214  // are not odr-used from constant expressions in unevaluated contexts.
12215  // However, they cannot be referenced if they are deleted, and they are
12216  // deleted whenever the implicit definition of the special member would
12217  // fail.
12218  if (!Func->isConstexpr() || Func->getBody())
12219  return;
12220  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
12221  if (!Func->isImplicitlyInstantiable() && (!MD || MD->isUserProvided()))
12222  return;
12223  }
12224 
12225  // Note that this declaration has been used.
12226  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
12227  Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
12228  if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
12229  if (Constructor->isDefaultConstructor()) {
12230  if (Constructor->isTrivial() && !Constructor->hasAttr<DLLExportAttr>())
12231  return;
12232  DefineImplicitDefaultConstructor(Loc, Constructor);
12233  } else if (Constructor->isCopyConstructor()) {
12234  DefineImplicitCopyConstructor(Loc, Constructor);
12235  } else if (Constructor->isMoveConstructor()) {
12236  DefineImplicitMoveConstructor(Loc, Constructor);
12237  }
12238  } else if (Constructor->getInheritedConstructor()) {
12239  DefineInheritingConstructor(Loc, Constructor);
12240  }
12241  } else if (CXXDestructorDecl *Destructor =
12242  dyn_cast<CXXDestructorDecl>(Func)) {
12243  Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
12244  if (Destructor->isDefaulted() && !Destructor->isDeleted()) {
12245  if (Destructor->isTrivial() && !Destructor->hasAttr<DLLExportAttr>())
12246  return;
12247  DefineImplicitDestructor(Loc, Destructor);
12248  }
12249  if (Destructor->isVirtual() && getLangOpts().AppleKext)
12250  MarkVTableUsed(Loc, Destructor->getParent());
12251  } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) {
12252  if (MethodDecl->isOverloadedOperator() &&
12253  MethodDecl->getOverloadedOperator() == OO_Equal) {
12254  MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
12255  if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
12256  if (MethodDecl->isCopyAssignmentOperator())
12257  DefineImplicitCopyAssignment(Loc, MethodDecl);
12258  else
12259  DefineImplicitMoveAssignment(Loc, MethodDecl);
12260  }
12261  } else if (isa<CXXConversionDecl>(MethodDecl) &&
12262  MethodDecl->getParent()->isLambda()) {
12263  CXXConversionDecl *Conversion =
12264  cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
12265  if (Conversion->isLambdaToBlockPointerConversion())
12267  else
12269  } else if (MethodDecl->isVirtual() && getLangOpts().AppleKext)
12270  MarkVTableUsed(Loc, MethodDecl->getParent());
12271  }
12272 
12273  // Recursive functions should be marked when used from another function.
12274  // FIXME: Is this really right?
12275  if (CurContext == Func) return;
12276 
12277  // Resolve the exception specification for any function which is
12278  // used: CodeGen will need it.
12279  const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>();
12281  ResolveExceptionSpec(Loc, FPT);
12282 
12283  if (!OdrUse) return;
12284 
12285  // Implicit instantiation of function templates and member functions of
12286  // class templates.
12287  if (Func->isImplicitlyInstantiable()) {
12288  bool AlreadyInstantiated = false;
12289  SourceLocation PointOfInstantiation = Loc;
12291  = Func->getTemplateSpecializationInfo()) {
12292  if (SpecInfo->getPointOfInstantiation().isInvalid())
12293  SpecInfo->setPointOfInstantiation(Loc);
12294  else if (SpecInfo->getTemplateSpecializationKind()
12296  AlreadyInstantiated = true;
12297  PointOfInstantiation = SpecInfo->getPointOfInstantiation();
12298  }
12299  } else if (MemberSpecializationInfo *MSInfo
12300  = Func->getMemberSpecializationInfo()) {
12301  if (MSInfo->getPointOfInstantiation().isInvalid())
12302  MSInfo->setPointOfInstantiation(Loc);
12303  else if (MSInfo->getTemplateSpecializationKind()
12305  AlreadyInstantiated = true;
12306  PointOfInstantiation = MSInfo->getPointOfInstantiation();
12307  }
12308  }
12309 
12310  if (!AlreadyInstantiated || Func->isConstexpr()) {
12311  if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
12312  cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
12315  std::make_pair(Func, PointOfInstantiation));
12316  else if (Func->isConstexpr())
12317  // Do not defer instantiations of constexpr functions, to avoid the
12318  // expression evaluator needing to call back into Sema if it sees a
12319  // call to such a function.
12320  InstantiateFunctionDefinition(PointOfInstantiation, Func);
12321  else {
12322  PendingInstantiations.push_back(std::make_pair(Func,
12323  PointOfInstantiation));
12324  // Notify the consumer that a function was implicitly instantiated.
12326  }
12327  }
12328  } else {
12329  // Walk redefinitions, as some of them may be instantiable.
12330  for (auto i : Func->redecls()) {
12331  if (!i->isUsed(false) && i->isImplicitlyInstantiable())
12332  MarkFunctionReferenced(Loc, i);
12333  }
12334  }
12335 
12336  // Keep track of used but undefined functions.
12337  if (!Func->isDefined()) {
12338  if (mightHaveNonExternalLinkage(Func))
12339  UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
12340  else if (Func->getMostRecentDecl()->isInlined() &&
12341  !LangOpts.GNUInline &&
12342  !Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
12343  UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
12344  }
12345 
12346  // Normally the most current decl is marked used while processing the use and
12347  // any subsequent decls are marked used by decl merging. This fails with
12348  // template instantiation since marking can happen at the end of the file
12349  // and, because of the two phase lookup, this function is called with at
12350  // decl in the middle of a decl chain. We loop to maintain the invariant
12351  // that once a decl is used, all decls after it are also used.
12352  for (FunctionDecl *F = Func->getMostRecentDecl();; F = F->getPreviousDecl()) {
12353  F->markUsed(Context);
12354  if (F == Func)
12355  break;
12356  }
12357 }
12358 
12359 static void
12361  VarDecl *var, DeclContext *DC) {
12362  DeclContext *VarDC = var->getDeclContext();
12363 
12364  // If the parameter still belongs to the translation unit, then
12365  // we're actually just using one parameter in the declaration of
12366  // the next.
12367  if (isa<ParmVarDecl>(var) &&
12368  isa<TranslationUnitDecl>(VarDC))
12369  return;
12370 
12371  // For C code, don't diagnose about capture if we're not actually in code
12372  // right now; it's impossible to write a non-constant expression outside of
12373  // function context, so we'll get other (more useful) diagnostics later.
12374  //
12375  // For C++, things get a bit more nasty... it would be nice to suppress this
12376  // diagnostic for certain cases like using a local variable in an array bound
12377  // for a member of a local class, but the correct predicate is not obvious.
12378  if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod())
12379  return;
12380 
12381  if (isa<CXXMethodDecl>(VarDC) &&
12382  cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) {
12383  S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_lambda)
12384  << var->getIdentifier();
12385  } else if (FunctionDecl *fn = dyn_cast<FunctionDecl>(VarDC)) {
12386  S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function)
12387  << var->getIdentifier() << fn->getDeclName();
12388  } else if (isa<BlockDecl>(VarDC)) {
12389  S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_block)
12390  << var->getIdentifier();
12391  } else {
12392  // FIXME: Is there any other context where a local variable can be
12393  // declared?
12394  S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_context)
12395  << var->getIdentifier();
12396  }
12397 
12398  S.Diag(var->getLocation(), diag::note_entity_declared_at)
12399  << var->getIdentifier();
12400 
12401  // FIXME: Add additional diagnostic info about class etc. which prevents
12402  // capture.
12403 }
12404 
12405 
12407  bool &SubCapturesAreNested,
12408  QualType &CaptureType,
12409  QualType &DeclRefType) {
12410  // Check whether we've already captured it.
12411  if (CSI->CaptureMap.count(Var)) {
12412  // If we found a capture, any subcaptures are nested.
12413  SubCapturesAreNested = true;
12414 
12415  // Retrieve the capture type for this variable.
12416  CaptureType = CSI->getCapture(Var).getCaptureType();
12417 
12418  // Compute the type of an expression that refers to this variable.
12419  DeclRefType = CaptureType.getNonReferenceType();
12420 
12421  const CapturingScopeInfo::Capture &Cap = CSI->getCapture(Var);
12422  if (Cap.isCopyCapture() &&
12423  !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable))
12424  DeclRefType.addConst();
12425  return true;
12426  }
12427  return false;
12428 }
12429 
12430 // Only block literals, captured statements, and lambda expressions can
12431 // capture; other scopes don't work.
12433  SourceLocation Loc,
12434  const bool Diagnose, Sema &S) {
12435  if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
12437  else if (Var->hasLocalStorage()) {
12438  if (Diagnose)
12439  diagnoseUncapturableValueReference(S, Loc, Var, DC);
12440  }
12441  return nullptr;
12442 }
12443 
12444 // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
12445 // certain types of variables (unnamed, variably modified types etc.)
12446 // so check for eligibility.
12448  SourceLocation Loc,
12449  const bool Diagnose, Sema &S) {
12450 
12451  bool IsBlock = isa<BlockScopeInfo>(CSI);
12452  bool IsLambda = isa<LambdaScopeInfo>(CSI);
12453 
12454  // Lambdas are not allowed to capture unnamed variables
12455  // (e.g. anonymous unions).
12456  // FIXME: The C++11 rule don't actually state this explicitly, but I'm
12457  // assuming that's the intent.
12458  if (IsLambda && !Var->getDeclName()) {
12459  if (Diagnose) {
12460  S.Diag(Loc, diag::err_lambda_capture_anonymous_var);
12461  S.Diag(Var->getLocation(), diag::note_declared_at);
12462  }
12463  return false;
12464  }
12465 
12466  // Prohibit variably-modified types in blocks; they're difficult to deal with.
12467  if (Var->getType()->isVariablyModifiedType() && IsBlock) {
12468  if (Diagnose) {
12469  S.Diag(Loc, diag::err_ref_vm_type);
12470  S.Diag(Var->getLocation(), diag::note_previous_decl)
12471  << Var->getDeclName();
12472  }
12473  return false;
12474  }
12475  // Prohibit structs with flexible array members too.
12476  // We cannot capture what is in the tail end of the struct.
12477  if (const RecordType *VTTy = Var->getType()->getAs<RecordType>()) {
12478  if (VTTy->getDecl()->hasFlexibleArrayMember()) {
12479  if (Diagnose) {
12480  if (IsBlock)
12481  S.Diag(Loc, diag::err_ref_flexarray_type);
12482  else
12483  S.Diag(Loc, diag::err_lambda_capture_flexarray_type)
12484  << Var->getDeclName();
12485  S.Diag(Var->getLocation(), diag::note_previous_decl)
12486  << Var->getDeclName();
12487  }
12488  return false;
12489  }
12490  }
12491  const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
12492  // Lambdas and captured statements are not allowed to capture __block
12493  // variables; they don't support the expected semantics.
12494  if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
12495  if (Diagnose) {
12496  S.Diag(Loc, diag::err_capture_block_variable)
12497  << Var->getDeclName() << !IsLambda;
12498  S.Diag(Var->getLocation(), diag::note_previous_decl)
12499  << Var->getDeclName();
12500  }
12501  return false;
12502  }
12503 
12504  return true;
12505 }
12506 
12507 // Returns true if the capture by block was successful.
12508 static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var,
12509  SourceLocation Loc,
12510  const bool BuildAndDiagnose,
12511  QualType &CaptureType,
12512  QualType &DeclRefType,
12513  const bool Nested,
12514  Sema &S) {
12515  Expr *CopyExpr = nullptr;
12516  bool ByRef = false;
12517 
12518  // Blocks are not allowed to capture arrays.
12519  if (CaptureType->isArrayType()) {
12520  if (BuildAndDiagnose) {
12521  S.Diag(Loc, diag::err_ref_array_type);
12522  S.Diag(Var->getLocation(), diag::note_previous_decl)
12523  << Var->getDeclName();
12524  }
12525  return false;
12526  }
12527 
12528  // Forbid the block-capture of autoreleasing variables.
12529  if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
12530  if (BuildAndDiagnose) {
12531  S.Diag(Loc, diag::err_arc_autoreleasing_capture)
12532  << /*block*/ 0;
12533  S.Diag(Var->getLocation(), diag::note_previous_decl)
12534  << Var->getDeclName();
12535  }
12536  return false;
12537  }
12538  const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
12539  if (HasBlocksAttr || CaptureType->isReferenceType()) {
12540  // Block capture by reference does not change the capture or
12541  // declaration reference types.
12542  ByRef = true;
12543  } else {
12544  // Block capture by copy introduces 'const'.
12545  CaptureType = CaptureType.getNonReferenceType().withConst();
12546  DeclRefType = CaptureType;
12547 
12548  if (S.getLangOpts().CPlusPlus && BuildAndDiagnose) {
12549  if (const RecordType *Record = DeclRefType->getAs<RecordType>()) {
12550  // The capture logic needs the destructor, so make sure we mark it.
12551  // Usually this is unnecessary because most local variables have
12552  // their destructors marked at declaration time, but parameters are
12553  // an exception because it's technically only the call site that
12554  // actually requires the destructor.
12555  if (isa<ParmVarDecl>(Var))
12556  S.FinalizeVarWithDestructor(Var, Record);
12557 
12558  // Enter a new evaluation context to insulate the copy
12559  // full-expression.
12561 
12562  // According to the blocks spec, the capture of a variable from
12563  // the stack requires a const copy constructor. This is not true
12564  // of the copy/move done to move a __block variable to the heap.
12565  Expr *DeclRef = new (S.Context) DeclRefExpr(Var, Nested,
12566  DeclRefType.withConst(),
12567  VK_LValue, Loc);
12568 
12572  CaptureType, false),
12573  Loc, DeclRef);
12574 
12575  // Build a full-expression copy expression if initialization
12576  // succeeded and used a non-trivial constructor. Recover from
12577  // errors by pretending that the copy isn't necessary.
12578  if (!Result.isInvalid() &&
12579  !cast<CXXConstructExpr>(Result.get())->getConstructor()
12580  ->isTrivial()) {
12581  Result = S.MaybeCreateExprWithCleanups(Result);
12582  CopyExpr = Result.get();
12583  }
12584  }
12585  }
12586  }
12587 
12588  // Actually capture the variable.
12589  if (BuildAndDiagnose)
12590  BSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc,
12591  SourceLocation(), CaptureType, CopyExpr);
12592 
12593  return true;
12594 
12595 }
12596 
12597 
12598 /// \brief Capture the given variable in the captured region.
12600  VarDecl *Var,
12601  SourceLocation Loc,
12602  const bool BuildAndDiagnose,
12603  QualType &CaptureType,
12604  QualType &DeclRefType,
12605  const bool RefersToCapturedVariable,
12606  Sema &S) {
12607 
12608  // By default, capture variables by reference.
12609  bool ByRef = true;
12610  // Using an LValue reference type is consistent with Lambdas (see below).
12611  if (S.getLangOpts().OpenMP && S.IsOpenMPCapturedVar(Var))
12612  DeclRefType = DeclRefType.getUnqualifiedType();
12613  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
12614  Expr *CopyExpr = nullptr;
12615  if (BuildAndDiagnose) {
12616  // The current implementation assumes that all variables are captured
12617  // by references. Since there is no capture by copy, no expression
12618  // evaluation will be needed.
12619  RecordDecl *RD = RSI->TheRecordDecl;
12620 
12621  FieldDecl *Field
12622  = FieldDecl::Create(S.Context, RD, Loc, Loc, nullptr, CaptureType,
12623  S.Context.getTrivialTypeSourceInfo(CaptureType, Loc),
12624  nullptr, false, ICIS_NoInit);
12625  Field->setImplicit(true);
12626  Field->setAccess(AS_private);
12627  RD->addDecl(Field);
12628 
12629  CopyExpr = new (S.Context) DeclRefExpr(Var, RefersToCapturedVariable,
12630  DeclRefType, VK_LValue, Loc);
12631  Var->setReferenced(true);
12632  Var->markUsed(S.Context);
12633  }
12634 
12635  // Actually capture the variable.
12636  if (BuildAndDiagnose)
12637  RSI->addCapture(Var, /*isBlock*/false, ByRef, RefersToCapturedVariable, Loc,
12638  SourceLocation(), CaptureType, CopyExpr);
12639 
12640 
12641  return true;
12642 }
12643 
12644 /// \brief Create a field within the lambda class for the variable
12645 /// being captured.
12647  QualType FieldType, QualType DeclRefType,
12648  SourceLocation Loc,
12649  bool RefersToCapturedVariable) {
12650  CXXRecordDecl *Lambda = LSI->Lambda;
12651 
12652  // Build the non-static data member.
12653  FieldDecl *Field
12654  = FieldDecl::Create(S.Context, Lambda, Loc, Loc, nullptr, FieldType,
12655  S.Context.getTrivialTypeSourceInfo(FieldType, Loc),
12656  nullptr, false, ICIS_NoInit);
12657  Field->setImplicit(true);
12658  Field->setAccess(AS_private);
12659  Lambda->addDecl(Field);
12660 }
12661 
12662 /// \brief Capture the given variable in the lambda.
12664  VarDecl *Var,
12665  SourceLocation Loc,
12666  const bool BuildAndDiagnose,
12667  QualType &CaptureType,
12668  QualType &DeclRefType,
12669  const bool RefersToCapturedVariable,
12670  const Sema::TryCaptureKind Kind,
12671  SourceLocation EllipsisLoc,
12672  const bool IsTopScope,
12673  Sema &S) {
12674 
12675  // Determine whether we are capturing by reference or by value.
12676  bool ByRef = false;
12677  if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
12678  ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
12679  } else {
12681  }
12682 
12683  // Compute the type of the field that will capture this variable.
12684  if (ByRef) {
12685  // C++11 [expr.prim.lambda]p15:
12686  // An entity is captured by reference if it is implicitly or
12687  // explicitly captured but not captured by copy. It is
12688  // unspecified whether additional unnamed non-static data
12689  // members are declared in the closure type for entities
12690  // captured by reference.
12691  //
12692  // FIXME: It is not clear whether we want to build an lvalue reference
12693  // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears
12694  // to do the former, while EDG does the latter. Core issue 1249 will
12695  // clarify, but for now we follow GCC because it's a more permissive and
12696  // easily defensible position.
12697  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
12698  } else {
12699  // C++11 [expr.prim.lambda]p14:
12700  // For each entity captured by copy, an unnamed non-static
12701  // data member is declared in the closure type. The
12702  // declaration order of these members is unspecified. The type
12703  // of such a data member is the type of the corresponding
12704  // captured entity if the entity is not a reference to an
12705  // object, or the referenced type otherwise. [Note: If the
12706  // captured entity is a reference to a function, the
12707  // corresponding data member is also a reference to a
12708  // function. - end note ]
12709  if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
12710  if (!RefType->getPointeeType()->isFunctionType())
12711  CaptureType = RefType->getPointeeType();
12712  }
12713 
12714  // Forbid the lambda copy-capture of autoreleasing variables.
12715  if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
12716  if (BuildAndDiagnose) {
12717  S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
12718  S.Diag(Var->getLocation(), diag::note_previous_decl)
12719  << Var->getDeclName();
12720  }
12721  return false;
12722  }
12723 
12724  // Make sure that by-copy captures are of a complete and non-abstract type.
12725  if (BuildAndDiagnose) {
12726  if (!CaptureType->isDependentType() &&
12727  S.RequireCompleteType(Loc, CaptureType,
12728  diag::err_capture_of_incomplete_type,
12729  Var->getDeclName()))
12730  return false;
12731 
12732  if (S.RequireNonAbstractType(Loc, CaptureType,
12733  diag::err_capture_of_abstract_type))
12734  return false;
12735  }
12736  }
12737 
12738  // Capture this variable in the lambda.
12739  if (BuildAndDiagnose)
12740  addAsFieldToClosureType(S, LSI, Var, CaptureType, DeclRefType, Loc,
12741  RefersToCapturedVariable);
12742 
12743  // Compute the type of a reference to this captured variable.
12744  if (ByRef)
12745  DeclRefType = CaptureType.getNonReferenceType();
12746  else {
12747  // C++ [expr.prim.lambda]p5:
12748  // The closure type for a lambda-expression has a public inline
12749  // function call operator [...]. This function call operator is
12750  // declared const (9.3.1) if and only if the lambda-expression’s
12751  // parameter-declaration-clause is not followed by mutable.
12752  DeclRefType = CaptureType.getNonReferenceType();
12753  if (!LSI->Mutable && !CaptureType->isReferenceType())
12754  DeclRefType.addConst();
12755  }
12756 
12757  // Add the capture.
12758  if (BuildAndDiagnose)
12759  LSI->addCapture(Var, /*IsBlock=*/false, ByRef, RefersToCapturedVariable,
12760  Loc, EllipsisLoc, CaptureType, /*CopyExpr=*/nullptr);
12761 
12762  return true;
12763 }
12764 
12766  VarDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
12767  SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType,
12768  QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt) {
12769  // An init-capture is notionally from the context surrounding its
12770  // declaration, but its parent DC is the lambda class.
12771  DeclContext *VarDC = Var->getDeclContext();
12772  if (Var->isInitCapture())
12773  VarDC = VarDC->getParent();
12774 
12775  DeclContext *DC = CurContext;
12776  const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
12777  ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
12778  // We need to sync up the Declaration Context with the
12779  // FunctionScopeIndexToStopAt
12780  if (FunctionScopeIndexToStopAt) {
12781  unsigned FSIndex = FunctionScopes.size() - 1;
12782  while (FSIndex != MaxFunctionScopesIndex) {
12784  --FSIndex;
12785  }
12786  }
12787 
12788 
12789  // If the variable is declared in the current context, there is no need to
12790  // capture it.
12791  if (VarDC == DC) return true;
12792 
12793  // Capture global variables if it is required to use private copy of this
12794  // variable.
12795  bool IsGlobal = !Var->hasLocalStorage();
12796  if (IsGlobal && !(LangOpts.OpenMP && IsOpenMPCapturedVar(Var)))
12797  return true;
12798 
12799  // Walk up the stack to determine whether we can capture the variable,
12800  // performing the "simple" checks that don't depend on type. We stop when
12801  // we've either hit the declared scope of the variable or find an existing
12802  // capture of that variable. We start from the innermost capturing-entity
12803  // (the DC) and ensure that all intervening capturing-entities
12804  // (blocks/lambdas etc.) between the innermost capturer and the variable`s
12805  // declcontext can either capture the variable or have already captured
12806  // the variable.
12807  CaptureType = Var->getType();
12808  DeclRefType = CaptureType.getNonReferenceType();
12809  bool Nested = false;
12810  bool Explicit = (Kind != TryCapture_Implicit);
12811  unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
12812  unsigned OpenMPLevel = 0;
12813  do {
12814  // Only block literals, captured statements, and lambda expressions can
12815  // capture; other scopes don't work.
12816  DeclContext *ParentDC = getParentOfCapturingContextOrNull(DC, Var,
12817  ExprLoc,
12818  BuildAndDiagnose,
12819  *this);
12820  // We need to check for the parent *first* because, if we *have*
12821  // private-captured a global variable, we need to recursively capture it in
12822  // intermediate blocks, lambdas, etc.
12823  if (!ParentDC) {
12824  if (IsGlobal) {
12825  FunctionScopesIndex = MaxFunctionScopesIndex - 1;
12826  break;
12827  }
12828  return true;
12829  }
12830 
12831  FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
12832  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
12833 
12834 
12835  // Check whether we've already captured it.
12836  if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType,
12837  DeclRefType))
12838  break;
12839  if (getLangOpts().OpenMP) {
12840  if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
12841  // OpenMP private variables should not be captured in outer scope, so
12842  // just break here.
12843  if (RSI->CapRegionKind == CR_OpenMP) {
12844  if (isOpenMPPrivateVar(Var, OpenMPLevel)) {
12845  Nested = true;
12846  DeclRefType = DeclRefType.getUnqualifiedType();
12847  CaptureType = Context.getLValueReferenceType(DeclRefType);
12848  break;
12849  }
12850  ++OpenMPLevel;
12851  }
12852  }
12853  }
12854  // If we are instantiating a generic lambda call operator body,
12855  // we do not want to capture new variables. What was captured
12856  // during either a lambdas transformation or initial parsing
12857  // should be used.
12859  if (BuildAndDiagnose) {
12860  LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
12862  Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
12863  Diag(Var->getLocation(), diag::note_previous_decl)
12864  << Var->getDeclName();
12865  Diag(LSI->Lambda->getLocStart(), diag::note_lambda_decl);
12866  } else
12867  diagnoseUncapturableValueReference(*this, ExprLoc, Var, DC);
12868  }
12869  return true;
12870  }
12871  // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
12872  // certain types of variables (unnamed, variably modified types etc.)
12873  // so check for eligibility.
12874  if (!isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this))
12875  return true;
12876 
12877  // Try to capture variable-length arrays types.
12878  if (Var->getType()->isVariablyModifiedType()) {
12879  // We're going to walk down into the type and look for VLA
12880  // expressions.
12881  QualType QTy = Var->getType();
12882  if (ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
12883  QTy = PVD->getOriginalType();
12884  do {
12885  const Type *Ty = QTy.getTypePtr();
12886  switch (Ty->getTypeClass()) {
12887 #define TYPE(Class, Base)
12888 #define ABSTRACT_TYPE(Class, Base)
12889 #define NON_CANONICAL_TYPE(Class, Base)
12890 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
12891 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
12892 #include "clang/AST/TypeNodes.def"
12893  QTy = QualType();
12894  break;
12895  // These types are never variably-modified.
12896  case Type::Builtin:
12897  case Type::Complex:
12898  case Type::Vector:
12899  case Type::ExtVector:
12900  case Type::Record:
12901  case Type::Enum:
12902  case Type::Elaborated:
12903  case Type::TemplateSpecialization:
12904  case Type::ObjCObject:
12905  case Type::ObjCInterface:
12906  case Type::ObjCObjectPointer:
12907  llvm_unreachable("type class is never variably-modified!");
12908  case Type::Adjusted:
12909  QTy = cast<AdjustedType>(Ty)->getOriginalType();
12910  break;
12911  case Type::Decayed:
12912  QTy = cast<DecayedType>(Ty)->getPointeeType();
12913  break;
12914  case Type::Pointer:
12915  QTy = cast<PointerType>(Ty)->getPointeeType();
12916  break;
12917  case Type::BlockPointer:
12918  QTy = cast<BlockPointerType>(Ty)->getPointeeType();
12919  break;
12920  case Type::LValueReference:
12921  case Type::RValueReference:
12922  QTy = cast<ReferenceType>(Ty)->getPointeeType();
12923  break;
12924  case Type::MemberPointer:
12925  QTy = cast<MemberPointerType>(Ty)->getPointeeType();
12926  break;
12927  case Type::ConstantArray:
12928  case Type::IncompleteArray:
12929  // Losing element qualification here is fine.
12930  QTy = cast<ArrayType>(Ty)->getElementType();
12931  break;
12932  case Type::VariableArray: {
12933  // Losing element qualification here is fine.
12934  const VariableArrayType *VAT = cast<VariableArrayType>(Ty);
12935 
12936  // Unknown size indication requires no size computation.
12937  // Otherwise, evaluate and record it.
12938  if (auto Size = VAT->getSizeExpr()) {
12939  if (!CSI->isVLATypeCaptured(VAT)) {
12940  RecordDecl *CapRecord = nullptr;
12941  if (auto LSI = dyn_cast<LambdaScopeInfo>(CSI)) {
12942  CapRecord = LSI->Lambda;
12943  } else if (auto CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
12944  CapRecord = CRSI->TheRecordDecl;
12945  }
12946  if (CapRecord) {
12947  auto ExprLoc = Size->getExprLoc();
12948  auto SizeType = Context.getSizeType();
12949  // Build the non-static data member.
12950  auto Field = FieldDecl::Create(
12951  Context, CapRecord, ExprLoc, ExprLoc,
12952  /*Id*/ nullptr, SizeType, /*TInfo*/ nullptr,
12953  /*BW*/ nullptr, /*Mutable*/ false,
12954  /*InitStyle*/ ICIS_NoInit);
12955  Field->setImplicit(true);
12956  Field->setAccess(AS_private);
12957  Field->setCapturedVLAType(VAT);
12958  CapRecord->addDecl(Field);
12959 
12960  CSI->addVLATypeCapture(ExprLoc, SizeType);
12961  }
12962  }
12963  }
12964  QTy = VAT->getElementType();
12965  break;
12966  }
12967  case Type::FunctionProto:
12968  case Type::FunctionNoProto:
12969  QTy = cast<FunctionType>(Ty)->getReturnType();
12970  break;
12971  case Type::Paren:
12972  case Type::TypeOf:
12973  case Type::UnaryTransform:
12974  case Type::Attributed:
12975  case Type::SubstTemplateTypeParm:
12976  case Type::PackExpansion:
12977  // Keep walking after single level desugaring.
12979  break;
12980  case Type::Typedef:
12981  QTy = cast<TypedefType>(Ty)->desugar();
12982  break;
12983  case Type::Decltype:
12984  QTy = cast<DecltypeType>(Ty)->desugar();
12985  break;
12986  case Type::Auto:
12987  QTy = cast<AutoType>(Ty)->getDeducedType();
12988  break;
12989  case Type::TypeOfExpr:
12990  QTy = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
12991  break;
12992  case Type::Atomic:
12993  QTy = cast<AtomicType>(Ty)->getValueType();
12994  break;
12995  }
12996  } while (!QTy.isNull() && QTy->isVariablyModifiedType());
12997  }
12998 
12999  if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
13000  // No capture-default, and this is not an explicit capture
13001  // so cannot capture this variable.
13002  if (BuildAndDiagnose) {
13003  Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
13004  Diag(Var->getLocation(), diag::note_previous_decl)
13005  << Var->getDeclName();
13006  Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getLocStart(),
13007  diag::note_lambda_decl);
13008  // FIXME: If we error out because an outer lambda can not implicitly
13009  // capture a variable that an inner lambda explicitly captures, we
13010  // should have the inner lambda do the explicit capture - because
13011  // it makes for cleaner diagnostics later. This would purely be done
13012  // so that the diagnostic does not misleadingly claim that a variable
13013  // can not be captured by a lambda implicitly even though it is captured
13014  // explicitly. Suggestion:
13015  // - create const bool VariableCaptureWasInitiallyExplicit = Explicit
13016  // at the function head
13017  // - cache the StartingDeclContext - this must be a lambda
13018  // - captureInLambda in the innermost lambda the variable.
13019  }
13020  return true;
13021  }
13022 
13023  FunctionScopesIndex--;
13024  DC = ParentDC;
13025  Explicit = false;
13026  } while (!VarDC->Equals(DC));
13027 
13028  // Walk back down the scope stack, (e.g. from outer lambda to inner lambda)
13029  // computing the type of the capture at each step, checking type-specific
13030  // requirements, and adding captures if requested.
13031  // If the variable had already been captured previously, we start capturing
13032  // at the lambda nested within that one.
13033  for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
13034  ++I) {
13035  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);
13036 
13037  if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
13038  if (!captureInBlock(BSI, Var, ExprLoc,
13039  BuildAndDiagnose, CaptureType,
13040  DeclRefType, Nested, *this))
13041  return true;
13042  Nested = true;
13043  } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
13044  if (!captureInCapturedRegion(RSI, Var, ExprLoc,
13045  BuildAndDiagnose, CaptureType,
13046  DeclRefType, Nested, *this))
13047  return true;
13048  Nested = true;
13049  } else {
13050  LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
13051  if (!captureInLambda(LSI, Var, ExprLoc,
13052  BuildAndDiagnose, CaptureType,
13053  DeclRefType, Nested, Kind, EllipsisLoc,
13054  /*IsTopScope*/I == N - 1, *this))
13055  return true;
13056  Nested = true;
13057  }
13058  }
13059  return false;
13060 }
13061 
13063  TryCaptureKind Kind, SourceLocation EllipsisLoc) {
13064  QualType CaptureType;
13065  QualType DeclRefType;
13066  return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
13067  /*BuildAndDiagnose=*/true, CaptureType,
13068  DeclRefType, nullptr);
13069 }
13070 
13072  QualType CaptureType;
13073  QualType DeclRefType;
13075  /*BuildAndDiagnose=*/false, CaptureType,
13076  DeclRefType, nullptr);
13077 }
13078 
13080  QualType CaptureType;
13081  QualType DeclRefType;
13082 
13083  // Determine whether we can capture this variable.
13085  /*BuildAndDiagnose=*/false, CaptureType,
13086  DeclRefType, nullptr))
13087  return QualType();
13088 
13089  return DeclRefType;
13090 }
13091 
13092 
13093 
13094 // If either the type of the variable or the initializer is dependent,
13095 // return false. Otherwise, determine whether the variable is a constant
13096 // expression. Use this if you need to know if a variable that might or
13097 // might not be dependent is truly a constant expression.
13099  ASTContext &Context) {
13100 
13101  if (Var->getType()->isDependentType())
13102  return false;
13103  const VarDecl *DefVD = nullptr;
13104  Var->getAnyInitializer(DefVD);
13105  if (!DefVD)
13106  return false;
13107  EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
13108  Expr *Init = cast<Expr>(Eval->Value);
13109  if (Init->isValueDependent())
13110  return false;
13111  return IsVariableAConstantExpression(Var, Context);
13112 }
13113 
13114 
13116  // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
13117  // an object that satisfies the requirements for appearing in a
13118  // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1)
13119  // is immediately applied." This function handles the lvalue-to-rvalue
13120  // conversion part.
13121  MaybeODRUseExprs.erase(E->IgnoreParens());
13122 
13123  // If we are in a lambda, check if this DeclRefExpr or MemberExpr refers
13124  // to a variable that is a constant expression, and if so, identify it as
13125  // a reference to a variable that does not involve an odr-use of that
13126  // variable.
13127  if (LambdaScopeInfo *LSI = getCurLambda()) {
13128  Expr *SansParensExpr = E->IgnoreParens();
13129  VarDecl *Var = nullptr;
13130  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SansParensExpr))
13131  Var = dyn_cast<VarDecl>(DRE->getFoundDecl());
13132  else if (MemberExpr *ME = dyn_cast<MemberExpr>(SansParensExpr))
13133  Var = dyn_cast<VarDecl>(ME->getMemberDecl());
13134 
13136  LSI->markVariableExprAsNonODRUsed(SansParensExpr);
13137  }
13138 }
13139 
13141  Res = CorrectDelayedTyposInExpr(Res);
13142 
13143  if (!Res.isUsable())
13144  return Res;
13145 
13146  // If a constant-expression is a reference to a variable where we delay
13147  // deciding whether it is an odr-use, just assume we will apply the
13148  // lvalue-to-rvalue conversion. In the one case where this doesn't happen
13149  // (a non-type template argument), we have special handling anyway.
13151  return Res;
13152 }
13153 
13155  for (llvm::SmallPtrSetIterator<Expr*> i = MaybeODRUseExprs.begin(),
13156  e = MaybeODRUseExprs.end();
13157  i != e; ++i) {
13158  VarDecl *Var;
13159  SourceLocation Loc;
13160  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(*i)) {
13161  Var = cast<VarDecl>(DRE->getDecl());
13162  Loc = DRE->getLocation();
13163  } else if (MemberExpr *ME = dyn_cast<MemberExpr>(*i)) {
13164  Var = cast<VarDecl>(ME->getMemberDecl());
13165  Loc = ME->getMemberLoc();
13166  } else {
13167  llvm_unreachable("Unexpected expression");
13168  }
13169 
13170  MarkVarDeclODRUsed(Var, Loc, *this,
13171  /*MaxFunctionScopeIndex Pointer*/ nullptr);
13172  }
13173 
13174  MaybeODRUseExprs.clear();
13175 }
13176 
13177 
13178 static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc,
13179  VarDecl *Var, Expr *E) {
13180  assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E)) &&
13181  "Invalid Expr argument to DoMarkVarDeclReferenced");
13182  Var->setReferenced();
13183 
13185  bool MarkODRUsed = true;
13186 
13187  // If the context is not potentially evaluated, this is not an odr-use and
13188  // does not trigger instantiation.
13189  if (!IsPotentiallyEvaluatedContext(SemaRef)) {
13190  if (SemaRef.isUnevaluatedContext())
13191  return;
13192 
13193  // If we don't yet know whether this context is going to end up being an
13194  // evaluated context, and we're referencing a variable from an enclosing
13195  // scope, add a potential capture.
13196  //
13197  // FIXME: Is this necessary? These contexts are only used for default
13198  // arguments, where local variables can't be used.
13199  const bool RefersToEnclosingScope =
13200  (SemaRef.CurContext != Var->getDeclContext() &&
13201  Var->getDeclContext()->isFunctionOrMethod() && Var->hasLocalStorage());
13202  if (RefersToEnclosingScope) {
13203  if (LambdaScopeInfo *const LSI = SemaRef.getCurLambda()) {
13204  // If a variable could potentially be odr-used, defer marking it so
13205  // until we finish analyzing the full expression for any
13206  // lvalue-to-rvalue
13207  // or discarded value conversions that would obviate odr-use.
13208  // Add it to the list of potential captures that will be analyzed
13209  // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
13210  // unless the variable is a reference that was initialized by a constant
13211  // expression (this will never need to be captured or odr-used).
13212  assert(E && "Capture variable should be used in an expression.");
13213  if (!Var->getType()->isReferenceType() ||
13215  LSI->addPotentialCapture(E->IgnoreParens());
13216  }
13217  }
13218 
13219  if (!isTemplateInstantiation(TSK))
13220  return;
13221 
13222  // Instantiate, but do not mark as odr-used, variable templates.
13223  MarkODRUsed = false;
13224  }
13225 
13227  dyn_cast<VarTemplateSpecializationDecl>(Var);
13228  assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
13229  "Can't instantiate a partial template specialization.");
13230 
13231  // Perform implicit instantiation of static data members, static data member
13232  // templates of class templates, and variable template specializations. Delay
13233  // instantiations of variable templates, except for those that could be used
13234  // in a constant expression.
13235  if (isTemplateInstantiation(TSK)) {
13236  bool TryInstantiating = TSK == TSK_ImplicitInstantiation;
13237 
13238  if (TryInstantiating && !isa<VarTemplateSpecializationDecl>(Var)) {
13239  if (Var->getPointOfInstantiation().isInvalid()) {
13240  // This is a modification of an existing AST node. Notify listeners.
13241  if (ASTMutationListener *L = SemaRef.getASTMutationListener())
13242  L->StaticDataMemberInstantiated(Var);
13243  } else if (!Var->isUsableInConstantExpressions(SemaRef.Context))
13244  // Don't bother trying to instantiate it again, unless we might need
13245  // its initializer before we get to the end of the TU.
13246  TryInstantiating = false;
13247  }
13248 
13249  if (Var->getPointOfInstantiation().isInvalid())
13250  Var->setTemplateSpecializationKind(TSK, Loc);
13251 
13252  if (TryInstantiating) {
13253  SourceLocation PointOfInstantiation = Var->getPointOfInstantiation();
13254  bool InstantiationDependent = false;
13255  bool IsNonDependent =
13257  VarSpec->getTemplateArgsInfo(), InstantiationDependent)
13258  : true;
13259 
13260  // Do not instantiate specializations that are still type-dependent.
13261  if (IsNonDependent) {
13262  if (Var->isUsableInConstantExpressions(SemaRef.Context)) {
13263  // Do not defer instantiations of variables which could be used in a
13264  // constant expression.
13265  SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
13266  } else {
13267  SemaRef.PendingInstantiations
13268  .push_back(std::make_pair(Var, PointOfInstantiation));
13269  }
13270  }
13271  }
13272  }
13273 
13274  if(!MarkODRUsed) return;
13275 
13276  // Per C++11 [basic.def.odr], a variable is odr-used "unless it satisfies
13277  // the requirements for appearing in a constant expression (5.19) and, if
13278  // it is an object, the lvalue-to-rvalue conversion (4.1)
13279  // is immediately applied." We check the first part here, and
13280  // Sema::UpdateMarkingForLValueToRValue deals with the second part.
13281  // Note that we use the C++11 definition everywhere because nothing in
13282  // C++03 depends on whether we get the C++03 version correct. The second
13283  // part does not apply to references, since they are not objects.
13284  if (E && IsVariableAConstantExpression(Var, SemaRef.Context)) {
13285  // A reference initialized by a constant expression can never be
13286  // odr-used, so simply ignore it.
13287  if (!Var->getType()->isReferenceType())
13288  SemaRef.MaybeODRUseExprs.insert(E);
13289  } else
13290  MarkVarDeclODRUsed(Var, Loc, SemaRef,
13291  /*MaxFunctionScopeIndex ptr*/ nullptr);
13292 }
13293 
13294 /// \brief Mark a variable referenced, and check whether it is odr-used
13295 /// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be
13296 /// used directly for normal expressions referring to VarDecl.
13298  DoMarkVarDeclReferenced(*this, Loc, Var, nullptr);
13299 }
13300 
13301 static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc,
13302  Decl *D, Expr *E, bool OdrUse) {
13303  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
13304  DoMarkVarDeclReferenced(SemaRef, Loc, Var, E);
13305  return;
13306  }
13307 
13308  SemaRef.MarkAnyDeclReferenced(Loc, D, OdrUse);
13309 
13310  // If this is a call to a method via a cast, also mark the method in the
13311  // derived class used in case codegen can devirtualize the call.
13312  const MemberExpr *ME = dyn_cast<MemberExpr>(E);
13313  if (!ME)
13314  return;
13315  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
13316  if (!MD)
13317  return;
13318  // Only attempt to devirtualize if this is truly a virtual call.
13319  bool IsVirtualCall = MD->isVirtual() && !ME->hasQualifier();
13320  if (!IsVirtualCall)
13321  return;
13322  const Expr *Base = ME->getBase();
13323  const CXXRecordDecl *MostDerivedClassDecl = Base->getBestDynamicClassType();
13324  if (!MostDerivedClassDecl)
13325  return;
13326  CXXMethodDecl *DM = MD->getCorrespondingMethodInClass(MostDerivedClassDecl);
13327  if (!DM || DM->isPure())
13328  return;
13329  SemaRef.MarkAnyDeclReferenced(Loc, DM, OdrUse);
13330 }
13331 
13332 /// \brief Perform reference-marking and odr-use handling for a DeclRefExpr.
13334  // TODO: update this with DR# once a defect report is filed.
13335  // C++11 defect. The address of a pure member should not be an ODR use, even
13336  // if it's a qualified reference.
13337  bool OdrUse = true;
13338  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
13339  if (Method->isVirtual())
13340  OdrUse = false;
13341  MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse);
13342 }
13343 
13344 /// \brief Perform reference-marking and odr-use handling for a MemberExpr.
13346  // C++11 [basic.def.odr]p2:
13347  // A non-overloaded function whose name appears as a potentially-evaluated
13348  // expression or a member of a set of candidate functions, if selected by
13349  // overload resolution when referred to from a potentially-evaluated
13350  // expression, is odr-used, unless it is a pure virtual function and its
13351  // name is not explicitly qualified.
13352  bool OdrUse = true;
13353  if (!E->hasQualifier()) {
13354  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getMemberDecl()))
13355  if (Method->isPure())
13356  OdrUse = false;
13357  }
13358  SourceLocation Loc = E->getMemberLoc().isValid() ?
13359  E->getMemberLoc() : E->getLocStart();
13360  MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, OdrUse);
13361 }
13362 
13363 /// \brief Perform marking for a reference to an arbitrary declaration. It
13364 /// marks the declaration referenced, and performs odr-use checking for
13365 /// functions and variables. This method should not be used when building a
13366 /// normal expression which refers to a variable.
13368  if (OdrUse) {
13369  if (auto *VD = dyn_cast<VarDecl>(D)) {
13370  MarkVariableReferenced(Loc, VD);
13371  return;
13372  }
13373  }
13374  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
13375  MarkFunctionReferenced(Loc, FD, OdrUse);
13376  return;
13377  }
13378  D->setReferenced();
13379 }
13380 
13381 namespace {
13382  // Mark all of the declarations referenced
13383  // FIXME: Not fully implemented yet! We need to have a better understanding
13384  // of when we're entering
13385  class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> {
13386  Sema &S;
13387  SourceLocation Loc;
13388 
13389  public:
13390  typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited;
13391 
13392  MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { }
13393 
13394  bool TraverseTemplateArgument(const TemplateArgument &Arg);
13395  bool TraverseRecordType(RecordType *T);
13396  };
13397 }
13398 
13399 bool MarkReferencedDecls::TraverseTemplateArgument(
13400  const TemplateArgument &Arg) {
13401  if (Arg.getKind() == TemplateArgument::Declaration) {
13402  if (Decl *D = Arg.getAsDecl())
13403  S.MarkAnyDeclReferenced(Loc, D, true);
13404  }
13405 
13406  return Inherited::TraverseTemplateArgument(Arg);
13407 }
13408 
13409 bool MarkReferencedDecls::TraverseRecordType(RecordType *T) {
13411  = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) {
13412  const TemplateArgumentList &Args = Spec->getTemplateArgs();
13413  return TraverseTemplateArguments(Args.data(), Args.size());
13414  }
13415 
13416  return true;
13417 }
13418 
13420  MarkReferencedDecls Marker(*this, Loc);
13421  Marker.TraverseType(Context.getCanonicalType(T));
13422 }
13423 
13424 namespace {
13425  /// \brief Helper class that marks all of the declarations referenced by
13426  /// potentially-evaluated subexpressions as "referenced".
13427  class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> {
13428  Sema &S;
13429  bool SkipLocalVariables;
13430 
13431  public:
13433 
13434  EvaluatedExprMarker(Sema &S, bool SkipLocalVariables)
13435  : Inherited(S.Context), S(S), SkipLocalVariables(SkipLocalVariables) { }
13436 
13437  void VisitDeclRefExpr(DeclRefExpr *E) {
13438  // If we were asked not to visit local variables, don't.
13439  if (SkipLocalVariables) {
13440  if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
13441  if (VD->hasLocalStorage())
13442  return;
13443  }
13444 
13445  S.MarkDeclRefReferenced(E);
13446  }
13447 
13448  void VisitMemberExpr(MemberExpr *E) {
13449  S.MarkMemberReferenced(E);
13450  Inherited::VisitMemberExpr(E);
13451  }
13452 
13453  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
13454  S.MarkFunctionReferenced(E->getLocStart(),
13455  const_cast<CXXDestructorDecl*>(E->getTemporary()->getDestructor()));
13456  Visit(E->getSubExpr());
13457  }
13458 
13459  void VisitCXXNewExpr(CXXNewExpr *E) {
13460  if (E->getOperatorNew())
13461  S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorNew());
13462  if (E->getOperatorDelete())
13463  S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete());
13464  Inherited::VisitCXXNewExpr(E);
13465  }
13466 
13467  void VisitCXXDeleteExpr(CXXDeleteExpr *E) {
13468  if (E->getOperatorDelete())
13469  S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete());
13470  QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType());
13471  if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
13472  CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
13473  S.MarkFunctionReferenced(E->getLocStart(),
13474  S.LookupDestructor(Record));
13475  }
13476 
13477  Inherited::VisitCXXDeleteExpr(E);
13478  }
13479 
13480  void VisitCXXConstructExpr(CXXConstructExpr *E) {
13481  S.MarkFunctionReferenced(E->getLocStart(), E->getConstructor());
13482  Inherited::VisitCXXConstructExpr(E);
13483  }
13484 
13485  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
13486  Visit(E->getExpr());
13487  }
13488 
13489  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
13490  Inherited::VisitImplicitCastExpr(E);
13491 
13492  if (E->getCastKind() == CK_LValueToRValue)
13493  S.UpdateMarkingForLValueToRValue(E->getSubExpr());
13494  }
13495  };
13496 }
13497 
13498 /// \brief Mark any declarations that appear within this expression or any
13499 /// potentially-evaluated subexpressions as "referenced".
13500 ///
13501 /// \param SkipLocalVariables If true, don't mark local variables as
13502 /// 'referenced'.
13504  bool SkipLocalVariables) {
13505  EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
13506 }
13507 
13508 /// \brief Emit a diagnostic that describes an effect on the run-time behavior
13509 /// of the program being compiled.
13510 ///
13511 /// This routine emits the given diagnostic when the code currently being
13512 /// type-checked is "potentially evaluated", meaning that there is a
13513 /// possibility that the code will actually be executable. Code in sizeof()
13514 /// expressions, code used only during overload resolution, etc., are not
13515 /// potentially evaluated. This routine will suppress such diagnostics or,
13516 /// in the absolutely nutty case of potentially potentially evaluated
13517 /// expressions (C++ typeid), queue the diagnostic to potentially emit it
13518 /// later.
13519 ///
13520 /// This routine should be used for all diagnostics that describe the run-time
13521 /// behavior of a program, such as passing a non-POD value through an ellipsis.
13522 /// Failure to do so will likely result in spurious diagnostics or failures
13523 /// during overload resolution or within sizeof/alignof/typeof/typeid.
13524 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
13525  const PartialDiagnostic &PD) {
13526  switch (ExprEvalContexts.back().Context) {
13527  case Unevaluated:
13528  case UnevaluatedAbstract:
13529  // The argument will never be evaluated, so don't complain.
13530  break;
13531 
13532  case ConstantEvaluated:
13533  // Relevant diagnostics should be produced by constant evaluation.
13534  break;
13535 
13536  case PotentiallyEvaluated:
13538  if (Statement && getCurFunctionOrMethodDecl()) {
13539  FunctionScopes.back()->PossiblyUnreachableDiags.
13540  push_back(sema::PossiblyUnreachableDiag(PD, Loc, Statement));
13541  }
13542  else
13543  Diag(Loc, PD);
13544 
13545  return true;
13546  }
13547 
13548  return false;
13549 }
13550 
13552  CallExpr *CE, FunctionDecl *FD) {
13553  if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
13554  return false;
13555 
13556  // If we're inside a decltype's expression, don't check for a valid return
13557  // type or construct temporaries until we know whether this is the last call.
13558  if (ExprEvalContexts.back().IsDecltype) {
13559  ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE);
13560  return false;
13561  }
13562 
13563  class CallReturnIncompleteDiagnoser : public TypeDiagnoser {
13564  FunctionDecl *FD;
13565  CallExpr *CE;
13566 
13567  public:
13568  CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
13569  : FD(FD), CE(CE) { }
13570 
13571  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
13572  if (!FD) {
13573  S.Diag(Loc, diag::err_call_incomplete_return)
13574  << T << CE->getSourceRange();
13575  return;
13576  }
13577 
13578  S.Diag(Loc, diag::err_call_function_incomplete_return)
13579  << CE->getSourceRange() << FD->getDeclName() << T;
13580  S.Diag(FD->getLocation(), diag::note_entity_declared_at)
13581  << FD->getDeclName();
13582  }
13583  } Diagnoser(FD, CE);
13584 
13585  if (RequireCompleteType(Loc, ReturnType, Diagnoser))
13586  return true;
13587 
13588  return false;
13589 }
13590 
13591 // Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
13592 // will prevent this condition from triggering, which is what we want.
13594  SourceLocation Loc;
13595 
13596  unsigned diagnostic = diag::warn_condition_is_assignment;
13597  bool IsOrAssign = false;
13598 
13599  if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
13600  if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
13601  return;
13602 
13603  IsOrAssign = Op->getOpcode() == BO_OrAssign;
13604 
13605  // Greylist some idioms by putting them into a warning subcategory.
13606  if (ObjCMessageExpr *ME
13607  = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
13608  Selector Sel = ME->getSelector();
13609 
13610  // self = [<foo> init...]
13611  if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)
13612  diagnostic = diag::warn_condition_is_idiomatic_assignment;
13613 
13614  // <foo> = [<bar> nextObject]
13615  else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject")
13616  diagnostic = diag::warn_condition_is_idiomatic_assignment;
13617  }
13618 
13619  Loc = Op->getOperatorLoc();
13620  } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
13621  if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
13622  return;
13623 
13624  IsOrAssign = Op->getOperator() == OO_PipeEqual;
13625  Loc = Op->getOperatorLoc();
13626  } else if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
13627  return DiagnoseAssignmentAsCondition(POE->getSyntacticForm());
13628  else {
13629  // Not an assignment.
13630  return;
13631  }
13632 
13633  Diag(Loc, diagnostic) << E->getSourceRange();
13634 
13635  SourceLocation Open = E->getLocStart();
13636  SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd());
13637  Diag(Loc, diag::note_condition_assign_silence)
13638  << FixItHint::CreateInsertion(Open, "(")
13639  << FixItHint::CreateInsertion(Close, ")");
13640 
13641  if (IsOrAssign)
13642  Diag(Loc, diag::note_condition_or_assign_to_comparison)
13643  << FixItHint::CreateReplacement(Loc, "!=");
13644  else
13645  Diag(Loc, diag::note_condition_assign_to_comparison)
13646  << FixItHint::CreateReplacement(Loc, "==");
13647 }
13648 
13649 /// \brief Redundant parentheses over an equality comparison can indicate
13650 /// that the user intended an assignment used as condition.
13652  // Don't warn if the parens came from a macro.
13653  SourceLocation parenLoc = ParenE->getLocStart();
13654  if (parenLoc.isInvalid() || parenLoc.isMacroID())
13655  return;
13656  // Don't warn for dependent expressions.
13657  if (ParenE->isTypeDependent())
13658  return;
13659 
13660  Expr *E = ParenE->IgnoreParens();
13661 
13662  if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
13663  if (opE->getOpcode() == BO_EQ &&
13664  opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
13665  == Expr::MLV_Valid) {
13666  SourceLocation Loc = opE->getOperatorLoc();
13667 
13668  Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
13669  SourceRange ParenERange = ParenE->getSourceRange();
13670  Diag(Loc, diag::note_equality_comparison_silence)
13671  << FixItHint::CreateRemoval(ParenERange.getBegin())
13672  << FixItHint::CreateRemoval(ParenERange.getEnd());
13673  Diag(Loc, diag::note_equality_comparison_to_assign)
13674  << FixItHint::CreateReplacement(Loc, "=");
13675  }
13676 }
13677 
13680  if (ParenExpr *parenE = dyn_cast<ParenExpr>(E))
13682 
13683  ExprResult result = CheckPlaceholderExpr(E);
13684  if (result.isInvalid()) return ExprError();
13685  E = result.get();
13686 
13687  if (!E->isTypeDependent()) {
13688  if (getLangOpts().CPlusPlus)
13689  return CheckCXXBooleanCondition(E); // C++ 6.4p4
13690 
13692  if (ERes.isInvalid())
13693  return ExprError();
13694  E = ERes.get();
13695 
13696  QualType T = E->getType();
13697  if (!T->isScalarType()) { // C99 6.8.4.1p1
13698  Diag(Loc, diag::err_typecheck_statement_requires_scalar)
13699  << T << E->getSourceRange();
13700  return ExprError();
13701  }
13702  CheckBoolLikeConversion(E, Loc);
13703  }
13704 
13705  return E;
13706 }
13707 
13709  Expr *SubExpr) {
13710  if (!SubExpr)
13711  return ExprError();
13712 
13713  return CheckBooleanCondition(SubExpr, Loc);
13714 }
13715 
13716 namespace {
13717  /// A visitor for rebuilding a call to an __unknown_any expression
13718  /// to have an appropriate type.
13719  struct RebuildUnknownAnyFunction
13720  : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
13721 
13722  Sema &S;
13723 
13724  RebuildUnknownAnyFunction(Sema &S) : S(S) {}
13725 
13726  ExprResult VisitStmt(Stmt *S) {
13727  llvm_unreachable("unexpected statement!");
13728  }
13729 
13730  ExprResult VisitExpr(Expr *E) {
13731  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
13732  << E->getSourceRange();
13733  return ExprError();
13734  }
13735 
13736  /// Rebuild an expression which simply semantically wraps another
13737  /// expression which it shares the type and value kind of.
13738  template <class T> ExprResult rebuildSugarExpr(T *E) {
13739  ExprResult SubResult = Visit(E->getSubExpr());
13740  if (SubResult.isInvalid()) return ExprError();
13741 
13742  Expr *SubExpr = SubResult.get();
13743  E->setSubExpr(SubExpr);
13744  E->setType(SubExpr->getType());
13745  E->setValueKind(SubExpr->getValueKind());
13746  assert(E->getObjectKind() == OK_Ordinary);
13747  return E;
13748  }
13749 
13750  ExprResult VisitParenExpr(ParenExpr *E) {
13751  return rebuildSugarExpr(E);
13752  }
13753 
13754  ExprResult VisitUnaryExtension(UnaryOperator *E) {
13755  return rebuildSugarExpr(E);
13756  }
13757 
13758  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
13759  ExprResult SubResult = Visit(E->getSubExpr());
13760  if (SubResult.isInvalid()) return ExprError();
13761 
13762  Expr *SubExpr = SubResult.get();
13763  E->setSubExpr(SubExpr);
13764  E->setType(S.Context.getPointerType(SubExpr->getType()));
13765  assert(E->getValueKind() == VK_RValue);
13766  assert(E->getObjectKind() == OK_Ordinary);
13767  return E;
13768  }
13769 
13770  ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
13771  if (!isa<FunctionDecl>(VD)) return VisitExpr(E);
13772 
13773  E->setType(VD->getType());
13774 
13775  assert(E->getValueKind() == VK_RValue);
13776  if (S.getLangOpts().CPlusPlus &&
13777  !(isa<CXXMethodDecl>(VD) &&
13778  cast<CXXMethodDecl>(VD)->isInstance()))
13779  E->setValueKind(VK_LValue);
13780 
13781  return E;
13782  }
13783 
13784  ExprResult VisitMemberExpr(MemberExpr *E) {
13785  return resolveDecl(E, E->getMemberDecl());
13786  }
13787 
13788  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
13789  return resolveDecl(E, E->getDecl());
13790  }
13791  };
13792 }
13793 
13794 /// Given a function expression of unknown-any type, try to rebuild it
13795 /// to have a function type.
13796 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
13797  ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
13798  if (Result.isInvalid()) return ExprError();
13799  return S.DefaultFunctionArrayConversion(Result.get());
13800 }
13801 
13802 namespace {
13803  /// A visitor for rebuilding an expression of type __unknown_anytype
13804  /// into one which resolves the type directly on the referring
13805  /// expression. Strict preservation of the original source
13806  /// structure is not a goal.
13807  struct RebuildUnknownAnyExpr
13808  : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
13809 
13810  Sema &S;
13811 
13812  /// The current destination type.
13813  QualType DestType;
13814 
13815  RebuildUnknownAnyExpr(Sema &S, QualType CastType)
13816  : S(S), DestType(CastType) {}
13817 
13818  ExprResult VisitStmt(Stmt *S) {
13819  llvm_unreachable("unexpected statement!");
13820  }
13821 
13822  ExprResult VisitExpr(Expr *E) {
13823  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
13824  << E->getSourceRange();
13825  return ExprError();
13826  }
13827 
13828  ExprResult VisitCallExpr(CallExpr *E);
13829  ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
13830 
13831  /// Rebuild an expression which simply semantically wraps another
13832  /// expression which it shares the type and value kind of.
13833  template <class T> ExprResult rebuildSugarExpr(T *E) {
13834  ExprResult SubResult = Visit(E->getSubExpr());
13835  if (SubResult.isInvalid()) return ExprError();
13836  Expr *SubExpr = SubResult.get();
13837  E->setSubExpr(SubExpr);
13838  E->setType(SubExpr->getType());
13839  E->setValueKind(SubExpr->getValueKind());
13840  assert(E->getObjectKind() == OK_Ordinary);
13841  return E;
13842  }
13843 
13844  ExprResult VisitParenExpr(ParenExpr *E) {
13845  return rebuildSugarExpr(E);
13846  }
13847 
13848  ExprResult VisitUnaryExtension(UnaryOperator *E) {
13849  return rebuildSugarExpr(E);
13850  }
13851 
13852  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
13853  const PointerType *Ptr = DestType->getAs<PointerType>();
13854  if (!Ptr) {
13855  S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
13856  << E->getSourceRange();
13857  return ExprError();
13858  }
13859  assert(E->getValueKind() == VK_RValue);
13860  assert(E->getObjectKind() == OK_Ordinary);
13861  E->setType(DestType);
13862 
13863  // Build the sub-expression as if it were an object of the pointee type.
13864  DestType = Ptr->getPointeeType();
13865  ExprResult SubResult = Visit(E->getSubExpr());
13866  if (SubResult.isInvalid()) return ExprError();
13867  E->setSubExpr(SubResult.get());
13868  return E;
13869  }
13870 
13871  ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
13872 
13873  ExprResult resolveDecl(Expr *E, ValueDecl *VD);
13874 
13875  ExprResult VisitMemberExpr(MemberExpr *E) {
13876  return resolveDecl(E, E->getMemberDecl());
13877  }
13878 
13879  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
13880  return resolveDecl(E, E->getDecl());
13881  }
13882  };
13883 }
13884 
13885 /// Rebuilds a call expression which yielded __unknown_anytype.
13886 ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
13887  Expr *CalleeExpr = E->getCallee();
13888 
13889  enum FnKind {
13890  FK_MemberFunction,
13891  FK_FunctionPointer,
13892  FK_BlockPointer
13893  };
13894 
13895  FnKind Kind;
13896  QualType CalleeType = CalleeExpr->getType();
13897  if (CalleeType == S.Context.BoundMemberTy) {
13898  assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
13899  Kind = FK_MemberFunction;
13900  CalleeType = Expr::findBoundMemberType(CalleeExpr);
13901  } else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) {
13902  CalleeType = Ptr->getPointeeType();
13903  Kind = FK_FunctionPointer;
13904  } else {
13905  CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType();
13906  Kind = FK_BlockPointer;
13907  }
13908  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
13909 
13910  // Verify that this is a legal result type of a function.
13911  if (DestType->isArrayType() || DestType->isFunctionType()) {
13912  unsigned diagID = diag::err_func_returning_array_function;
13913  if (Kind == FK_BlockPointer)
13914  diagID = diag::err_block_returning_array_function;
13915 
13916  S.Diag(E->getExprLoc(), diagID)
13917  << DestType->isFunctionType() << DestType;
13918  return ExprError();
13919  }
13920 
13921  // Otherwise, go ahead and set DestType as the call's result.
13922  E->setType(DestType.getNonLValueExprType(S.Context));
13924  assert(E->getObjectKind() == OK_Ordinary);
13925 
13926  // Rebuild the function type, replacing the result type with DestType.
13927  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType);
13928  if (Proto) {
13929  // __unknown_anytype(...) is a special case used by the debugger when
13930  // it has no idea what a function's signature is.
13931  //
13932  // We want to build this call essentially under the K&R
13933  // unprototyped rules, but making a FunctionNoProtoType in C++
13934  // would foul up all sorts of assumptions. However, we cannot
13935  // simply pass all arguments as variadic arguments, nor can we
13936  // portably just call the function under a non-variadic type; see
13937  // the comment on IR-gen's TargetInfo::isNoProtoCallVariadic.
13938  // However, it turns out that in practice it is generally safe to
13939  // call a function declared as "A foo(B,C,D);" under the prototype
13940  // "A foo(B,C,D,...);". The only known exception is with the
13941  // Windows ABI, where any variadic function is implicitly cdecl
13942  // regardless of its normal CC. Therefore we change the parameter
13943  // types to match the types of the arguments.
13944  //
13945  // This is a hack, but it is far superior to moving the
13946  // corresponding target-specific code from IR-gen to Sema/AST.
13947 
13948  ArrayRef<QualType> ParamTypes = Proto->getParamTypes();
13949  SmallVector<QualType, 8> ArgTypes;
13950  if (ParamTypes.empty() && Proto->isVariadic()) { // the special case
13951  ArgTypes.reserve(E->getNumArgs());
13952  for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
13953  Expr *Arg = E->getArg(i);
13954  QualType ArgType = Arg->getType();
13955  if (E->isLValue()) {
13956  ArgType = S.Context.getLValueReferenceType(ArgType);
13957  } else if (E->isXValue()) {
13958  ArgType = S.Context.getRValueReferenceType(ArgType);
13959  }
13960  ArgTypes.push_back(ArgType);
13961  }
13962  ParamTypes = ArgTypes;
13963  }
13964  DestType = S.Context.getFunctionType(DestType, ParamTypes,
13965  Proto->getExtProtoInfo());
13966  } else {
13967  DestType = S.Context.getFunctionNoProtoType(DestType,
13968  FnType->getExtInfo());
13969  }
13970 
13971  // Rebuild the appropriate pointer-to-function type.
13972  switch (Kind) {
13973  case FK_MemberFunction:
13974  // Nothing to do.
13975  break;
13976 
13977  case FK_FunctionPointer:
13978  DestType = S.Context.getPointerType(DestType);
13979  break;
13980 
13981  case FK_BlockPointer:
13982  DestType = S.Context.getBlockPointerType(DestType);
13983  break;
13984  }
13985 
13986  // Finally, we can recurse.
13987  ExprResult CalleeResult = Visit(CalleeExpr);
13988  if (!CalleeResult.isUsable()) return ExprError();
13989  E->setCallee(CalleeResult.get());
13990 
13991  // Bind a temporary if necessary.
13992  return S.MaybeBindToTemporary(E);
13993 }
13994 
13995 ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
13996  // Verify that this is a legal result type of a call.
13997  if (DestType->isArrayType() || DestType->isFunctionType()) {
13998  S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
13999  << DestType->isFunctionType() << DestType;
14000  return ExprError();
14001  }
14002 
14003  // Rewrite the method result type if available.
14004  if (ObjCMethodDecl *Method = E->getMethodDecl()) {
14005  assert(Method->getReturnType() == S.Context.UnknownAnyTy);
14006  Method->setReturnType(DestType);
14007  }
14008 
14009  // Change the type of the message.
14010  E->setType(DestType.getNonReferenceType());
14012 
14013  return S.MaybeBindToTemporary(E);
14014 }
14015 
14016 ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
14017  // The only case we should ever see here is a function-to-pointer decay.
14018  if (E->getCastKind() == CK_FunctionToPointerDecay) {
14019  assert(E->getValueKind() == VK_RValue);
14020  assert(E->getObjectKind() == OK_Ordinary);
14021 
14022  E->setType(DestType);
14023 
14024  // Rebuild the sub-expression as the pointee (function) type.
14025  DestType = DestType->castAs<PointerType>()->getPointeeType();
14026 
14027  ExprResult Result = Visit(E->getSubExpr());
14028  if (!Result.isUsable()) return ExprError();
14029 
14030  E->setSubExpr(Result.get());
14031  return E;
14032  } else if (E->getCastKind() == CK_LValueToRValue) {
14033  assert(E->getValueKind() == VK_RValue);
14034  assert(E->getObjectKind() == OK_Ordinary);
14035 
14036  assert(isa<BlockPointerType>(E->getType()));
14037 
14038  E->setType(DestType);
14039 
14040  // The sub-expression has to be a lvalue reference, so rebuild it as such.
14041  DestType = S.Context.getLValueReferenceType(DestType);
14042 
14043  ExprResult Result = Visit(E->getSubExpr());
14044  if (!Result.isUsable()) return ExprError();
14045 
14046  E->setSubExpr(Result.get());
14047  return E;
14048  } else {
14049  llvm_unreachable("Unhandled cast type!");
14050  }
14051 }
14052 
14053 ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
14054  ExprValueKind ValueKind = VK_LValue;
14055  QualType Type = DestType;
14056 
14057  // We know how to make this work for certain kinds of decls:
14058 
14059  // - functions
14060  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {
14061  if (const PointerType *Ptr = Type->getAs<PointerType>()) {
14062  DestType = Ptr->getPointeeType();
14063  ExprResult Result = resolveDecl(E, VD);
14064  if (Result.isInvalid()) return ExprError();
14065  return S.ImpCastExprToType(Result.get(), Type,
14067  }
14068 
14069  if (!Type->isFunctionType()) {
14070  S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
14071  << VD << E->getSourceRange();
14072  return ExprError();
14073  }
14074  if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
14075  // We must match the FunctionDecl's type to the hack introduced in
14076  // RebuildUnknownAnyExpr::VisitCallExpr to vararg functions of unknown
14077  // type. See the lengthy commentary in that routine.
14078  QualType FDT = FD->getType();
14079  const FunctionType *FnType = FDT->castAs<FunctionType>();
14080  const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
14081  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
14082  if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
14083  SourceLocation Loc = FD->getLocation();
14084  FunctionDecl *NewFD = FunctionDecl::Create(FD->getASTContext(),
14085  FD->getDeclContext(),
14086  Loc, Loc, FD->getNameInfo().getName(),
14087  DestType, FD->getTypeSourceInfo(),
14088  SC_None, false/*isInlineSpecified*/,
14089  FD->hasPrototype(),
14090  false/*isConstexprSpecified*/);
14091 
14092  if (FD->getQualifier())
14093  NewFD->setQualifierInfo(FD->getQualifierLoc());
14094 
14096  for (const auto &AI : FT->param_types()) {
14097  ParmVarDecl *Param =
14098  S.BuildParmVarDeclForTypedef(FD, Loc, AI);
14099  Param->setScopeInfo(0, Params.size());
14100  Params.push_back(Param);
14101  }
14102  NewFD->setParams(Params);
14103  DRE->setDecl(NewFD);
14104  VD = DRE->getDecl();
14105  }
14106  }
14107 
14108  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
14109  if (MD->isInstance()) {
14110  ValueKind = VK_RValue;
14111  Type = S.Context.BoundMemberTy;
14112  }
14113 
14114  // Function references aren't l-values in C.
14115  if (!S.getLangOpts().CPlusPlus)
14116  ValueKind = VK_RValue;
14117 
14118  // - variables
14119  } else if (isa<VarDecl>(VD)) {
14120  if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
14121  Type = RefTy->getPointeeType();
14122  } else if (Type->isFunctionType()) {
14123  S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
14124  << VD << E->getSourceRange();
14125  return ExprError();
14126  }
14127 
14128  // - nothing else
14129  } else {
14130  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
14131  << VD << E->getSourceRange();
14132  return ExprError();
14133  }
14134 
14135  // Modifying the declaration like this is friendly to IR-gen but
14136  // also really dangerous.
14137  VD->setType(DestType);
14138  E->setType(Type);
14139  E->setValueKind(ValueKind);
14140  return E;
14141 }
14142 
14143 /// Check a cast of an unknown-any type. We intentionally only
14144 /// trigger this for C-style casts.
14147  ExprValueKind &VK, CXXCastPath &Path) {
14148  // Rewrite the casted expression from scratch.
14149  ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
14150  if (!result.isUsable()) return ExprError();
14151 
14152  CastExpr = result.get();
14153  VK = CastExpr->getValueKind();
14154  CastKind = CK_NoOp;
14155 
14156  return CastExpr;
14157 }
14158 
14160  return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
14161 }
14162 
14164  Expr *arg, QualType &paramType) {
14165  // If the syntactic form of the argument is not an explicit cast of
14166  // any sort, just do default argument promotion.
14167  ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
14168  if (!castArg) {
14169  ExprResult result = DefaultArgumentPromotion(arg);
14170  if (result.isInvalid()) return ExprError();
14171  paramType = result.get()->getType();
14172  return result;
14173  }
14174 
14175  // Otherwise, use the type that was written in the explicit cast.
14176  assert(!arg->hasPlaceholderType());
14177  paramType = castArg->getTypeAsWritten();
14178 
14179  // Copy-initialize a parameter of that type.
14180  InitializedEntity entity =
14182  /*consumed*/ false);
14183  return PerformCopyInitialization(entity, callLoc, arg);
14184 }
14185 
14187  Expr *orig = E;
14188  unsigned diagID = diag::err_uncasted_use_of_unknown_any;
14189  while (true) {
14190  E = E->IgnoreParenImpCasts();
14191  if (CallExpr *call = dyn_cast<CallExpr>(E)) {
14192  E = call->getCallee();
14193  diagID = diag::err_uncasted_call_of_unknown_any;
14194  } else {
14195  break;
14196  }
14197  }
14198 
14199  SourceLocation loc;
14200  NamedDecl *d;
14201  if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
14202  loc = ref->getLocation();
14203  d = ref->getDecl();
14204  } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
14205  loc = mem->getMemberLoc();
14206  d = mem->getMemberDecl();
14207  } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {
14208  diagID = diag::err_uncasted_call_of_unknown_any;
14209  loc = msg->getSelectorStartLoc();
14210  d = msg->getMethodDecl();
14211  if (!d) {
14212  S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
14213  << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
14214  << orig->getSourceRange();
14215  return ExprError();
14216  }
14217  } else {
14218  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
14219  << E->getSourceRange();
14220  return ExprError();
14221  }
14222 
14223  S.Diag(loc, diagID) << d << orig->getSourceRange();
14224 
14225  // Never recoverable.
14226  return ExprError();
14227 }
14228 
14229 /// Check for operands with placeholder types and complain if found.
14230 /// Returns true if there was an error and no recovery was possible.
14232  if (!getLangOpts().CPlusPlus) {
14233  // C cannot handle TypoExpr nodes on either side of a binop because it
14234  // doesn't handle dependent types properly, so make sure any TypoExprs have
14235  // been dealt with before checking the operands.
14237  if (!Result.isUsable()) return ExprError();
14238  E = Result.get();
14239  }
14240 
14241  const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
14242  if (!placeholderType) return E;
14243 
14244  switch (placeholderType->getKind()) {
14245 
14246  // Overloaded expressions.
14247  case BuiltinType::Overload: {
14248  // Try to resolve a single function template specialization.
14249  // This is obligatory.
14250  ExprResult result = E;
14252  return result;
14253 
14254  // If that failed, try to recover with a call.
14255  } else {
14256  tryToRecoverWithCall(result, PDiag(diag::err_ovl_unresolvable),
14257  /*complain*/ true);
14258  return result;
14259  }
14260  }
14261 
14262  // Bound member functions.
14263  case BuiltinType::BoundMember: {
14264  ExprResult result = E;
14265  const Expr *BME = E->IgnoreParens();
14266  PartialDiagnostic PD = PDiag(diag::err_bound_member_function);
14267  // Try to give a nicer diagnostic if it is a bound member that we recognize.
14268  if (isa<CXXPseudoDestructorExpr>(BME)) {
14269  PD = PDiag(diag::err_dtor_expr_without_call) << /*pseudo-destructor*/ 1;
14270  } else if (const auto *ME = dyn_cast<MemberExpr>(BME)) {
14271  if (ME->getMemberNameInfo().getName().getNameKind() ==
14273  PD = PDiag(diag::err_dtor_expr_without_call) << /*destructor*/ 0;
14274  }
14275  tryToRecoverWithCall(result, PD,
14276  /*complain*/ true);
14277  return result;
14278  }
14279 
14280  // ARC unbridged casts.
14281  case BuiltinType::ARCUnbridgedCast: {
14282  Expr *realCast = stripARCUnbridgedCast(E);
14283  diagnoseARCUnbridgedCast(realCast);
14284  return realCast;
14285  }
14286 
14287  // Expressions of unknown type.
14288  case BuiltinType::UnknownAny:
14289  return diagnoseUnknownAnyExpr(*this, E);
14290 
14291  // Pseudo-objects.
14292  case BuiltinType::PseudoObject:
14293  return checkPseudoObjectRValue(E);
14294 
14295  case BuiltinType::BuiltinFn: {
14296  // Accept __noop without parens by implicitly converting it to a call expr.
14297  auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
14298  if (DRE) {
14299  auto *FD = cast<FunctionDecl>(DRE->getDecl());
14300  if (FD->getBuiltinID() == Builtin::BI__noop) {
14301  E = ImpCastExprToType(E, Context.getPointerType(FD->getType()),
14303  return new (Context) CallExpr(Context, E, None, Context.IntTy,
14305  }
14306  }
14307 
14308  Diag(E->getLocStart(), diag::err_builtin_fn_use);
14309  return ExprError();
14310  }
14311 
14312  // Everything else should be impossible.
14313 #define BUILTIN_TYPE(Id, SingletonId) \
14314  case BuiltinType::Id:
14315 #define PLACEHOLDER_TYPE(Id, SingletonId)
14316 #include "clang/AST/BuiltinTypes.def"
14317  break;
14318  }
14319 
14320  llvm_unreachable("invalid placeholder type!");
14321 }
14322 
14324  if (E->isTypeDependent())
14325  return true;
14327  return E->getType()->isIntegralOrEnumerationType();
14328  return false;
14329 }
14330 
14331 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
14332 ExprResult
14334  assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
14335  "Unknown Objective-C Boolean value!");
14337  if (!Context.getBOOLDecl()) {
14338  LookupResult Result(*this, &Context.Idents.get("BOOL"), OpLoc,
14340  if (LookupName(Result, getCurScope()) && Result.isSingleResult()) {
14341  NamedDecl *ND = Result.getFoundDecl();
14342  if (TypedefDecl *TD = dyn_cast<TypedefDecl>(ND))
14343  Context.setBOOLDecl(TD);
14344  }
14345  }
14346  if (Context.getBOOLDecl())
14347  BoolT = Context.getBOOLType();
14348  return new (Context)
14349  ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes, BoolT, OpLoc);
14350 }
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1298
static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a function pointer.
Definition: SemaExpr.cpp:7521
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1060
Kind getKind() const
Definition: Type.h:2006
unsigned getNumElements() const
Definition: Type.h:2724
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
unsigned getAddressSpace() const
getAddressSpace - Return the address space of this type.
Definition: Type.h:5131
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
const ComplexType * getAsComplexIntegerType() const
Definition: Type.cpp:407
SourceLocation getRParenLoc() const
Definition: Expr.h:4401
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:442
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.h:2087
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1200
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
Definition: ObjCRuntime.h:212
static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10271
Defines the clang::ASTContext interface.
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false)
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
Definition: SemaExpr.cpp:13503
VariadicCallType
Definition: Sema.h:8080
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1366
SourceLocation getEnd() const
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
const Expr * getBase() const
Definition: ExprObjC.h:504
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
static std::string ComputeName(IdentType IT, const Decl *CurrentDecl)
Definition: Expr.cpp:475
CastKind getCastKind() const
Definition: Expr.h:2709
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:966
ExprObjectKind getObjectKind() const
Definition: Expr.h:411
CanQualType LongLongTy
Definition: ASTContext.h:825
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:504
void MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt)
Definition: SemaInternal.h:70
static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, VarDecl *Var, bool &SubCapturesAreNested, QualType &CaptureType, QualType &DeclRefType)
Definition: SemaExpr.cpp:12406
Stmt * body_back()
Definition: Stmt.h:589
bool isVariadic() const
Definition: Type.h:3228
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1110
static void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, VarDecl *var, DeclContext *DC)
Definition: SemaExpr.cpp:12360
Expr ** getArgs()
Retrieve the call arguments.
Definition: Expr.h:2208
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:8979
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:5490
bool isNullPtrType() const
Definition: Type.h:5439
StringRef getName() const
Definition: Decl.h:168
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
Definition: Sema.h:771
Smart pointer class that efficiently represents Objective-C method names.
bool isNonOverloadPlaceholderType() const
Definition: Type.h:5420
bool isCXX98PODType(ASTContext &Context) const
Definition: Type.cpp:1930
EvaluatedExprVisitor - This class visits 'Expr *'s.
QualType CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, QualType *CompLHSTy=nullptr)
Definition: SemaExpr.cpp:7742
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:5169
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2202
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc)
Definition: SemaExpr.cpp:3174
ASTConsumer & Consumer
Definition: Sema.h:296
static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Checks compatibility between two pointers and return the resulting type.
Definition: SemaExpr.cpp:5760
Simple class containing the result of Sema::CorrectTypo.
QualType CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType)
Definition: SemaExpr.cpp:9352
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:215
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
bool isInvalid() const
Definition: Ownership.h:159
bool isMacroID() const
bool isCharType() const
Definition: Type.cpp:1633
bool isSpecificBuiltinType(unsigned K) const
isSpecificBuiltinType - Test for a particular builtin type.
Definition: Type.h:5393
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2216
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:1769
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1014
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2330
DestructionKind isDestructedType() const
Definition: Type.h:999
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:178
static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
Diagnose invalid arithmetic on two function pointers.
Definition: SemaExpr.cpp:7505
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:6478
bool isMemberPointerType() const
Definition: Type.h:5256
SourceLocation getLocation() const
Definition: ExprObjC.h:513
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:899
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3136
TheContext getContext() const
Definition: DeclSpec.h:1697
static const CastKind CK_Invalid
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, QualType FloatTy, QualType IntTy, bool ConvertFloat, bool ConvertInt)
Hande arithmetic conversion from integer to float. Helper function of UsualArithmeticConversions() ...
Definition: SemaExpr.cpp:1061
static CXXDependentScopeMemberExpr * Create(const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1252
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType)
Definition: SemaExpr.cpp:5385
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:5661
CanQualType Char32Ty
Definition: ASTContext.h:824
static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, QualType PointerTy)
Return false if the NullExpr can be promoted to PointerTy, true otherwise.
Definition: SemaExpr.cpp:5747
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2524
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1581
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E)
Definition: SemaExpr.cpp:14186
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:209
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2539
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
DeclClass * getAsSingle() const
Definition: Lookup.h:447
bool isUserProvided() const
Definition: DeclCXX.h:1802
static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, SmallString< 32 > &Target)
Definition: SemaExpr.cpp:3006
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:464
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:39
SourceLocation getEndLoc() const
getEndLoc - Retrieve the location of the last token.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1663
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
unsigned getIntWidth(QualType T) const
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
static bool IsReadonlyMessage(Expr *E, Sema &S)
Definition: SemaExpr.cpp:9037
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:3944
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
Defines the SourceManager interface.
bool tryToFixConversion(const Expr *FromExpr, const QualType FromQTy, const QualType ToQTy, Sema &S)
If possible, generates and stores a fix for the given conversion.
void addConst()
addConst - add the specified type qualifier to this QualType.
Definition: Type.h:733
ActionResult< Expr * > ExprResult
Definition: Ownership.h:252
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Definition: SemaExpr.cpp:4137
The current expression is potentially evaluated at run time, which means that code may be generated t...
Definition: Sema.h:781
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:163
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc)
Definition: SemaExpr.cpp:8330
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedExpr::IdentType IT)
Definition: SemaExpr.cpp:3017
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, SourceLocation Loc, Sema &Sema)
Definition: SemaExpr.cpp:9329
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:462
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
bool isRecordType() const
Definition: Type.h:5289
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
QualType CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign=false)
Definition: SemaExpr.cpp:7453
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Definition: SemaExpr.cpp:5671
void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, Scope *CurScope)
Definition: SemaExpr.cpp:11238
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
Definition: SemaExpr.cpp:4428
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1804
ExprResult CheckBooleanCondition(Expr *E, SourceLocation Loc)
Definition: SemaExpr.cpp:13678
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc", where we know the signature a priori.
Definition: Builtins.h:130
void setType(QualType t)
Definition: Expr.h:126
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:6826
param_iterator param_end()
Definition: Decl.h:3525
AssignConvertType
Definition: Sema.h:8140
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2500
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E)
Definition: SemaExpr.cpp:9051
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
Defines the C++ template declaration subclasses.
bool isVoidPointerType() const
Definition: Type.cpp:384
Scope * TUScope
Definition: Sema.h:680
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, Expr *PointerExpr, SourceLocation Loc, bool IsIntFirstExpr)
Return false if the first expression is not an integer and the second expression is not a pointer...
Definition: SemaExpr.cpp:5896
bool isEnumeralType() const
Definition: Type.h:5292
static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
Definition: SemaExpr.cpp:3540
ExprResult DefaultArgumentPromotion(Expr *E)
Definition: SemaExpr.cpp:785
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:814
bool CheckVecStepExpr(Expr *E)
Definition: SemaExpr.cpp:3778
std::string getAsString() const
Definition: Type.h:897
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
Definition: SemaExpr.cpp:14159
PtrTy get() const
Definition: Ownership.h:163
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:3995
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:834
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
Definition: SemaExpr.cpp:11486
IdentifierInfo * getAsIdentifierInfo() const
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:6866
bool isObjCQualifiedClassType() const
Definition: Type.h:5323
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:851
CanQualType LongTy
Definition: ASTContext.h:825
iterator begin() const
Definition: Lookup.h:275
SourceLocation LocEnd
Definition: Sema.h:3918
QualType CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, QualType *CompLHSTy=nullptr)
Definition: SemaExpr.cpp:7820
Declaration of a variable template.
const Expr * getInit() const
Definition: Decl.h:1068
void MarkDeclRefReferenced(DeclRefExpr *E)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:13333
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1341
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, FunctionDecl *FDecl, ArrayRef< Expr * > Args)
Definition: SemaExpr.cpp:4265
static ExprValueKind getValueKindForType(QualType T)
Definition: Expr.h:394
decl_iterator begin()
static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Returns false if the pointers are converted to a composite type, true otherwise.
Definition: SemaExpr.cpp:8174
bool isBooleanType() const
Definition: Type.h:5489
TemplateNameKind Kind
The kind of template that Template refers to.
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set. Generally this answers the question of...
Definition: Type.h:424
A container of type source information.
Definition: Decl.h:60
static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmetic conversion with complex types. Helper function of UsualArithmeticConversions() ...
Definition: SemaExpr.cpp:1005
SourceLocation getOperatorLoc() const
Definition: Expr.h:2958
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:1607
bool isBlockPointerType() const
Definition: Type.h:5238
static StringLiteral * Create(const ASTContext &C, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumStrs)
Definition: Expr.cpp:832
static bool IsWithinTemplateSpecialization(Decl *D)
Definition: SemaExpr.cpp:8125
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:8901
static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S)
Definition: SemaExpr.cpp:9213
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1083
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C...
Definition: Type.h:5189
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:8524
[ARC] Consumes a retainable object pointer that has just been produced, e.g. as the return value of a...
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy, SourceLocation QuestionLoc)
Return false if the vector condition type and the vector result type are compatible.
Definition: SemaExpr.cpp:6035
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
Definition: Expr.cpp:2912
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3746
CanQualType WideCharTy
Definition: ASTContext.h:821
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e.g., it is an unsigned integer type or a vector.
Definition: Type.cpp:1753
isModifiableLvalueResult
Definition: Expr.h:270
const llvm::APInt & getSize() const
Definition: Type.h:2472
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
Definition: SemaExpr.cpp:11579
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, QualType LHSType)
Definition: SemaExpr.cpp:7919
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:80
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:135
bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, CastKind &Kind)
Definition: SemaExpr.cpp:5428
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS)
Definition: SemaExpr.cpp:8242
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:539
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
Definition: SemaExpr.cpp:2684
static void diagnoseLogicalNotOnLHSofComparison(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned OpaqueOpc)
Definition: SemaExpr.cpp:8379
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9016
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2056
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
visible_categories_range visible_categories() const
Definition: DeclObjC.h:1324
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1572
void removeObjCLifetime()
Definition: Type.h:293
static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Definition: SemaExpr.cpp:8219
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
const Expr * getCallee() const
Definition: Expr.h:2188
ObjCLifetime getObjCLifetime() const
Definition: Type.h:287
bool hasCaptures() const
Definition: Decl.h:3552
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
ExtProtoInfo - Extra information about a function prototype.
Definition: Type.h:3042
QualType getUsageType(QualType objectType) const
Definition: DeclObjC.cpp:1655
bool isCanonical() const
Definition: Type.h:5060
static void EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a '&' expr that is inside a '|' one. Emit a diagnostic together with a fixit hint that wra...
Definition: SemaExpr.cpp:10313
std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD)
Retrieve the message suffix that should be added to a diagnostic complaining about the given function...
Definition: SemaExpr.cpp:383
bool isUnresolvableResult() const
Definition: Lookup.h:257
static FunctionDecl * rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context, const FunctionDecl *FDecl, MultiExprArg ArgExprs)
Definition: SemaExpr.cpp:4660
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1701
Represents a variable template specialization, which refers to a variable template with a given set o...
static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
If two different enums are compared, raise a warning.
Definition: SemaExpr.cpp:8136
static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, ExprResult &ComplexExpr, QualType IntTy, QualType ComplexTy, bool SkipCast)
Converts an integer to complex float type. Helper function of UsualArithmeticConversions() ...
Definition: SemaExpr.cpp:983
bool isRealType() const
Definition: Type.cpp:1782
void ActOnStartStmtExpr()
Definition: SemaExpr.cpp:10884
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO)
Create the initialization entity for the result of a function.
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
Definition: ExprCXX.h:87
static InitializationKind CreateDirectList(SourceLocation InitLoc)
capture_range captures()
Definition: Decl.h:3563
const BuiltinType * getAsPlaceholderType() const
Definition: Type.h:5406
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input)
Definition: SemaExpr.cpp:10799
bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
Definition: SemaExpr.cpp:12765
unsigned getValue() const
Definition: Expr.h:1349
static void DiagnoseConstAssignment(Sema &S, const Expr *E, SourceLocation Loc)
Definition: SemaExpr.cpp:9089
std::vector< FixItHint > Hints
The list of Hints generated so far.
bool body_empty() const
Definition: Stmt.h:579
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false)
Definition: SemaExpr.cpp:7114
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
Definition: Expr.cpp:3225
Defines the clang::Expr interface and subclasses for C++ expressions.
SourceLocation getLocation() const
Definition: Expr.h:1002
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:194
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:647
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1727
bool isVoidType() const
Definition: Type.h:5426
static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Emit error when two pointers are incompatible.
Definition: SemaExpr.cpp:7733
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
Definition: ScopeInfo.h:465
QualType withConst() const
Retrieves a version of this type with const applied. Note that this does not always yield a canonical...
EvaluatedStmt * ensureEvaluatedStmt() const
Definition: Decl.cpp:2086
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
Definition: SemaExpr.cpp:4730
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
static bool VectorTypesMatch(Sema &S, QualType srcTy, QualType destTy)
Definition: SemaExpr.cpp:5404
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Definition: SemaExpr.cpp:13419
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
Expr * IgnoreImpCasts() LLVM_READONLY
Definition: Expr.h:2803
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration. It marks the declaration referenced...
Definition: SemaExpr.cpp:13367
static Sema::AssignConvertType checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:6712
unsigned getNumParams() const
Definition: Type.h:3133
bool isBitwiseOp() const
Definition: Expr.h:2999
static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType CondTy, SourceLocation QuestionLoc)
Convert scalar operands to a vector that matches the condition in length.
Definition: SemaExpr.cpp:5981
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:94
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Definition: SemaExpr.cpp:6217
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body (definition). The function body might be in any of the (re-)d...
Definition: Decl.cpp:2368
bool isComparisonOp() const
Definition: Expr.h:3008
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1457
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2537
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:937
ExprResult UsualUnaryConversions(Expr *E)
Definition: SemaExpr.cpp:736
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
Definition: SemaExpr.cpp:3909
DeclarationName getName() const
getName - Returns the embedded declaration name.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3057
CanQualType getIntMaxType() const
Return the unique type for "intmax_t" (C99 7.18.1.5), defined in <stdint.h>.
Represents a class template specialization, which refers to a class template with a given set of temp...
iterator end() const
Definition: Lookup.h:276
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:700
static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle conversions with GCC complex int extension. Helper function of UsualArithmeticConversions() ...
Definition: SemaExpr.cpp:1196
bool isScalarType() const
Definition: Type.h:5461
bool hasPtrArgsOrResult(unsigned ID) const
Determines whether this builtin has a result or any arguments which are pointer types.
Definition: Builtins.h:148
void DiagnoseUnusedExprResult(const Stmt *S)
Definition: SemaStmt.cpp:185
bool hasAttr() const
Definition: DeclBase.h:487
IdentifierInfo * getCorrectionAsIdentifierInfo() const
A vector component is an element or range of elements on a vector.
Definition: Specifiers.h:117
Expr * getSizeExpr() const
Definition: Type.h:2568
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1742
static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:6446
static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, Sema &S)
Capture the given variable in the captured region.
Definition: SemaExpr.cpp:12599
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
A C++ nested-name-specifier augmented with source location information.
ExprResult ExprEmpty()
Definition: Ownership.h:273
static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, Expr *Operand)
Check the validity of an arithmetic pointer operand.
Definition: SemaExpr.cpp:7556
Converts between different integral complex types. _Complex char -> _Complex long long _Complex unsig...
LineState State
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3138
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2213
ObjCMethodFamily
A family of Objective-C methods.
QualType getAddrSpaceQualType(QualType T, unsigned AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
static Sema::AssignConvertType checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:6558
bool isReferenceType() const
Definition: Type.h:5241
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
QualType getReturnType() const
Definition: Decl.h:1997
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:882
bool isAnyPointerType() const
Definition: Type.h:5235
void diagnoseARCUnbridgedCast(Expr *e)
void setBOOLDecl(TypedefDecl *TD)
Save declaration of 'BOOL' typedef.
Definition: ASTContext.h:1546
void setNumArgs(const ASTContext &C, unsigned NumArgs)
Definition: Expr.cpp:1191
bool isFileID() const
bool isOverloaded() const
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:92
bool isPure() const
Definition: Decl.h:1789
static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A)
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, unsigned Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS)
Create a binary operation that may resolve to an overloaded operator.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprObjC.h:519
void setCaptures(ASTContext &Context, const Capture *begin, const Capture *end, bool capturesCXXThis)
Definition: Decl.cpp:3760
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:212
unsigned getCVRQualifiers() const
Definition: Type.h:248
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:2226
void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE)
Redundant parentheses over an equality comparison can indicate that the user intended an assignment u...
Definition: SemaExpr.cpp:13651
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:134
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS)
Definition: SemaExpr.cpp:554
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1871
[ARC] Causes a value of block type to be copied to the heap, if it is not already there...
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:367
static void addAsFieldToClosureType(Sema &S, LambdaScopeInfo *LSI, VarDecl *Var, QualType FieldType, QualType DeclRefType, SourceLocation Loc, bool RefersToCapturedVariable)
Create a field within the lambda class for the variable being captured.
Definition: SemaExpr.cpp:12646
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:449
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Diagnose invalid arithmetic on two void pointers.
Definition: SemaExpr.cpp:7486
FrontendAction * Action
Definition: Tooling.cpp:168
void setKind(tok::TokenKind K)
Definition: Token.h:91
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1708
ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
Definition: SemaExpr.cpp:14333
Expr * getSubExpr()
Definition: Expr.h:2713
bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr)
Definition: SemaExpr.cpp:11598
bool isOpenMPPrivateVar(VarDecl *VD, unsigned Level)
Definition: SemaOpenMP.cpp:679
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Definition: SemaExpr.cpp:6097
bool isForRedeclaration() const
True if this lookup is just looking for an existing declaration.
Definition: Lookup.h:219
bool isParamConsumed(unsigned I) const
Definition: Type.h:3277
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1114
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:12075
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1896
SourceRange getExprRange(Expr *E) const
Definition: SemaExpr.cpp:487
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:39
IdentifierTable & Idents
Definition: ASTContext.h:439
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:200
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Definition: Expr.cpp:1285
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:95
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:371
Converts a floating point complex to bool by comparing against 0+0i.
T * getAttr() const
Definition: DeclBase.h:484
ExprResult ActOnBooleanCondition(Scope *S, SourceLocation Loc, Expr *SubExpr)
Definition: SemaExpr.cpp:13708
static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if the condition expression is valid, true otherwise.
Definition: SemaExpr.cpp:5710
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:170
Describes an C or C++ initializer list.
Definition: Expr.h:3759
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1616
void CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr)
Definition: SemaExpr.cpp:4548
static bool IsTypeModifiable(QualType Ty, bool IsDereference)
Definition: SemaExpr.cpp:9078
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1543
QualType getCallResultType(ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition: Type.h:2968
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
Definition: SemaExpr.cpp:11368
ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, Expr *ControllingExpr, ArrayRef< ParsedType > ArgTypes, ArrayRef< Expr * > ArgExprs)
Definition: SemaExpr.cpp:1318
static bool CheckVecStepTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
Definition: SemaExpr.cpp:3493
BinaryOperatorKind
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:869
static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E, bool OdrUse)
Definition: SemaExpr.cpp:13301
param_type_range param_types() const
Definition: Type.h:3251
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
Definition: Sema.h:791
SmallVectorImpl< PartialDiagnosticAt > * Diag
Definition: Expr.h:543
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:488
Represents the results of name lookup.
Definition: Lookup.h:30
static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Simple conversion between integer and floating point types.
Definition: SemaExpr.cpp:5926
ExprResult CallExprUnaryConversions(Expr *E)
Definition: SemaExpr.cpp:714
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:518
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:323
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
QualType getOriginalType() const
Definition: Decl.cpp:2285
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
Definition: SemaExpr.cpp:5645
static bool isVariableCapturable(CapturingScopeInfo *CSI, VarDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
Definition: SemaExpr.cpp:12447
const LangOptions & getLangOpts() const
Definition: ASTContext.h:533
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
Definition: SemaExpr.cpp:11211
ObjCMethodDecl * getCurMethodDecl()
Definition: Sema.cpp:924
bool isImplicit() const
Definition: DeclBase.h:503
unsigned getLength() const
Definition: Expr.h:1554
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:557
Qualifiers withoutObjCGCAttr() const
Definition: Type.h:275
bool ValidateCandidate(const TypoCorrection &candidate) override
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
uint32_t Offset
Definition: CacheTokens.cpp:43
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:856
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
QualType getReturnType() const
Definition: Type.h:2952
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:6746
unsigned getMinRequiredArguments() const
Definition: Decl.cpp:2694
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
field_range fields() const
Definition: Decl.h:3349
bool isObjCLifetimeType() const
Definition: Type.cpp:3561
static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, SourceLocation OpLoc)
Definition: SemaExpr.cpp:9990
const ArrayType * getAsArrayType(QualType T) const
static Expr * recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, DeclarationNameInfo &NameInfo, SourceLocation TemplateKWLoc, const TemplateArgumentListInfo *TemplateArgs)
Definition: SemaExpr.cpp:2025
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2918
An implicit 'self' parameter.
Definition: DeclSpec.h:894
CanQualType PseudoObjectTy
Definition: ASTContext.h:834
static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both block pointers.
Definition: SemaExpr.cpp:5831
bool isValueDependent() const
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3527
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate)
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
bool isUnsignedIntegerType() const
Definition: Type.cpp:1723
bool isOverloadedOperator() const
Definition: Decl.h:2050
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, const SourceRange &ArgRange)
Definition: SemaExpr.cpp:3855
CanQualType LongDoubleTy
Definition: ASTContext.h:828
Expr * IgnoreParenCasts() LLVM_READONLY
Definition: Expr.cpp:2439
QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope...
Definition: SemaExpr.cpp:13079
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Definition: ASTLambda.h:71
QualType getTypeAsWritten() const
Definition: Expr.h:2849
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6024
static bool CheckExtensionTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
Definition: SemaExpr.cpp:3511
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1006
bool CanUseDecl(NamedDecl *D)
Determine whether the use of this declaration is valid, without emitting diagnostics.
Definition: SemaExpr.cpp:51
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:68
TypeClass getTypeClass() const
Definition: Type.h:1486
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, SourceLocation OpLoc)
CheckIndirectionOperand - Type check unary indirection (prefix '*').
Definition: SemaExpr.cpp:9868
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1731
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:217
bool isIncompleteType(NamedDecl **Def=nullptr) const
Def If non-NULL, and the type refers to some kind of declaration that can be completed (such as a C s...
Definition: Type.cpp:1869
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1032
DeclContext * getLexicalDeclContext()
Definition: DeclBase.h:697
tok::TokenKind getKind() const
Definition: Token.h:90
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1052
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
Preprocessor & PP
Definition: Sema.h:294
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:726
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3202
An ordinary object is located at an address in memory.
Definition: Specifiers.h:111
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:2954
static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the right hand of a '||' expr.
Definition: SemaExpr.cpp:10378
A class that does preorder depth-first traversal on the entire Clang AST and visits each node...
Represents an ObjC class declaration.
Definition: DeclObjC.h:851
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
Definition: Sema.h:818
bool isExtVectorType() const
Definition: Type.h:5301
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access. Does not test the acceptance criteria...
Definition: Lookup.h:366
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Character, const SourceManager &SM, const LangOptions &LangOpts)
Definition: Lexer.cpp:700
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Definition: SemaExpr.cpp:5219
bool isEqualityOp() const
Definition: Expr.h:3005
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2763
SourceLocation getLParenLoc() const
Definition: Expr.h:4400
ExprResult checkUnknownAnyArg(SourceLocation callLoc, Expr *result, QualType &paramType)
Type-check an expression that's being passed to an __unknown_anytype parameter.
Definition: SemaExpr.cpp:14163
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Definition: DeclCXX.cpp:1949
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be used directly for normal expressions referring to VarDecl.
Definition: SemaExpr.cpp:13297
bool ExprNeedsCleanups
Definition: Sema.h:413
CanQualType UnsignedCharTy
Definition: ASTContext.h:826
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:862
QualType getType() const
Definition: Decl.h:538
bool isInvalid() const
void setStmt(LabelStmt *T)
Definition: Decl.h:379
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1683
const LangOptions & LangOpts
Definition: Sema.h:293
CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find the method in RD that corresponds to this one.
Definition: DeclCXX.cpp:1426
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:733
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
static void CheckForNullPointerDereference(Sema &S, Expr *E)
Definition: SemaExpr.cpp:535
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name. Otherwise, returns NULL.
Definition: Expr.h:1013
TypeSpecTypeLoc pushTypeSpec(QualType T)
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:6731
bool isDefined(const FunctionDecl *&Definition) const
Definition: Decl.cpp:2393
Represents the this expression in C++.
Definition: ExprCXX.h:770
void ActOnStmtExprError()
Definition: SemaExpr.cpp:10888
TyLocType push(QualType T)
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:500
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Definition: Sema.h:808
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:1823
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID)
Lookup a property by name in the specified DeclContext.
Definition: DeclObjC.cpp:154
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:63
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:373
EnumDecl * getDecl() const
Definition: Type.h:3550
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:965
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1864
AvailabilityResult getAvailability(std::string *Message=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:442
ExtInfo getExtInfo() const
Definition: Type.h:2961
IdentifierInfo * IdentInfo
Definition: Sema.h:3921
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10444
bool isAssignmentOp() const
Definition: Expr.h:3043
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
Definition: Lookup.h:348
static bool ExprLooksBoolean(Expr *E)
Definition: SemaExpr.cpp:6427
bool Mutable
Whether this is a mutable lambda.
Definition: ScopeInfo.h:640
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:194
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Definition: SemaExpr.cpp:874
QualType getParamType(unsigned i) const
Definition: Type.h:3134
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3166
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:129
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2560
static NamedDecl * getDeclFromExpr(Expr *E)
Definition: SemaExpr.cpp:10064
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10079
static QualType checkOpenCLVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Return the resulting type when an OpenCL vector is shifted by a scalar or vector shift amount...
Definition: SemaExpr.cpp:8000
Retains information about a captured region.
Definition: ScopeInfo.h:579
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - Returns lifetime attribute of this type.
Definition: Type.h:976
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
CastKind
CastKind - The kind of operation required for a conversion.
static bool isQualifiedMemberAccess(Expr *E)
Determine whether the given expression is a qualified member access expression, of a form that could ...
Definition: SemaExpr.cpp:10760
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1737
static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, ExprResult &RHS)
Handle when one or both operands are void type.
Definition: SemaExpr.cpp:5729
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:442
Specifies that the expression should never be value-dependent.
Definition: Expr.h:658
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
Definition: ASTContext.h:1441
void setSubExpr(Expr *E)
Definition: Expr.h:1700
static StringRef getOpcodeStr(Opcode Op)
Definition: Expr.cpp:1781
QualType CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign=false)
Definition: SemaExpr.cpp:8917
ASTContext * Context
static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Emit a warning when adding a char literal to a string.
Definition: SemaExpr.cpp:7682
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
VAArgExpr, used for the builtin function __builtin_va_arg.
Definition: Expr.h:3670
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param)
Definition: ExprCXX.h:896
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1710
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle integer arithmetic conversions. Helper function of UsualArithmeticConversions() ...
Definition: SemaExpr.cpp:1146
QualType getPointeeType() const
Definition: Type.cpp:414
bool isUnarySelector() const
SourceLocation getOpLoc() const
Definition: ExprObjC.h:521
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:246
Converts between different floating point complex types. _Complex float -> _Complex double...
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a void pointer.
Definition: SemaExpr.cpp:7496
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1776
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
Definition: SemaExpr.cpp:5098
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1248
void DiagnoseAssignmentAsCondition(Expr *E)
Definition: SemaExpr.cpp:13593
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10478
LabelDecl * getDecl() const
Definition: Stmt.h:809
unsigned getNumExprs() const
Definition: Expr.h:4386
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:552
DeclContext * getLexicalParent()
Definition: DeclBase.h:1190
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1861
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:133
const Type * getTypeForDecl() const
Definition: Decl.h:2557
unsigned param_size() const
Definition: Decl.h:1941
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr * > Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false)
Definition: SemaExpr.cpp:4908
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, std::unique_ptr< CorrectionCandidateCallback > CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args=None, TypoExpr **Out=nullptr)
Definition: SemaExpr.cpp:1783
bool isOrdinaryOrBitFieldObject() const
Definition: Expr.h:415
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:204
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Definition: Lexer.cpp:759
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
const Expr * getExpr(unsigned Init) const
Definition: Expr.h:4388
Converts an integral complex to an integral real of the source's element type by discarding the imagi...
Represents a character-granular source range.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:92
static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for '&&' in the left hand of a '||' expr.
Definition: SemaExpr.cpp:10356
void setCallee(Expr *F)
Definition: Expr.h:2190
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e. the class which was looked into to find these result...
Definition: Lookup.h:343
Expr * stripARCUnbridgedCast(Expr *e)
bool isInstance() const
Definition: DeclCXX.h:1744
static DeclContext * getParentOfCapturingContextOrNull(DeclContext *DC, VarDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
Definition: SemaExpr.cpp:12432
bool isAnyComplexType() const
Definition: Type.h:5295
bool isObjCClassType() const
Definition: Type.h:5333
static bool EvaluatesAsTrue(Sema &S, Expr *E)
Returns true if the given expression can be evaluated as a constant 'true'.
Definition: SemaExpr.cpp:10341
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2362
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SourceLocation getNameLoc() const
Definition: Lookup.h:545
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool isVirtual() const
Definition: DeclCXX.h:1761
static bool captureInLambda(LambdaScopeInfo *LSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S)
Capture the given variable in the lambda.
Definition: SemaExpr.cpp:12663
bool isAtomicType() const
Definition: Type.h:5314
static Expr * maybeRebuildARCConsumingStmt(Stmt *Statement)
Definition: SemaExpr.cpp:10866
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
SourceRange getSourceRange() const
Definition: ExprCXX.h:98
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:812
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup. Asserts that one was found.
Definition: Lookup.h:457
bool isVariableArrayType() const
Definition: Type.h:5280
Defines the clang::Preprocessor interface.
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:743
bool IsVariableAConstantExpression(VarDecl *Var, ASTContext &Context)
Definition: SemaInternal.h:44
Kind getKind() const
Definition: DeclBase.h:375
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
Definition: SemaExpr.cpp:11869
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:218
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1968
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3142
bool isImplicitlyInstantiable() const
Determines whether this function is a function template specialization or a member of a class templat...
Definition: Decl.cpp:2966
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
#define bool
Definition: stdbool.h:31
static void emitEmptyLookupTypoDiagnostic(const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, DeclarationName Typo, SourceLocation TypoLoc, ArrayRef< Expr * > Args, unsigned DiagnosticID, unsigned DiagnosticSuggestID)
Definition: SemaExpr.cpp:1745
static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10415
DeclContext * getDeclContext()
Definition: DeclBase.h:381
Overload resolution succeeded.
Definition: Overload.h:41
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1096
bool isFloatingType() const
Definition: Type.cpp:1760
SourceLocation LocStart
Definition: Sema.h:3918
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHS, Expr *RHS)
Build an overloaded binary operator expression in the given scope.
Definition: SemaExpr.cpp:10492
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
Definition: SemaExpr.cpp:11630
CanQualType ShortTy
Definition: ASTContext.h:825
static ValueDecl * getCompareDecl(Expr *E)
Definition: SemaExpr.cpp:8424
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:411
ExprResult CheckPlaceholderExpr(Expr *E)
Definition: SemaExpr.cpp:14231
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:752
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
static DependentScopeDeclRefExpr * Create(const ASTContext &C, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:446
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6354
llvm::DenseMap< NamedDecl *, SourceLocation > UndefinedButUsed
Definition: Sema.h:938
Defines the clang::TypeLoc interface and its subclasses.
bool isObjCIdType() const
Definition: Type.h:5328
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
Definition: Builtins.h:142
unsigned getIntMaxTWidth() const
Return the size of intmax_t and uintmax_t for this target, in bits.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2040
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:12133
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:662
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:303
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:107
Expr * getUninstantiatedDefaultArg()
Definition: Decl.h:1429
Capture & getCapture(VarDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Definition: ScopeInfo.h:533
Expr * getSubExpr() const
Definition: Expr.h:1699
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:538
const SourceRange & getRange() const
Definition: DeclSpec.h:73
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:434
bool isDependentType() const
Definition: Type.h:1727
static bool IsPotentiallyEvaluatedContext(Sema &SemaRef)
Definition: SemaExpr.cpp:12147
bool isInstanceMethod() const
Definition: DeclObjC.h:419
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:421
bool isFunctionOrMethod() const
Definition: DeclBase.h:1223
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
Definition: ScopeInfo.cpp:100
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1174
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
QualType getCXXNameType() const
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1510
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:215
ScalarTypeKind
Definition: Type.h:1710
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:858
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
bool isExternallyVisible() const
Definition: Decl.h:279
Converts from an integral complex to a floating complex. _Complex unsigned -> _Complex float...
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
Definition: SemaExpr.cpp:9967
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6518
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
Definition: SemaExpr.cpp:11167
DeclarationName getDeclName() const
Definition: Decl.h:189
void CleanupVarDeclMarking()
Definition: SemaExpr.cpp:13154
QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool isRelational)
Definition: SemaExpr.cpp:8855
ValueDecl * getDecl()
Definition: Expr.h:994
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view. Entities in anonymous namespaces are external (in c++9...
Definition: Decl.h:270
QualType getElementType() const
Definition: Type.h:2723
bool isGLValue() const
Definition: Expr.h:253
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2405
bool isComplexIntegerType() const
Definition: Type.cpp:402
The result type of a method or function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration. Return null if the results were absent...
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:702
bool ParentNeedsCleanups
Whether the enclosing context needed a cleanup.
Definition: Sema.h:801
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
Definition: SemaExpr.cpp:5113
void setBlockMangling(unsigned Number, Decl *Ctx)
Definition: Decl.h:3596
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:253
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:155
static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args)
Definition: SemaExpr.cpp:4633
UnresolvedSetImpl::iterator decls_iterator
Definition: ExprCXX.h:2388
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:611
static bool hasAnyExplicitStorageClass(const FunctionDecl *D)
Determine whether a FunctionDecl was ever declared with an explicit storage class.
Definition: SemaExpr.cpp:240
QualType getWideCharType() const
Return the type of wide characters. In C++, this returns the unique wchar_t type. In C99...
Definition: ASTContext.h:1264
const Expr * getAnyInitializer() const
Definition: Decl.h:1056
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1835
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:148
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, TypeSourceInfo **RecoveryTSI=nullptr)
Definition: SemaExpr.cpp:2306
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD)
Definition: SemaExpr.cpp:4530
static bool isPlaceholderToRemoveAsArg(QualType type)
Definition: SemaExpr.cpp:4592
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool *NonStandardCompositeType=nullptr)
Find a merged pointer type and convert the two expressions to it.
ivar_iterator ivar_begin() const
Definition: DeclObjC.h:1126
static CharSourceRange getCharRange(SourceRange R)
bool isAmbiguous() const
Definition: Lookup.h:241
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
Definition: SemaExpr.cpp:3488
static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E, unsigned Type)
Diagnose invalid operand for address of operations.
Definition: SemaExpr.cpp:9640
param_iterator param_begin()
Definition: Decl.h:3524
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:81
bool isClassMethod() const
Definition: DeclObjC.h:424
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute. The C++11 [[noreturn]] attr...
Definition: Type.h:2959
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:376
static bool isBitwiseOp(Opcode Opc)
Definition: Expr.h:2998
Stmt * getBody(const FunctionDecl *&Definition) const
Definition: Decl.cpp:2405
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void initializeFullCopy(TypeLoc Other) const
Initializes this by copying its information from another TypeLoc of the same type.
Definition: TypeLoc.h:165
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:1821
static QualType checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both pointers.
Definition: SemaExpr.cpp:5857
Wrapper for source info for arrays.
Definition: TypeLoc.h:1346
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
Expr * IgnoreConversionOperator() LLVM_READONLY
Definition: Expr.cpp:2548
CanQualType OverloadTy
Definition: ASTContext.h:832
static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, Expr *Operand)
Emit error if Operand is incomplete pointer type.
Definition: SemaExpr.cpp:7535
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. This may omit quali...
Definition: Decl.cpp:2819
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:208
static AvailabilityResult DiagnoseAvailabilityOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess)
Definition: SemaExpr.cpp:102
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl. It will iterate at least once ...
Definition: Redeclarable.h:228
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
#define false
Definition: stdbool.h:33
CanQualType BuiltinFnTy
Definition: ASTContext.h:833
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2305
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5476
bool CheckCaseExpression(Expr *E)
Definition: SemaExpr.cpp:14323
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
Definition: SemaExpr.cpp:2390
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:136
A stack object to be created when performing template instantiation.
Definition: Sema.h:6610
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > Types, ArrayRef< Expr * > Exprs)
Definition: SemaExpr.cpp:1344
SourceLocation getOuterLocStart() const
Definition: Decl.cpp:1674
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_convertvector(...)
Definition: SemaExpr.cpp:4893
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition: Type.cpp:1576
llvm::SmallPtrSet< Expr *, 2 > MaybeODRUseExprs
Store a list of either DeclRefExprs or MemberExprs that contain a reference to a variable (constant) ...
Definition: Sema.h:426
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType())
llvm::APFloat::opStatus GetFloatValue(llvm::APFloat &Result)
const Type * getTypePtr() const
Definition: Type.h:5016
llvm::SmallPtrSet< Expr *, 2 > SavedMaybeODRUseExprs
Definition: Sema.h:814
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Definition: SemaExpr.cpp:5204
QualType getElementType() const
Definition: Type.h:2077
QualType withCVRQualifiers(unsigned CVR) const
Definition: Type.h:756
Expression is not a Null pointer constant.
Definition: Expr.h:635
VarArgKind isValidVarArgType(const QualType &Ty)
Definition: SemaExpr.cpp:827
static void SuggestParentheses(Sema &Self, SourceLocation Loc, const PartialDiagnostic &Note, SourceRange ParenRange)
Definition: SemaExpr.cpp:6358
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:623
const TemplateArgumentListInfo & getTemplateArgsInfo() const
void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr)
Definition: SemaStmt.cpp:1170
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:9456
bool IsNoReturnConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noreturn"...
bool isComplexType() const
Definition: Type.cpp:396
bool isValid() const
Return true if this is a valid SourceLocation object.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1623
static ValueDecl * getPrimaryDecl(Expr *E)
Definition: SemaExpr.cpp:9583
void setLastStmt(Stmt *S)
Definition: Stmt.h:591
static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, Expr *E)
Check whether E is a pointer from a decayed array type (the decayed pointer type is equal to T) and e...
Definition: SemaExpr.cpp:3558
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:153
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1026
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1158
void setReferenced(bool R=true)
Definition: DeclBase.h:532
QualType CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned OpaqueOpc, bool isRelational)
Definition: SemaExpr.cpp:8439
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
VectorKind getVectorKind() const
Definition: Type.h:2732
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3083
QualType withConst() const
Definition: Type.h:736
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:109
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1875
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
bool isObjCBuiltinType() const
Definition: Type.h:5343
void setIdentifierInfo(IdentifierInfo *II)
Definition: Token.h:186
QualType CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, bool IsCompAssign=false)
Definition: SemaExpr.cpp:8062
ExprResult TransformToPotentiallyEvaluated(Expr *E)
Definition: SemaExpr.cpp:12045
const CXXRecordDecl * getBestDynamicClassType() const
For an expression of class type or pointer to class type, return the most derived class decl the expr...
Definition: Expr.cpp:39
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:610
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
CanQualType FloatTy
Definition: ASTContext.h:828
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:2909
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:199
QualType getObjCSelRedefinitionType() const
Retrieve the type that 'SEL' has been defined to, which may be different from the built-in 'SEL' if '...
Definition: ASTContext.h:1354
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2003
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
ExprResult ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
Definition: SemaExpr.cpp:5163
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:666
CanQualType VoidTy
Definition: ASTContext.h:817
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Describes the kind of initialization being performed, along with location information for tokens rela...
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
Definition: SemaExpr.cpp:7062
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition: ScopeInfo.h:486
Converts from an integral real to an integral complex whose element type matches the source...
unsigned NumTypos
The number of typos encountered during this expression evaluation context (i.e. the number of TypoExp...
Definition: Sema.h:812
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:2424
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member. Returns null if this is an ove...
Definition: Expr.cpp:2384
bool isRValue() const
Definition: Expr.h:251
QualType getReturnType() const
Definition: DeclObjC.h:330
SourceLocation getBegin() const
virtual void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR)
Definition: SemaExpr.cpp:11863
bool isTypeDependent() const
Definition: Expr.h:166
const T * castAs() const
Definition: Type.h:5586
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:77
void setKind(IdKind kind)
Definition: DeclSpec.h:967
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
bool isAscii() const
Definition: Expr.h:1564
bool typesAreBlockPointerCompatible(QualType, QualType)
PtrTy get() const
Definition: Ownership.h:74
bool isVectorType() const
Definition: Type.h:5298
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2601
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2275
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1137
Assigning into this object requires a lifetime extension.
Definition: Type.h:147
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5086
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
Definition: Template.h:108
QualType CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc)
Definition: SemaExpr.cpp:8944
ExprResult HandleExprEvaluationContextForTypeof(Expr *E)
Definition: SemaExpr.cpp:12141
const BlockDecl * getBlockDecl() const
Definition: Expr.h:4616
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:436
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:538
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:555
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:247
Opcode getOpcode() const
Definition: Expr.h:1696
ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
Definition: SemaExpr.cpp:10897
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
QualType getPointeeType() const
Definition: Type.h:2139
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:1703
ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType)
Definition: SemaExpr.cpp:1128
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, Expr *CastExpr, CastKind &CastKind, ExprValueKind &VK, CXXCastPath &Path)
Definition: SemaExpr.cpp:14145
void maybeExtendBlockObject(ExprResult &E)
Do an explicit extend of the given block pointer if we're in ARC.
Definition: SemaExpr.cpp:5189
Represents a C11 generic selection.
Definition: Expr.h:4446
ReuseLambdaContextDecl_t
Definition: Sema.h:3506
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
Definition: Decl.cpp:2242
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1242
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3357
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
Definition: SemaExpr.cpp:13345
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
QualType getType() const
Definition: Expr.h:125
sema::LambdaScopeInfo * getCurLambda()
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1179
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
CanQualType CharTy
Definition: ASTContext.h:819
Represents a template argument.
Definition: TemplateBase.h:39
Converts a floating point complex to floating point real of the source's element type. Just discards the imaginary component. _Complex long double -> long double.
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:7629
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Definition: SemaExpr.cpp:1723
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3059
NonConstCaptureKind
Definition: SemaExpr.cpp:9050
static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, QualType UnionType, FieldDecl *Field)
Constructs a transparent union from an expression that is used to initialize the transparent union...
Definition: SemaExpr.cpp:7043
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2276
static const Type * getElementType(const Expr *BaseExpr)
void setBody(CompoundStmt *B)
Definition: Decl.h:3504
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, OffsetOfComponent *CompPtr, unsigned NumComponents, SourceLocation RParenLoc)
Definition: SemaExpr.cpp:11146
StringRef getOpcodeStr() const
Definition: Expr.h:2980
const Expr * getExpr() const
Definition: ExprCXX.h:911
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:2932
ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S)
Qualifiers withoutObjCLifetime() const
Definition: Type.h:280
static bool isScopedEnumerationType(QualType T)
Definition: SemaExpr.cpp:7913
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1174
TypedefDecl * getBOOLDecl() const
Retrieve declaration of 'BOOL' typedef.
Definition: ASTContext.h:1541
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:555
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input)
Definition: SemaExpr.cpp:10847
Represents a delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray"...
Definition: ExprCXX.h:1819
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:7643
bool isSentinelNullExpr(const Expr *E)
Converts an integral complex to bool by comparing against 0+0i.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:311
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:214
bool hasUnparsedDefaultArg() const
Definition: Decl.h:1453
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1184
QualType GetSignedVectorType(QualType V)
Definition: SemaExpr.cpp:8835
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
Definition: Sema.cpp:340
static bool CheckAlignOfExpr(Sema &S, Expr *E)
Definition: SemaExpr.cpp:3721
bool isInvalidDecl() const
Definition: DeclBase.h:498
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
Definition: SemaExpr.cpp:8288
static bool IsVariableNonDependentAndAConstantExpression(VarDecl *Var, ASTContext &Context)
Definition: SemaExpr.cpp:13098
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, QualType scalarTy, QualType vectorEltTy, QualType vectorTy)
Definition: SemaExpr.cpp:7235
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1044
void setSubExpr(Expr *E)
Definition: Expr.h:2715
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_astype(...)
Definition: SemaExpr.cpp:4872
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:13524
static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare)
Definition: SemaExpr.cpp:7387
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:827
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
Definition: SemaCast.cpp:1658
const ObjCInterfaceType * getInterfaceType() const
Definition: Type.cpp:1423
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind)
Check the constraints on expression operands to unary type expression and type traits.
Definition: SemaExpr.cpp:3581
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > CUDAKernelCallExpr
Matches CUDA kernel call expression.
Definition: ASTMatchers.h:4113
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, IdentifierInfo *UDSuffix, SourceLocation UDSuffixLoc, ArrayRef< Expr * > Args, SourceLocation LitEndLoc)
Definition: SemaExpr.cpp:1493
Expr * getDefaultArg()
Definition: Decl.cpp:2314
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn)
Definition: SemaExpr.cpp:13796
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call. Returns true if recovery was attempted or...
Definition: Sema.cpp:1431
bool isUsed(bool CheckUsedAttr=true) const
Whether this declaration was used, meaning that a definition is required.
Definition: DeclBase.cpp:305
bool isLValue() const
Definition: Expr.h:250
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:1849
Expression is a Null pointer constant built from a zero integer expression that is not a simple...
Definition: Expr.h:642
ExpressionEvaluationContext Context
The expression evaluation context.
Definition: Sema.h:798
virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D)
Invoked when a function is implicitly instantiated. Note that at this point point it does not have a ...
Definition: ASTConsumer.h:85
union clang::Sema::OffsetOfComponent::@207 U
A set of unresolved declarations.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:633
bool isDefinedOutsideFunctionOrMethod() const
Definition: DeclBase.h:720
virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR)=0
Expression is a C++11 nullptr.
Definition: Expr.h:648
static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a '&&' expr that is inside a '||' one. Emit a diagnostic together with a fixit hint that w...
Definition: SemaExpr.cpp:10328
bool isHalfType() const
Definition: Type.h:5432
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:131
unsigned getNumArgs() const
Definition: Expr.h:2205
bool isSingleResult() const
Definition: Lookup.h:248
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
A conversion of a floating point real to a floating point complex of the original type...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1855
ExprResult DefaultFunctionArrayConversion(Expr *E)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:496
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:394
static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc, Expr *op)
Diagnose if arithmetic on the given ObjC pointer is illegal.
Definition: SemaExpr.cpp:3929
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
Definition: SemaExpr.cpp:3067
void setInitializedFieldInUnion(FieldDecl *FD)
Definition: Expr.h:3864
NamedDecl * getCurFunctionOrMethodDecl()
Definition: Sema.cpp:931
static bool IsLogicOp(BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:6420
QualType getCorrespondingUnsignedType(QualType T) const
StringRef Typo
ExprResult ActOnConstantExpression(ExprResult Res)
Definition: SemaExpr.cpp:13140
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Definition: ASTContext.h:1565
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false)
Instantiate the definition of the given function from its template.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Definition: Expr.cpp:2526
QualType getPointeeType() const
Definition: Type.h:4794
QualType getNonReferenceType() const
Definition: Type.h:5182
ExprResult checkPseudoObjectRValue(Expr *E)
ExprResult IgnoredValueConversions(Expr *E)
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, QualType T1, QualType T2, UnresolvedSetImpl &Functions)
SourceLocation getMemberLoc() const
Definition: Expr.h:2553
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
bool IsOpenMPCapturedVar(VarDecl *VD)
Check if the specified variable is used in a private clause in Checks if the specified variable is us...
Definition: SemaOpenMP.cpp:658
CanQualType ObjCBuiltinBoolTy
Definition: ASTContext.h:836
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
Definition: Sema.h:3145
static bool EvaluatesAsFalse(Sema &S, Expr *E)
Returns true if the given expression can be evaluated as a constant 'false'.
Definition: SemaExpr.cpp:10349
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:279
bool isObjCObjectType() const
Definition: Type.h:5307
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
Not an overloaded operator.
Definition: OperatorKinds.h:23
RecordDecl * TheRecordDecl
The captured record type.
Definition: ScopeInfo.h:584
ExprResult CheckCXXBooleanCondition(Expr *CondExpr)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>. Pointer - pointer requires t...
SourceManager & getSourceManager() const
Definition: Sema.h:1024
bool isXValue() const
Definition: Expr.h:252
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:1708
CanQualType UnknownAnyTy
Definition: ASTContext.h:832
const T * getAs() const
Definition: Type.h:5555
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr * > Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2066
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
Definition: SemaExpr.cpp:4313
bool isAddressSpaceOverlapping(const PointerType &other) const
Returns true if address spaces of pointers overlap. OpenCL v2.0 defines conversion rules for pointers...
Definition: Type.h:2149
QualType getCanonicalType() const
Definition: Type.h:5055
ObjCLiteralKind
Definition: Sema.h:2316
static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Return the resulting type for the conditional operator in OpenCL (aka "ternary selection operator"...
Definition: SemaExpr.cpp:6063
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Definition: SemaExpr.cpp:12056
CanQualType UnsignedLongTy
Definition: ASTContext.h:826
ObjCInterfaceDecl * getInterfaceDecl() const
Definition: Type.h:4835
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1626
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, CastKind &Kind)
Definition: SemaExpr.cpp:5448
static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift)
Definition: SemaExpr.cpp:10401
CanQualType DependentTy
Definition: ASTContext.h:832
void setSubExpr(Expr *E)
Definition: ExprCXX.h:2811
FunctionDecl * getCurFunctionDecl()
Definition: Sema.cpp:919
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Check the validity of a binary arithmetic operation w.r.t. pointer operands.
Definition: SemaExpr.cpp:7588
bool isObjCQualifiedIdType() const
Definition: Type.h:5318
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1266
static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, unsigned Offset)
Definition: SemaExpr.cpp:1485
bool isFunctionType() const
Definition: Type.h:5229
bool isNull() const
Definition: Diagnostic.h:72
Converts from T to _Atomic(T).
DeclContext * getRedeclContext()
Definition: DeclBase.cpp:1466
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1137
CanQualType BoundMemberTy
Definition: ASTContext.h:832
LValueClassification
Definition: Expr.h:255
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:860
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1505
unsigned getAddressSpace() const
Definition: Type.h:313
static Sema::AssignConvertType checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:6682
Converts from a floating complex to an integral complex. _Complex float -> _Complex int...
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:10589
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:1705
std::string getAsString(const LangOptions &LO) const
static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix)
Definition: SemaExpr.cpp:9489
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1328
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:1642
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D)
Definition: SemaExpr.cpp:2744
static bool isInvalid(SourceLocation Loc, bool *Invalid)
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1228
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
A template-id, e.g., f<int>.
Definition: DeclSpec.h:892
llvm::DenseMap< VarDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
Definition: ScopeInfo.h:479
ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, OffsetOfComponent *CompPtr, unsigned NumComponents, SourceLocation RParenLoc)
__builtin_offsetof(type, a.b[123][456].c)
Definition: SemaExpr.cpp:10972
SmallVector< BlockDecl *, 8 > ExprCleanupObjects
Definition: Sema.h:418
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:114
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:316
bool isUsable() const
Definition: Ownership.h:160
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
Definition: SemaExpr.cpp:395
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:474
static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Diagnose bad pointer comparisons.
Definition: SemaExpr.cpp:8163
QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
type checking binary operators (subroutines of CreateBuiltinBinOp).
Definition: SemaExpr.cpp:7219
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1915
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2066
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1080
Expr * getBase() const
Definition: Expr.h:2405
A template argument list.
Definition: DeclTemplate.h:150
static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, Expr *OrArg)
Look for '&' in the left or right hand of a '|' expr.
Definition: SemaExpr.cpp:10393
const DeclContext * getCurObjCLexicalContext() const
Definition: Sema.h:8996
SourceRange getCorrectionRange() const
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:3884
AccessControl getAccessControl() const
Definition: DeclObjC.h:1651
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
Definition: SemaExpr.cpp:3790
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
bool isPODType(ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1922
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Definition: TypeLoc.h:139
bool hasAddressSpace() const
Definition: Type.h:312
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
Definition: SemaExpr.cpp:920
Expression is a Null pointer constant built from a literal zero.
Definition: Expr.h:645
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:1648
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition: Type.cpp:3473
static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E)
Definition: SemaExpr.cpp:13178
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.h:2131
Data structure used to record current or nested expression evaluation contexts.
Definition: Sema.h:796
const Expr * getSubExpr() const
Definition: Expr.h:1638
Describes the sequence of initializations required to initialize a given object or reference with a s...
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable. A pseudo-__strong variable has a ...
Definition: Decl.h:1224
FormatToken * Current
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5096
static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmethic conversion with floating point types. Helper function of UsualArithmeticConversion...
Definition: SemaExpr.cpp:1092
static bool isObjCObjectLiteral(ExprResult &E)
Definition: SemaExpr.cpp:8229
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
Compatible - the types are compatible according to the standard.
Definition: Sema.h:8142
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isObjCObjectPointerType() const
Definition: Type.h:5304
bool isPlaceholderType() const
Definition: Type.h:5400
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.cpp:478
Opcode getOpcode() const
Definition: Expr.h:2961
static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, Expr **RHSExprs)
Definition: SemaExpr.cpp:6381
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Definition: Sema.h:776
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2425
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:481
CanQualType Char16Ty
Definition: ASTContext.h:823
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult{return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2435
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two known vector types?
Definition: SemaExpr.cpp:5420
TryCaptureKind
Definition: Sema.h:3535
bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc)
Checks if the variable must be captured.
Definition: SemaExpr.cpp:13071
bool isObjCSelType(QualType T) const
Definition: ASTContext.h:2133
QualType CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool IsDivide)
Definition: SemaExpr.cpp:7423
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition: Type.h:5502
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:441
Location information for a TemplateArgument.
Definition: TemplateBase.h:364
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
Definition: SemaExpr.cpp:300
qual_range quals() const
Definition: Type.h:4903
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
void addVLATypeCapture(SourceLocation Loc, QualType CaptureType)
Definition: ScopeInfo.h:504
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
LookupResultKind getResultKind() const
Definition: Lookup.h:261
Converts from _Atomic(T) to T.
bool isArrayType() const
Definition: Type.h:5271
const StringRef Input
decl_iterator end()
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all...
Definition: Sema.h:760
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best, bool UserDefinedConversion=false)
Find the best viable function on this overload set, if it exists.
static Expr * BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, QualType Ty, SourceLocation Loc)
Definition: SemaExpr.cpp:3142
Defines the clang::TargetInfo interface.
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion)
type checking for vector binary operators.
Definition: SemaExpr.cpp:7274
Expr * getRHS() const
Definition: Expr.h:2966
void UpdateMarkingForLValueToRValue(Expr *E)
Definition: SemaExpr.cpp:13115
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1290
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3222
bool HasImplicitReturnType
Whether the target type of return statements in this context is deduced (e.g. a lambda or block with ...
Definition: ScopeInfo.h:490
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:271
AvailabilityResult getCurContextAvailability() const
Definition: SemaDecl.cpp:14443
ExprResult ExprError()
Definition: Ownership.h:267
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:2719
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
Definition: SemaExpr.cpp:2536
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
bool isInt() const
Definition: APValue.h:182
CanQualType IntTy
Definition: ASTContext.h:825
bool isRecord() const
Definition: DeclBase.h:1247
static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S)
Definition: SemaExpr.cpp:12508
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:158
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:201
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:404
bool isSet() const
Definition: DeclSpec.h:214
NamedDecl * getMostRecentDecl()
Definition: Decl.h:330
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
Definition: SemaExpr.cpp:11494
unsigned getLength() const
Definition: Token.h:127
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
Definition: Sema.h:766
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
QualType getElementType() const
Definition: Type.h:2434
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool OdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:12179
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5091
void setSubStmt(Stmt *SS)
Definition: Stmt.h:815
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:1528
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1858
static bool HasRedeclarationWithoutAvailabilityInCategory(const Decl *D)
Definition: SemaExpr.cpp:85
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:52
const Expr * getSubExpr() const
Definition: ExprCXX.h:1056
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, Expr *Cpy)
Definition: ScopeInfo.h:496
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false)
void suppressDiagnostics()
Definition: Lookup.h:522
void setLocation(SourceLocation L)
Definition: Token.h:132
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:99
static bool anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned NumArgs, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:2957
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
ASTContext & Context
Definition: Sema.h:295
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2590
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:973
bool isInvalidType() const
Definition: DeclSpec.h:2163
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:2948
ExprResult BuildVectorLiteral(SourceLocation LParenLoc, SourceLocation RParenLoc, Expr *E, TypeSourceInfo *TInfo)
Build an altivec or OpenCL literal.
Definition: SemaExpr.cpp:5562
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConverion=false, bool Complain=false, const SourceRange &OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:411
CanQualType BoolTy
Definition: ASTContext.h:818
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
Definition: SemaExpr.cpp:13551
bool isArithmeticType() const
Definition: Type.cpp:1791
No keyword precedes the qualified type name.
Definition: Type.h:4158
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare)
bool isIncrementDecrementOp() const
Definition: Expr.h:1734
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10511
APSInt & getInt()
Definition: APValue.h:200
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5075
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
Definition: ObjCRuntime.h:220
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1713
CanQualType DoubleTy
Definition: ASTContext.h:828
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:1681
Describes an entity that is being initialized.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:3319
unsigned NumArgs
NumArgs - The number of template arguments.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
bool isObjCIdType() const
Definition: Type.h:4841
static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc)
Definition: SemaExpr.cpp:76
static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if this is a valid OpenCL condition vector.
Definition: SemaExpr.cpp:6015
void setType(QualType newType)
Definition: Decl.h:539
static bool isComparisonOp(Opcode Opc)
Definition: Expr.h:3007
static OpaquePtr getFromOpaquePtr(void *P)
Definition: Ownership.h:85
AssignmentAction
Definition: Sema.h:2111
SourceLocation ColonLoc
Location of ':'.
Definition: OpenMPClause.h:260
void EmitAvailabilityWarning(AvailabilityDiagnostic AD, NamedDecl *D, StringRef Message, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess)
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:877
void WillReplaceSpecifier(bool ForceReplacement)
No in-class initializer.
Definition: Specifiers.h:198
The lookup resulted in an error.
Definition: Sema.h:2637
static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc)
Definition: SemaExpr.cpp:10023
bool isIntegralType(ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1602
static bool IsArithmeticOp(BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:6373
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1012
Preprocessor & getPreprocessor() const
Definition: Sema.h:1025
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Declaration of a template function.
Definition: DeclTemplate.h:821
void clear()
Clears out any current state.
Definition: Lookup.h:494
QualType getBOOLType() const
type of 'BOOL' type.
Definition: ASTContext.h:1551
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant()...
Definition: Expr.h:633
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprObjC.h:516
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1718
bool isOverloadedResult() const
Determines if the results are overloaded.
Definition: Lookup.h:253
Attr - This represents one attribute.
Definition: Attr.h:44
ScalarTypeKind getScalarTypeKind() const
getScalarTypeKind - Given that this is a scalar type, classify it.
Definition: Type.cpp:1806
CastType
Definition: SemaCast.cpp:39
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, bool IsCompAssign=false)
Definition: SemaExpr.cpp:1243
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Definition: SemaExpr.cpp:10853
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
Definition: SemaExpr.cpp:9652
bool isIntegerType() const
Definition: Type.h:5448
bool hasLocalStorage() const
Definition: Decl.h:887
const RecordDecl * getParent() const
Definition: Decl.h:2424
void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope)
Definition: SemaExpr.cpp:11356
static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc)
Check whether we're in an extern inline function and referring to a variable or function with interna...
Definition: SemaExpr.cpp:256
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1049
Expr * IgnoreParens() LLVM_READONLY
Definition: Expr.cpp:2408
CanQualType UnsignedIntTy
Definition: ASTContext.h:826
bool isArrow() const
Definition: ExprObjC.h:508
bool isAddressSpaceSupersetOf(Qualifiers other) const
Returns true if this address space is a superset of the other one. OpenCL v2.0 defines conversion rul...
Definition: Type.h:411
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
bool isPointerType() const
Definition: Type.h:5232
static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp)
Definition: SemaExpr.cpp:9849
Structure used to store a statement, the constant value to which it was evaluated (if any)...
Definition: Decl.h:679
A RAII object to temporarily push a declaration context.
Definition: Sema.h:601
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
Definition: SemaExpr.cpp:4225
OverloadedOperatorKind getOverloadedOperator() const
Definition: Decl.cpp:2916
bool isIncompleteOrObjectType() const
Definition: Type.h:1536
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1439
static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, bool IsReal)
Definition: SemaExpr.cpp:3872