clang  11.0.0git
SemaExprMember.cpp
Go to the documentation of this file.
1 //===--- SemaExprMember.cpp - Semantic Analysis for Expressions -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis member access expressions.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "clang/Sema/Overload.h"
13 #include "clang/AST/ASTLambda.h"
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/ExprObjC.h"
19 #include "clang/Lex/Preprocessor.h"
20 #include "clang/Sema/Lookup.h"
21 #include "clang/Sema/Scope.h"
22 #include "clang/Sema/ScopeInfo.h"
24 
25 using namespace clang;
26 using namespace sema;
27 
29 
30 /// Determines if the given class is provably not derived from all of
31 /// the prospective base classes.
32 static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record,
33  const BaseSet &Bases) {
34  auto BaseIsNotInSet = [&Bases](const CXXRecordDecl *Base) {
35  return !Bases.count(Base->getCanonicalDecl());
36  };
37  return BaseIsNotInSet(Record) && Record->forallBases(BaseIsNotInSet);
38 }
39 
40 enum IMAKind {
41  /// The reference is definitely not an instance member access.
43 
44  /// The reference may be an implicit instance member access.
46 
47  /// The reference may be to an instance member, but it might be invalid if
48  /// so, because the context is not an instance method.
50 
51  /// The reference may be to an instance member, but it is invalid if
52  /// so, because the context is from an unrelated class.
54 
55  /// The reference is definitely an implicit instance member access.
57 
58  /// The reference may be to an unresolved using declaration.
60 
61  /// The reference is a contextually-permitted abstract member reference.
63 
64  /// The reference may be to an unresolved using declaration and the
65  /// context is not an instance method.
67 
68  // The reference refers to a field which is not a member of the containing
69  // class, which is allowed because we're in C++11 mode and the context is
70  // unevaluated.
72 
73  /// All possible referrents are instance members and the current
74  /// context is not an instance method.
76 
77  /// All possible referrents are instance members of an unrelated
78  /// class.
80 };
81 
82 /// The given lookup names class member(s) and is not being used for
83 /// an address-of-member expression. Classify the type of access
84 /// according to whether it's possible that this reference names an
85 /// instance member. This is best-effort in dependent contexts; it is okay to
86 /// conservatively answer "yes", in which case some errors will simply
87 /// not be caught until template-instantiation.
89  const LookupResult &R) {
90  assert(!R.empty() && (*R.begin())->isCXXClassMember());
91 
93 
94  bool isStaticContext = SemaRef.CXXThisTypeOverride.isNull() &&
95  (!isa<CXXMethodDecl>(DC) || cast<CXXMethodDecl>(DC)->isStatic());
96 
97  if (R.isUnresolvableResult())
98  return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved;
99 
100  // Collect all the declaring classes of instance members we find.
101  bool hasNonInstance = false;
102  bool isField = false;
103  BaseSet Classes;
104  for (NamedDecl *D : R) {
105  // Look through any using decls.
106  D = D->getUnderlyingDecl();
107 
108  if (D->isCXXInstanceMember()) {
109  isField |= isa<FieldDecl>(D) || isa<MSPropertyDecl>(D) ||
110  isa<IndirectFieldDecl>(D);
111 
112  CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext());
113  Classes.insert(R->getCanonicalDecl());
114  } else
115  hasNonInstance = true;
116  }
117 
118  // If we didn't find any instance members, it can't be an implicit
119  // member reference.
120  if (Classes.empty())
121  return IMA_Static;
122 
123  // C++11 [expr.prim.general]p12:
124  // An id-expression that denotes a non-static data member or non-static
125  // member function of a class can only be used:
126  // (...)
127  // - if that id-expression denotes a non-static data member and it
128  // appears in an unevaluated operand.
129  //
130  // This rule is specific to C++11. However, we also permit this form
131  // in unevaluated inline assembly operands, like the operand to a SIZE.
132  IMAKind AbstractInstanceResult = IMA_Static; // happens to be 'false'
133  assert(!AbstractInstanceResult);
134  switch (SemaRef.ExprEvalContexts.back().Context) {
137  if (isField && SemaRef.getLangOpts().CPlusPlus11)
138  AbstractInstanceResult = IMA_Field_Uneval_Context;
139  break;
140 
142  AbstractInstanceResult = IMA_Abstract;
143  break;
144 
149  break;
150  }
151 
152  // If the current context is not an instance method, it can't be
153  // an implicit member reference.
154  if (isStaticContext) {
155  if (hasNonInstance)
157 
158  return AbstractInstanceResult ? AbstractInstanceResult
160  }
161 
162  CXXRecordDecl *contextClass;
163  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
164  contextClass = MD->getParent()->getCanonicalDecl();
165  else
166  contextClass = cast<CXXRecordDecl>(DC);
167 
168  // [class.mfct.non-static]p3:
169  // ...is used in the body of a non-static member function of class X,
170  // if name lookup (3.4.1) resolves the name in the id-expression to a
171  // non-static non-type member of some class C [...]
172  // ...if C is not X or a base class of X, the class member access expression
173  // is ill-formed.
174  if (R.getNamingClass() &&
175  contextClass->getCanonicalDecl() !=
176  R.getNamingClass()->getCanonicalDecl()) {
177  // If the naming class is not the current context, this was a qualified
178  // member name lookup, and it's sufficient to check that we have the naming
179  // class as a base class.
180  Classes.clear();
181  Classes.insert(R.getNamingClass()->getCanonicalDecl());
182  }
183 
184  // If we can prove that the current context is unrelated to all the
185  // declaring classes, it can't be an implicit member reference (in
186  // which case it's an error if any of those members are selected).
187  if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes))
188  return hasNonInstance ? IMA_Mixed_Unrelated :
189  AbstractInstanceResult ? AbstractInstanceResult :
191 
192  return (hasNonInstance ? IMA_Mixed : IMA_Instance);
193 }
194 
195 /// Diagnose a reference to a field with no object available.
196 static void diagnoseInstanceReference(Sema &SemaRef,
197  const CXXScopeSpec &SS,
198  NamedDecl *Rep,
199  const DeclarationNameInfo &nameInfo) {
200  SourceLocation Loc = nameInfo.getLoc();
201  SourceRange Range(Loc);
202  if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
203 
204  // Look through using shadow decls and aliases.
205  Rep = Rep->getUnderlyingDecl();
206 
207  DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
208  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
209  CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr;
210  CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
211 
212  bool InStaticMethod = Method && Method->isStatic();
213  bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep);
214 
215  if (IsField && InStaticMethod)
216  // "invalid use of member 'x' in static member function"
217  SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
218  << Range << nameInfo.getName();
219  else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod &&
220  !RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass))
221  // Unqualified lookup in a non-static member function found a member of an
222  // enclosing class.
223  SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
224  << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
225  else if (IsField)
226  SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
227  << nameInfo.getName() << Range;
228  else
229  SemaRef.Diag(Loc, diag::err_member_call_without_object)
230  << Range;
231 }
232 
233 /// Builds an expression which might be an implicit member expression.
236  SourceLocation TemplateKWLoc,
237  LookupResult &R,
238  const TemplateArgumentListInfo *TemplateArgs,
239  const Scope *S) {
240  switch (ClassifyImplicitMemberAccess(*this, R)) {
241  case IMA_Instance:
242  return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true, S);
243 
244  case IMA_Mixed:
245  case IMA_Mixed_Unrelated:
246  case IMA_Unresolved:
247  return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false,
248  S);
249 
251  Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use)
252  << R.getLookupNameInfo().getName();
253  LLVM_FALLTHROUGH;
254  case IMA_Static:
255  case IMA_Abstract:
258  if (TemplateArgs || TemplateKWLoc.isValid())
259  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs);
260  return BuildDeclarationNameExpr(SS, R, false);
261 
263  case IMA_Error_Unrelated:
265  R.getLookupNameInfo());
266  return ExprError();
267  }
268 
269  llvm_unreachable("unexpected instance member access kind");
270 }
271 
272 /// Determine whether input char is from rgba component set.
273 static bool
274 IsRGBA(char c) {
275  switch (c) {
276  case 'r':
277  case 'g':
278  case 'b':
279  case 'a':
280  return true;
281  default:
282  return false;
283  }
284 }
285 
286 // OpenCL v1.1, s6.1.7
287 // The component swizzle length must be in accordance with the acceptable
288 // vector sizes.
289 static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
290 {
291  return (len >= 1 && len <= 4) || len == 8 || len == 16;
292 }
293 
294 /// Check an ext-vector component access expression.
295 ///
296 /// VK should be set in advance to the value kind of the base
297 /// expression.
298 static QualType
300  SourceLocation OpLoc, const IdentifierInfo *CompName,
301  SourceLocation CompLoc) {
302  // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
303  // see FIXME there.
304  //
305  // FIXME: This logic can be greatly simplified by splitting it along
306  // halving/not halving and reworking the component checking.
307  const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
308 
309  // The vector accessor can't exceed the number of elements.
310  const char *compStr = CompName->getNameStart();
311 
312  // This flag determines whether or not the component is one of the four
313  // special names that indicate a subset of exactly half the elements are
314  // to be selected.
315  bool HalvingSwizzle = false;
316 
317  // This flag determines whether or not CompName has an 's' char prefix,
318  // indicating that it is a string of hex values to be used as vector indices.
319  bool HexSwizzle = (*compStr == 's' || *compStr == 'S') && compStr[1];
320 
321  bool HasRepeated = false;
322  bool HasIndex[16] = {};
323 
324  int Idx;
325 
326  // Check that we've found one of the special components, or that the component
327  // names must come from the same set.
328  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
329  !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
330  HalvingSwizzle = true;
331  } else if (!HexSwizzle &&
332  (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
333  bool HasRGBA = IsRGBA(*compStr);
334  do {
335  // Ensure that xyzw and rgba components don't intermingle.
336  if (HasRGBA != IsRGBA(*compStr))
337  break;
338  if (HasIndex[Idx]) HasRepeated = true;
339  HasIndex[Idx] = true;
340  compStr++;
341  } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
342 
343  // Emit a warning if an rgba selector is used earlier than OpenCL 2.2
344  if (HasRGBA || (*compStr && IsRGBA(*compStr))) {
345  if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion < 220) {
346  const char *DiagBegin = HasRGBA ? CompName->getNameStart() : compStr;
347  S.Diag(OpLoc, diag::ext_opencl_ext_vector_type_rgba_selector)
348  << StringRef(DiagBegin, 1)
349  << S.getLangOpts().OpenCLVersion << SourceRange(CompLoc);
350  }
351  }
352  } else {
353  if (HexSwizzle) compStr++;
354  while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
355  if (HasIndex[Idx]) HasRepeated = true;
356  HasIndex[Idx] = true;
357  compStr++;
358  }
359  }
360 
361  if (!HalvingSwizzle && *compStr) {
362  // We didn't get to the end of the string. This means the component names
363  // didn't come from the same set *or* we encountered an illegal name.
364  S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
365  << StringRef(compStr, 1) << SourceRange(CompLoc);
366  return QualType();
367  }
368 
369  // Ensure no component accessor exceeds the width of the vector type it
370  // operates on.
371  if (!HalvingSwizzle) {
372  compStr = CompName->getNameStart();
373 
374  if (HexSwizzle)
375  compStr++;
376 
377  while (*compStr) {
378  if (!vecType->isAccessorWithinNumElements(*compStr++, HexSwizzle)) {
379  S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
380  << baseType << SourceRange(CompLoc);
381  return QualType();
382  }
383  }
384  }
385 
386  // OpenCL mode requires swizzle length to be in accordance with accepted
387  // sizes. Clang however supports arbitrary lengths for other languages.
388  if (S.getLangOpts().OpenCL && !HalvingSwizzle) {
389  unsigned SwizzleLength = CompName->getLength();
390 
391  if (HexSwizzle)
392  SwizzleLength--;
393 
394  if (IsValidOpenCLComponentSwizzleLength(SwizzleLength) == false) {
395  S.Diag(OpLoc, diag::err_opencl_ext_vector_component_invalid_length)
396  << SwizzleLength << SourceRange(CompLoc);
397  return QualType();
398  }
399  }
400 
401  // The component accessor looks fine - now we need to compute the actual type.
402  // The vector type is implied by the component accessor. For example,
403  // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
404  // vec4.s0 is a float, vec4.s23 is a vec3, etc.
405  // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
406  unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2
407  : CompName->getLength();
408  if (HexSwizzle)
409  CompSize--;
410 
411  if (CompSize == 1)
412  return vecType->getElementType();
413 
414  if (HasRepeated) VK = VK_RValue;
415 
416  QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
417  // Now look up the TypeDefDecl from the vector type. Without this,
418  // diagostics look bad. We want extended vector types to appear built-in.
419  for (Sema::ExtVectorDeclsType::iterator
421  E = S.ExtVectorDecls.end();
422  I != E; ++I) {
423  if ((*I)->getUnderlyingType() == VT)
424  return S.Context.getTypedefType(*I);
425  }
426 
427  return VT; // should never get here (a typedef type should always be found).
428 }
429 
431  IdentifierInfo *Member,
432  const Selector &Sel,
433  ASTContext &Context) {
434  if (Member)
435  if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(
437  return PD;
438  if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
439  return OMD;
440 
441  for (const auto *I : PDecl->protocols()) {
442  if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel,
443  Context))
444  return D;
445  }
446  return nullptr;
447 }
448 
450  IdentifierInfo *Member,
451  const Selector &Sel,
452  ASTContext &Context) {
453  // Check protocols on qualified interfaces.
454  Decl *GDecl = nullptr;
455  for (const auto *I : QIdTy->quals()) {
456  if (Member)
457  if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(
459  GDecl = PD;
460  break;
461  }
462  // Also must look for a getter or setter name which uses property syntax.
463  if (ObjCMethodDecl *OMD = I->getInstanceMethod(Sel)) {
464  GDecl = OMD;
465  break;
466  }
467  }
468  if (!GDecl) {
469  for (const auto *I : QIdTy->quals()) {
470  // Search in the protocol-qualifier list of current protocol.
471  GDecl = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, Context);
472  if (GDecl)
473  return GDecl;
474  }
475  }
476  return GDecl;
477 }
478 
481  bool IsArrow, SourceLocation OpLoc,
482  const CXXScopeSpec &SS,
483  SourceLocation TemplateKWLoc,
484  NamedDecl *FirstQualifierInScope,
485  const DeclarationNameInfo &NameInfo,
486  const TemplateArgumentListInfo *TemplateArgs) {
487  // Even in dependent contexts, try to diagnose base expressions with
488  // obviously wrong types, e.g.:
489  //
490  // T* t;
491  // t.f;
492  //
493  // In Obj-C++, however, the above expression is valid, since it could be
494  // accessing the 'f' property if T is an Obj-C interface. The extra check
495  // allows this, while still reporting an error if T is a struct pointer.
496  if (!IsArrow) {
497  const PointerType *PT = BaseType->getAs<PointerType>();
498  if (PT && (!getLangOpts().ObjC ||
499  PT->getPointeeType()->isRecordType())) {
500  assert(BaseExpr && "cannot happen with implicit member accesses");
501  Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
502  << BaseType << BaseExpr->getSourceRange() << NameInfo.getSourceRange();
503  return ExprError();
504  }
505  }
506 
507  assert(BaseType->isDependentType() ||
508  NameInfo.getName().isDependentName() ||
509  isDependentScopeSpecifier(SS));
510 
511  // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
512  // must have pointer type, and the accessed type is the pointee.
514  Context, BaseExpr, BaseType, IsArrow, OpLoc,
515  SS.getWithLocInContext(Context), TemplateKWLoc, FirstQualifierInScope,
516  NameInfo, TemplateArgs);
517 }
518 
519 /// We know that the given qualified member reference points only to
520 /// declarations which do not belong to the static type of the base
521 /// expression. Diagnose the problem.
523  Expr *BaseExpr,
524  QualType BaseType,
525  const CXXScopeSpec &SS,
526  NamedDecl *rep,
527  const DeclarationNameInfo &nameInfo) {
528  // If this is an implicit member access, use a different set of
529  // diagnostics.
530  if (!BaseExpr)
531  return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
532 
533  SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
534  << SS.getRange() << rep << BaseType;
535 }
536 
537 // Check whether the declarations we found through a nested-name
538 // specifier in a member expression are actually members of the base
539 // type. The restriction here is:
540 //
541 // C++ [expr.ref]p2:
542 // ... In these cases, the id-expression shall name a
543 // member of the class or of one of its base classes.
544 //
545 // So it's perfectly legitimate for the nested-name specifier to name
546 // an unrelated class, and for us to find an overload set including
547 // decls from classes which are not superclasses, as long as the decl
548 // we actually pick through overload resolution is from a superclass.
550  QualType BaseType,
551  const CXXScopeSpec &SS,
552  const LookupResult &R) {
553  CXXRecordDecl *BaseRecord =
554  cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType));
555  if (!BaseRecord) {
556  // We can't check this yet because the base type is still
557  // dependent.
558  assert(BaseType->isDependentType());
559  return false;
560  }
561 
562  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
563  // If this is an implicit member reference and we find a
564  // non-instance member, it's not an error.
565  if (!BaseExpr && !(*I)->isCXXInstanceMember())
566  return false;
567 
568  // Note that we use the DC of the decl, not the underlying decl.
569  DeclContext *DC = (*I)->getDeclContext();
570  while (DC->isTransparentContext())
571  DC = DC->getParent();
572 
573  if (!DC->isRecord())
574  continue;
575 
576  CXXRecordDecl *MemberRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
577  if (BaseRecord->getCanonicalDecl() == MemberRecord ||
578  !BaseRecord->isProvablyNotDerivedFrom(MemberRecord))
579  return false;
580  }
581 
582  DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS,
584  R.getLookupNameInfo());
585  return true;
586 }
587 
588 namespace {
589 
590 // Callback to only accept typo corrections that are either a ValueDecl or a
591 // FunctionTemplateDecl and are declared in the current record or, for a C++
592 // classes, one of its base classes.
593 class RecordMemberExprValidatorCCC final : public CorrectionCandidateCallback {
594 public:
595  explicit RecordMemberExprValidatorCCC(const RecordType *RTy)
596  : Record(RTy->getDecl()) {
597  // Don't add bare keywords to the consumer since they will always fail
598  // validation by virtue of not being associated with any decls.
599  WantTypeSpecifiers = false;
600  WantExpressionKeywords = false;
601  WantCXXNamedCasts = false;
602  WantFunctionLikeCasts = false;
603  WantRemainingKeywords = false;
604  }
605 
606  bool ValidateCandidate(const TypoCorrection &candidate) override {
607  NamedDecl *ND = candidate.getCorrectionDecl();
608  // Don't accept candidates that cannot be member functions, constants,
609  // variables, or templates.
610  if (!ND || !(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)))
611  return false;
612 
613  // Accept candidates that occur in the current record.
614  if (Record->containsDecl(ND))
615  return true;
616 
617  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) {
618  // Accept candidates that occur in any of the current class' base classes.
619  for (const auto &BS : RD->bases()) {
620  if (const RecordType *BSTy =
621  dyn_cast_or_null<RecordType>(BS.getType().getTypePtrOrNull())) {
622  if (BSTy->getDecl()->containsDecl(ND))
623  return true;
624  }
625  }
626  }
627 
628  return false;
629  }
630 
631  std::unique_ptr<CorrectionCandidateCallback> clone() override {
632  return std::make_unique<RecordMemberExprValidatorCCC>(*this);
633  }
634 
635 private:
636  const RecordDecl *const Record;
637 };
638 
639 }
640 
641 static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
642  Expr *BaseExpr,
643  const RecordType *RTy,
644  SourceLocation OpLoc, bool IsArrow,
645  CXXScopeSpec &SS, bool HasTemplateArgs,
646  SourceLocation TemplateKWLoc,
647  TypoExpr *&TE) {
648  SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange();
649  RecordDecl *RDecl = RTy->getDecl();
650  if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
651  SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
652  diag::err_typecheck_incomplete_tag,
653  BaseRange))
654  return true;
655 
656  if (HasTemplateArgs || TemplateKWLoc.isValid()) {
657  // LookupTemplateName doesn't expect these both to exist simultaneously.
658  QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
659 
660  bool MOUS;
661  return SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS,
662  TemplateKWLoc);
663  }
664 
665  DeclContext *DC = RDecl;
666  if (SS.isSet()) {
667  // If the member name was a qualified-id, look into the
668  // nested-name-specifier.
669  DC = SemaRef.computeDeclContext(SS, false);
670 
671  if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
672  SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
673  << SS.getRange() << DC;
674  return true;
675  }
676 
677  assert(DC && "Cannot handle non-computable dependent contexts in lookup");
678 
679  if (!isa<TypeDecl>(DC)) {
680  SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
681  << DC << SS.getRange();
682  return true;
683  }
684  }
685 
686  // The record definition is complete, now look up the member.
687  SemaRef.LookupQualifiedName(R, DC, SS);
688 
689  if (!R.empty())
690  return false;
691 
692  DeclarationName Typo = R.getLookupName();
693  SourceLocation TypoLoc = R.getNameLoc();
694 
695  struct QueryState {
696  Sema &SemaRef;
697  DeclarationNameInfo NameInfo;
698  Sema::LookupNameKind LookupKind;
700  };
701  QueryState Q = {R.getSema(), R.getLookupNameInfo(), R.getLookupKind(),
702  R.redeclarationKind()};
703  RecordMemberExprValidatorCCC CCC(RTy);
704  TE = SemaRef.CorrectTypoDelayed(
705  R.getLookupNameInfo(), R.getLookupKind(), nullptr, &SS, CCC,
706  [=, &SemaRef](const TypoCorrection &TC) {
707  if (TC) {
708  assert(!TC.isKeyword() &&
709  "Got a keyword as a correction for a member!");
710  bool DroppedSpecifier =
711  TC.WillReplaceSpecifier() &&
712  Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts());
713  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
714  << Typo << DC << DroppedSpecifier
715  << SS.getRange());
716  } else {
717  SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange;
718  }
719  },
720  [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
721  LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
722  R.clear(); // Ensure there's no decls lingering in the shared state.
724  R.setLookupName(TC.getCorrection());
725  for (NamedDecl *ND : TC)
726  R.addDecl(ND);
727  R.resolveKind();
728  return SemaRef.BuildMemberReferenceExpr(
729  BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(),
730  nullptr, R, nullptr, nullptr);
731  },
733 
734  return false;
735 }
736 
738  ExprResult &BaseExpr, bool &IsArrow,
739  SourceLocation OpLoc, CXXScopeSpec &SS,
740  Decl *ObjCImpDecl, bool HasTemplateArgs,
741  SourceLocation TemplateKWLoc);
742 
745  SourceLocation OpLoc, bool IsArrow,
746  CXXScopeSpec &SS,
747  SourceLocation TemplateKWLoc,
748  NamedDecl *FirstQualifierInScope,
749  const DeclarationNameInfo &NameInfo,
750  const TemplateArgumentListInfo *TemplateArgs,
751  const Scope *S,
752  ActOnMemberAccessExtraArgs *ExtraArgs) {
753  if (BaseType->isDependentType() ||
754  (SS.isSet() && isDependentScopeSpecifier(SS)))
755  return ActOnDependentMemberExpr(Base, BaseType,
756  IsArrow, OpLoc,
757  SS, TemplateKWLoc, FirstQualifierInScope,
758  NameInfo, TemplateArgs);
759 
760  LookupResult R(*this, NameInfo, LookupMemberName);
761 
762  // Implicit member accesses.
763  if (!Base) {
764  TypoExpr *TE = nullptr;
765  QualType RecordTy = BaseType;
766  if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType();
768  *this, R, nullptr, RecordTy->getAs<RecordType>(), OpLoc, IsArrow,
769  SS, TemplateArgs != nullptr, TemplateKWLoc, TE))
770  return ExprError();
771  if (TE)
772  return TE;
773 
774  // Explicit member accesses.
775  } else {
776  ExprResult BaseResult = Base;
777  ExprResult Result =
778  LookupMemberExpr(*this, R, BaseResult, IsArrow, OpLoc, SS,
779  ExtraArgs ? ExtraArgs->ObjCImpDecl : nullptr,
780  TemplateArgs != nullptr, TemplateKWLoc);
781 
782  if (BaseResult.isInvalid())
783  return ExprError();
784  Base = BaseResult.get();
785 
786  if (Result.isInvalid())
787  return ExprError();
788 
789  if (Result.get())
790  return Result;
791 
792  // LookupMemberExpr can modify Base, and thus change BaseType
793  BaseType = Base->getType();
794  }
795 
796  return BuildMemberReferenceExpr(Base, BaseType,
797  OpLoc, IsArrow, SS, TemplateKWLoc,
798  FirstQualifierInScope, R, TemplateArgs, S,
799  false, ExtraArgs);
800 }
801 
804  SourceLocation loc,
805  IndirectFieldDecl *indirectField,
806  DeclAccessPair foundDecl,
807  Expr *baseObjectExpr,
808  SourceLocation opLoc) {
809  // First, build the expression that refers to the base object.
810 
811  // Case 1: the base of the indirect field is not a field.
812  VarDecl *baseVariable = indirectField->getVarDecl();
813  CXXScopeSpec EmptySS;
814  if (baseVariable) {
815  assert(baseVariable->getType()->isRecordType());
816 
817  // In principle we could have a member access expression that
818  // accesses an anonymous struct/union that's a static member of
819  // the base object's class. However, under the current standard,
820  // static data members cannot be anonymous structs or unions.
821  // Supporting this is as easy as building a MemberExpr here.
822  assert(!baseObjectExpr && "anonymous struct/union is static data member?");
823 
824  DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
825 
826  ExprResult result
827  = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
828  if (result.isInvalid()) return ExprError();
829 
830  baseObjectExpr = result.get();
831  }
832 
833  assert((baseVariable || baseObjectExpr) &&
834  "referencing anonymous struct/union without a base variable or "
835  "expression");
836 
837  // Build the implicit member references to the field of the
838  // anonymous struct/union.
839  Expr *result = baseObjectExpr;
841  FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
842 
843  // Case 2: the base of the indirect field is a field and the user
844  // wrote a member expression.
845  if (!baseVariable) {
846  FieldDecl *field = cast<FieldDecl>(*FI);
847 
848  bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
849 
850  // Make a nameInfo that properly uses the anonymous name.
851  DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
852 
853  // Build the first member access in the chain with full information.
854  result =
855  BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
856  SS, field, foundDecl, memberNameInfo)
857  .get();
858  if (!result)
859  return ExprError();
860  }
861 
862  // In all cases, we should now skip the first declaration in the chain.
863  ++FI;
864 
865  while (FI != FEnd) {
866  FieldDecl *field = cast<FieldDecl>(*FI++);
867 
868  // FIXME: these are somewhat meaningless
869  DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
870  DeclAccessPair fakeFoundDecl =
871  DeclAccessPair::make(field, field->getAccess());
872 
873  result =
874  BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
875  (FI == FEnd ? SS : EmptySS), field,
876  fakeFoundDecl, memberNameInfo)
877  .get();
878  }
879 
880  return result;
881 }
882 
883 static ExprResult
884 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
885  const CXXScopeSpec &SS,
886  MSPropertyDecl *PD,
887  const DeclarationNameInfo &NameInfo) {
888  // Property names are always simple identifiers and therefore never
889  // require any interesting additional storage.
890  return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow,
893  NameInfo.getLoc());
894 }
895 
897  Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS,
898  SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
899  bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
901  const TemplateArgumentListInfo *TemplateArgs) {
903  SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc();
904  return BuildMemberExpr(Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member,
905  FoundDecl, HadMultipleCandidates, MemberNameInfo, Ty,
906  VK, OK, TemplateArgs);
907 }
908 
910  Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS,
911  SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
912  bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
914  const TemplateArgumentListInfo *TemplateArgs) {
915  assert((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue");
916  MemberExpr *E =
917  MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc,
918  Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty,
919  VK, OK, getNonOdrUseReasonInCurrentContext(Member));
920  E->setHadMultipleCandidates(HadMultipleCandidates);
921  MarkMemberReferenced(E);
922 
923  // C++ [except.spec]p17:
924  // An exception-specification is considered to be needed when:
925  // - in an expression the function is the unique lookup result or the
926  // selected member of a set of overloaded functions
927  if (auto *FPT = Ty->getAs<FunctionProtoType>()) {
928  if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
929  if (auto *NewFPT = ResolveExceptionSpec(MemberNameInfo.getLoc(), FPT))
930  E->setType(Context.getQualifiedType(NewFPT, Ty.getQualifiers()));
931  }
932  }
933 
934  return E;
935 }
936 
937 /// Determine if the given scope is within a function-try-block handler.
938 static bool IsInFnTryBlockHandler(const Scope *S) {
939  // Walk the scope stack until finding a FnTryCatchScope, or leave the
940  // function scope. If a FnTryCatchScope is found, check whether the TryScope
941  // flag is set. If it is not, it's a function-try-block handler.
942  for (; S != S->getFnParent(); S = S->getParent()) {
943  if (S->getFlags() & Scope::FnTryCatchScope)
944  return (S->getFlags() & Scope::TryScope) != Scope::TryScope;
945  }
946  return false;
947 }
948 
949 VarDecl *
951  const TemplateArgumentListInfo *TemplateArgs,
952  const DeclarationNameInfo &MemberNameInfo,
953  SourceLocation TemplateKWLoc) {
954  if (!TemplateArgs) {
955  diagnoseMissingTemplateArguments(TemplateName(VarTempl),
956  MemberNameInfo.getBeginLoc());
957  return nullptr;
958  }
959 
960  DeclResult VDecl = CheckVarTemplateId(VarTempl, TemplateKWLoc,
961  MemberNameInfo.getLoc(), *TemplateArgs);
962  if (VDecl.isInvalid())
963  return nullptr;
964  VarDecl *Var = cast<VarDecl>(VDecl.get());
965  if (!Var->getTemplateSpecializationKind())
967  MemberNameInfo.getLoc());
968  return Var;
969 }
970 
973  SourceLocation OpLoc, bool IsArrow,
974  const CXXScopeSpec &SS,
975  SourceLocation TemplateKWLoc,
976  NamedDecl *FirstQualifierInScope,
977  LookupResult &R,
978  const TemplateArgumentListInfo *TemplateArgs,
979  const Scope *S,
980  bool SuppressQualifierCheck,
981  ActOnMemberAccessExtraArgs *ExtraArgs) {
982  QualType BaseType = BaseExprType;
983  if (IsArrow) {
984  assert(BaseType->isPointerType());
985  BaseType = BaseType->castAs<PointerType>()->getPointeeType();
986  }
987  R.setBaseObjectType(BaseType);
988 
989  // C++1z [expr.ref]p2:
990  // For the first option (dot) the first expression shall be a glvalue [...]
991  if (!IsArrow && BaseExpr && BaseExpr->isRValue()) {
992  ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
993  if (Converted.isInvalid())
994  return ExprError();
995  BaseExpr = Converted.get();
996  }
997 
998 
999  const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
1000  DeclarationName MemberName = MemberNameInfo.getName();
1001  SourceLocation MemberLoc = MemberNameInfo.getLoc();
1002 
1003  if (R.isAmbiguous())
1004  return ExprError();
1005 
1006  // [except.handle]p10: Referring to any non-static member or base class of an
1007  // object in the handler for a function-try-block of a constructor or
1008  // destructor for that object results in undefined behavior.
1009  const auto *FD = getCurFunctionDecl();
1010  if (S && BaseExpr && FD &&
1011  (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) &&
1012  isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) &&
1014  Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr)
1015  << isa<CXXDestructorDecl>(FD);
1016 
1017  if (R.empty()) {
1018  // Rederive where we looked up.
1019  DeclContext *DC = (SS.isSet()
1020  ? computeDeclContext(SS, false)
1021  : BaseType->castAs<RecordType>()->getDecl());
1022 
1023  if (ExtraArgs) {
1024  ExprResult RetryExpr;
1025  if (!IsArrow && BaseExpr) {
1026  SFINAETrap Trap(*this, true);
1027  ParsedType ObjectType;
1028  bool MayBePseudoDestructor = false;
1029  RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
1030  OpLoc, tok::arrow, ObjectType,
1031  MayBePseudoDestructor);
1032  if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
1033  CXXScopeSpec TempSS(SS);
1034  RetryExpr = ActOnMemberAccessExpr(
1035  ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
1036  TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl);
1037  }
1038  if (Trap.hasErrorOccurred())
1039  RetryExpr = ExprError();
1040  }
1041  if (RetryExpr.isUsable()) {
1042  Diag(OpLoc, diag::err_no_member_overloaded_arrow)
1043  << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
1044  return RetryExpr;
1045  }
1046  }
1047 
1048  Diag(R.getNameLoc(), diag::err_no_member)
1049  << MemberName << DC
1050  << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
1051  return ExprError();
1052  }
1053 
1054  // Diagnose lookups that find only declarations from a non-base
1055  // type. This is possible for either qualified lookups (which may
1056  // have been qualified with an unrelated type) or implicit member
1057  // expressions (which were found with unqualified lookup and thus
1058  // may have come from an enclosing scope). Note that it's okay for
1059  // lookup to find declarations from a non-base type as long as those
1060  // aren't the ones picked by overload resolution.
1061  if ((SS.isSet() || !BaseExpr ||
1062  (isa<CXXThisExpr>(BaseExpr) &&
1063  cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
1064  !SuppressQualifierCheck &&
1065  CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
1066  return ExprError();
1067 
1068  // Construct an unresolved result if we in fact got an unresolved
1069  // result.
1070  if (R.isOverloadedResult() || R.isUnresolvableResult()) {
1071  // Suppress any lookup-related diagnostics; we'll do these when we
1072  // pick a member.
1073  R.suppressDiagnostics();
1074 
1075  UnresolvedMemberExpr *MemExpr
1077  BaseExpr, BaseExprType,
1078  IsArrow, OpLoc,
1079  SS.getWithLocInContext(Context),
1080  TemplateKWLoc, MemberNameInfo,
1081  TemplateArgs, R.begin(), R.end());
1082 
1083  return MemExpr;
1084  }
1085 
1086  assert(R.isSingleResult());
1087  DeclAccessPair FoundDecl = R.begin().getPair();
1088  NamedDecl *MemberDecl = R.getFoundDecl();
1089 
1090  // FIXME: diagnose the presence of template arguments now.
1091 
1092  // If the decl being referenced had an error, return an error for this
1093  // sub-expr without emitting another error, in order to avoid cascading
1094  // error cases.
1095  if (MemberDecl->isInvalidDecl())
1096  return ExprError();
1097 
1098  // Handle the implicit-member-access case.
1099  if (!BaseExpr) {
1100  // If this is not an instance member, convert to a non-member access.
1101  if (!MemberDecl->isCXXInstanceMember()) {
1102  // If this is a variable template, get the instantiated variable
1103  // declaration corresponding to the supplied template arguments
1104  // (while emitting diagnostics as necessary) that will be referenced
1105  // by this expression.
1106  assert((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&
1107  "How did we get template arguments here sans a variable template");
1108  if (isa<VarTemplateDecl>(MemberDecl)) {
1109  MemberDecl = getVarTemplateSpecialization(
1110  cast<VarTemplateDecl>(MemberDecl), TemplateArgs,
1111  R.getLookupNameInfo(), TemplateKWLoc);
1112  if (!MemberDecl)
1113  return ExprError();
1114  }
1115  return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl,
1116  FoundDecl, TemplateArgs);
1117  }
1118  SourceLocation Loc = R.getNameLoc();
1119  if (SS.getRange().isValid())
1120  Loc = SS.getRange().getBegin();
1121  BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
1122  }
1123 
1124  // Check the use of this member.
1125  if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
1126  return ExprError();
1127 
1128  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1129  return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
1130  MemberNameInfo);
1131 
1132  if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1133  return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1134  MemberNameInfo);
1135 
1136  if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1137  // We may have found a field within an anonymous union or struct
1138  // (C++ [class.union]).
1139  return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1140  FoundDecl, BaseExpr,
1141  OpLoc);
1142 
1143  if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1144  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
1145  FoundDecl, /*HadMultipleCandidates=*/false,
1146  MemberNameInfo, Var->getType().getNonReferenceType(),
1148  }
1149 
1150  if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1151  ExprValueKind valueKind;
1152  QualType type;
1153  if (MemberFn->isInstance()) {
1154  valueKind = VK_RValue;
1155  type = Context.BoundMemberTy;
1156  } else {
1157  valueKind = VK_LValue;
1158  type = MemberFn->getType();
1159  }
1160 
1161  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
1162  MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
1163  MemberNameInfo, type, valueKind, OK_Ordinary);
1164  }
1165  assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
1166 
1167  if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1168  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
1169  FoundDecl, /*HadMultipleCandidates=*/false,
1170  MemberNameInfo, Enum->getType(), VK_RValue,
1171  OK_Ordinary);
1172  }
1173  if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
1174  if (VarDecl *Var = getVarTemplateSpecialization(
1175  VarTempl, TemplateArgs, MemberNameInfo, TemplateKWLoc))
1176  return BuildMemberExpr(
1177  BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
1178  /*HadMultipleCandidates=*/false, MemberNameInfo,
1179  Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary);
1180  return ExprError();
1181  }
1182 
1183  // We found something that we didn't expect. Complain.
1184  if (isa<TypeDecl>(MemberDecl))
1185  Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1186  << MemberName << BaseType << int(IsArrow);
1187  else
1188  Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1189  << MemberName << BaseType << int(IsArrow);
1190 
1191  Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1192  << MemberName;
1193  R.suppressDiagnostics();
1194  return ExprError();
1195 }
1196 
1197 /// Given that normal member access failed on the given expression,
1198 /// and given that the expression's type involves builtin-id or
1199 /// builtin-Class, decide whether substituting in the redefinition
1200 /// types would be profitable. The redefinition type is whatever
1201 /// this translation unit tried to typedef to id/Class; we store
1202 /// it to the side and then re-use it in places like this.
1204  const ObjCObjectPointerType *opty
1205  = base.get()->getType()->getAs<ObjCObjectPointerType>();
1206  if (!opty) return false;
1207 
1208  const ObjCObjectType *ty = opty->getObjectType();
1209 
1210  QualType redef;
1211  if (ty->isObjCId()) {
1212  redef = S.Context.getObjCIdRedefinitionType();
1213  } else if (ty->isObjCClass()) {
1215  } else {
1216  return false;
1217  }
1218 
1219  // Do the substitution as long as the redefinition type isn't just a
1220  // possibly-qualified pointer to builtin-id or builtin-Class again.
1221  opty = redef->getAs<ObjCObjectPointerType>();
1222  if (opty && !opty->getObjectType()->getInterface())
1223  return false;
1224 
1225  base = S.ImpCastExprToType(base.get(), redef, CK_BitCast);
1226  return true;
1227 }
1228 
1229 static bool isRecordType(QualType T) {
1230  return T->isRecordType();
1231 }
1233  if (const PointerType *PT = T->getAs<PointerType>())
1234  return PT->getPointeeType()->isRecordType();
1235  return false;
1236 }
1237 
1238 /// Perform conversions on the LHS of a member access expression.
1239 ExprResult
1241  if (IsArrow && !Base->getType()->isFunctionType())
1242  return DefaultFunctionArrayLvalueConversion(Base);
1243 
1244  return CheckPlaceholderExpr(Base);
1245 }
1246 
1247 /// Look up the given member of the given non-type-dependent
1248 /// expression. This can return in one of two ways:
1249 /// * If it returns a sentinel null-but-valid result, the caller will
1250 /// assume that lookup was performed and the results written into
1251 /// the provided structure. It will take over from there.
1252 /// * Otherwise, the returned expression will be produced in place of
1253 /// an ordinary member expression.
1254 ///
1255 /// The ObjCImpDecl bit is a gross hack that will need to be properly
1256 /// fixed for ObjC++.
1258  ExprResult &BaseExpr, bool &IsArrow,
1259  SourceLocation OpLoc, CXXScopeSpec &SS,
1260  Decl *ObjCImpDecl, bool HasTemplateArgs,
1261  SourceLocation TemplateKWLoc) {
1262  assert(BaseExpr.get() && "no base expression");
1263 
1264  // Perform default conversions.
1265  BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow);
1266  if (BaseExpr.isInvalid())
1267  return ExprError();
1268 
1269  QualType BaseType = BaseExpr.get()->getType();
1270  assert(!BaseType->isDependentType());
1271 
1272  DeclarationName MemberName = R.getLookupName();
1273  SourceLocation MemberLoc = R.getNameLoc();
1274 
1275  // For later type-checking purposes, turn arrow accesses into dot
1276  // accesses. The only access type we support that doesn't follow
1277  // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1278  // and those never use arrows, so this is unaffected.
1279  if (IsArrow) {
1280  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1281  BaseType = Ptr->getPointeeType();
1282  else if (const ObjCObjectPointerType *Ptr
1283  = BaseType->getAs<ObjCObjectPointerType>())
1284  BaseType = Ptr->getPointeeType();
1285  else if (BaseType->isRecordType()) {
1286  // Recover from arrow accesses to records, e.g.:
1287  // struct MyRecord foo;
1288  // foo->bar
1289  // This is actually well-formed in C++ if MyRecord has an
1290  // overloaded operator->, but that should have been dealt with
1291  // by now--or a diagnostic message already issued if a problem
1292  // was encountered while looking for the overloaded operator->.
1293  if (!S.getLangOpts().CPlusPlus) {
1294  S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1295  << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1296  << FixItHint::CreateReplacement(OpLoc, ".");
1297  }
1298  IsArrow = false;
1299  } else if (BaseType->isFunctionType()) {
1300  goto fail;
1301  } else {
1302  S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1303  << BaseType << BaseExpr.get()->getSourceRange();
1304  return ExprError();
1305  }
1306  }
1307 
1308  // Handle field access to simple records.
1309  if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
1310  TypoExpr *TE = nullptr;
1311  if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy, OpLoc, IsArrow, SS,
1312  HasTemplateArgs, TemplateKWLoc, TE))
1313  return ExprError();
1314 
1315  // Returning valid-but-null is how we indicate to the caller that
1316  // the lookup result was filled in. If typo correction was attempted and
1317  // failed, the lookup result will have been cleared--that combined with the
1318  // valid-but-null ExprResult will trigger the appropriate diagnostics.
1319  return ExprResult(TE);
1320  }
1321 
1322  // Handle ivar access to Objective-C objects.
1323  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
1324  if (!SS.isEmpty() && !SS.isInvalid()) {
1325  S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1326  << 1 << SS.getScopeRep()
1328  SS.clear();
1329  }
1330 
1331  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1332 
1333  // There are three cases for the base type:
1334  // - builtin id (qualified or unqualified)
1335  // - builtin Class (qualified or unqualified)
1336  // - an interface
1337  ObjCInterfaceDecl *IDecl = OTy->getInterface();
1338  if (!IDecl) {
1339  if (S.getLangOpts().ObjCAutoRefCount &&
1340  (OTy->isObjCId() || OTy->isObjCClass()))
1341  goto fail;
1342  // There's an implicit 'isa' ivar on all objects.
1343  // But we only actually find it this way on objects of type 'id',
1344  // apparently.
1345  if (OTy->isObjCId() && Member->isStr("isa"))
1346  return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc,
1347  OpLoc, S.Context.getObjCClassType());
1348  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1349  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1350  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1351  goto fail;
1352  }
1353 
1354  if (S.RequireCompleteType(OpLoc, BaseType,
1355  diag::err_typecheck_incomplete_tag,
1356  BaseExpr.get()))
1357  return ExprError();
1358 
1359  ObjCInterfaceDecl *ClassDeclared = nullptr;
1360  ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1361 
1362  if (!IV) {
1363  // Attempt to correct for typos in ivar names.
1364  DeclFilterCCC<ObjCIvarDecl> Validator{};
1365  Validator.IsObjCIvarLookup = IsArrow;
1366  if (TypoCorrection Corrected = S.CorrectTypo(
1367  R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
1368  Validator, Sema::CTK_ErrorRecovery, IDecl)) {
1369  IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1370  S.diagnoseTypo(
1371  Corrected,
1372  S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1373  << IDecl->getDeclName() << MemberName);
1374 
1375  // Figure out the class that declares the ivar.
1376  assert(!ClassDeclared);
1377 
1378  Decl *D = cast<Decl>(IV->getDeclContext());
1379  if (auto *Category = dyn_cast<ObjCCategoryDecl>(D))
1380  D = Category->getClassInterface();
1381 
1382  if (auto *Implementation = dyn_cast<ObjCImplementationDecl>(D))
1383  ClassDeclared = Implementation->getClassInterface();
1384  else if (auto *Interface = dyn_cast<ObjCInterfaceDecl>(D))
1385  ClassDeclared = Interface;
1386 
1387  assert(ClassDeclared && "cannot query interface");
1388  } else {
1389  if (IsArrow &&
1390  IDecl->FindPropertyDeclaration(
1392  S.Diag(MemberLoc, diag::err_property_found_suggest)
1393  << Member << BaseExpr.get()->getType()
1394  << FixItHint::CreateReplacement(OpLoc, ".");
1395  return ExprError();
1396  }
1397 
1398  S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1399  << IDecl->getDeclName() << MemberName
1400  << BaseExpr.get()->getSourceRange();
1401  return ExprError();
1402  }
1403  }
1404 
1405  assert(ClassDeclared);
1406 
1407  // If the decl being referenced had an error, return an error for this
1408  // sub-expr without emitting another error, in order to avoid cascading
1409  // error cases.
1410  if (IV->isInvalidDecl())
1411  return ExprError();
1412 
1413  // Check whether we can reference this field.
1414  if (S.DiagnoseUseOfDecl(IV, MemberLoc))
1415  return ExprError();
1416  if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1418  ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1419  if (ObjCMethodDecl *MD = S.getCurMethodDecl())
1420  ClassOfMethodDecl = MD->getClassInterface();
1421  else if (ObjCImpDecl && S.getCurFunctionDecl()) {
1422  // Case of a c-function declared inside an objc implementation.
1423  // FIXME: For a c-style function nested inside an objc implementation
1424  // class, there is no implementation context available, so we pass
1425  // down the context as argument to this routine. Ideally, this context
1426  // need be passed down in the AST node and somehow calculated from the
1427  // AST for a function decl.
1428  if (ObjCImplementationDecl *IMPD =
1429  dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1430  ClassOfMethodDecl = IMPD->getClassInterface();
1431  else if (ObjCCategoryImplDecl* CatImplClass =
1432  dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1433  ClassOfMethodDecl = CatImplClass->getClassInterface();
1434  }
1435  if (!S.getLangOpts().DebuggerSupport) {
1436  if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1437  if (!declaresSameEntity(ClassDeclared, IDecl) ||
1438  !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1439  S.Diag(MemberLoc, diag::err_private_ivar_access)
1440  << IV->getDeclName();
1441  } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1442  // @protected
1443  S.Diag(MemberLoc, diag::err_protected_ivar_access)
1444  << IV->getDeclName();
1445  }
1446  }
1447  bool warn = true;
1448  if (S.getLangOpts().ObjCWeak) {
1449  Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1450  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1451  if (UO->getOpcode() == UO_Deref)
1452  BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1453 
1454  if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1455  if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1456  S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);
1457  warn = false;
1458  }
1459  }
1460  if (warn) {
1461  if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
1462  ObjCMethodFamily MF = MD->getMethodFamily();
1463  warn = (MF != OMF_init && MF != OMF_dealloc &&
1464  MF != OMF_finalize &&
1465  !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1466  }
1467  if (warn)
1468  S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1469  }
1470 
1471  ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
1472  IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
1473  IsArrow);
1474 
1475  if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1476  if (!S.isUnevaluatedContext() &&
1477  !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
1478  S.getCurFunction()->recordUseOfWeak(Result);
1479  }
1480 
1481  return Result;
1482  }
1483 
1484  // Objective-C property access.
1485  const ObjCObjectPointerType *OPT;
1486  if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
1487  if (!SS.isEmpty() && !SS.isInvalid()) {
1488  S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1489  << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());
1490  SS.clear();
1491  }
1492 
1493  // This actually uses the base as an r-value.
1494  BaseExpr = S.DefaultLvalueConversion(BaseExpr.get());
1495  if (BaseExpr.isInvalid())
1496  return ExprError();
1497 
1498  assert(S.Context.hasSameUnqualifiedType(BaseType,
1499  BaseExpr.get()->getType()));
1500 
1501  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1502 
1503  const ObjCObjectType *OT = OPT->getObjectType();
1504 
1505  // id, with and without qualifiers.
1506  if (OT->isObjCId()) {
1507  // Check protocols on qualified interfaces.
1508  Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1509  if (Decl *PMDecl =
1510  FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
1511  if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1512  // Check the use of this declaration
1513  if (S.DiagnoseUseOfDecl(PD, MemberLoc))
1514  return ExprError();
1515 
1516  return new (S.Context)
1518  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1519  }
1520 
1521  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1522  Selector SetterSel =
1524  S.PP.getSelectorTable(),
1525  Member);
1526  ObjCMethodDecl *SMD = nullptr;
1527  if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
1528  /*Property id*/ nullptr,
1529  SetterSel, S.Context))
1530  SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1531 
1532  return new (S.Context)
1534  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1535  }
1536  }
1537  // Use of id.member can only be for a property reference. Do not
1538  // use the 'id' redefinition in this case.
1539  if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1540  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1541  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1542 
1543  return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1544  << MemberName << BaseType);
1545  }
1546 
1547  // 'Class', unqualified only.
1548  if (OT->isObjCClass()) {
1549  // Only works in a method declaration (??!).
1550  ObjCMethodDecl *MD = S.getCurMethodDecl();
1551  if (!MD) {
1552  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1553  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1554  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1555 
1556  goto fail;
1557  }
1558 
1559  // Also must look for a getter name which uses property syntax.
1560  Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1561  ObjCInterfaceDecl *IFace = MD->getClassInterface();
1562  if (!IFace)
1563  goto fail;
1564 
1565  ObjCMethodDecl *Getter;
1566  if ((Getter = IFace->lookupClassMethod(Sel))) {
1567  // Check the use of this method.
1568  if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
1569  return ExprError();
1570  } else
1571  Getter = IFace->lookupPrivateMethod(Sel, false);
1572  // If we found a getter then this may be a valid dot-reference, we
1573  // will look for the matching setter, in case it is needed.
1574  Selector SetterSel =
1576  S.PP.getSelectorTable(),
1577  Member);
1578  ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1579  if (!Setter) {
1580  // If this reference is in an @implementation, also check for 'private'
1581  // methods.
1582  Setter = IFace->lookupPrivateMethod(SetterSel, false);
1583  }
1584 
1585  if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))
1586  return ExprError();
1587 
1588  if (Getter || Setter) {
1589  return new (S.Context) ObjCPropertyRefExpr(
1590  Getter, Setter, S.Context.PseudoObjectTy, VK_LValue,
1591  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1592  }
1593 
1594  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1595  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1596  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1597 
1598  return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1599  << MemberName << BaseType);
1600  }
1601 
1602  // Normal property access.
1603  return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName,
1604  MemberLoc, SourceLocation(), QualType(),
1605  false);
1606  }
1607 
1608  // Handle 'field access' to vectors, such as 'V.xx'.
1609  if (BaseType->isExtVectorType()) {
1610  // FIXME: this expr should store IsArrow.
1611  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1612  ExprValueKind VK;
1613  if (IsArrow)
1614  VK = VK_LValue;
1615  else {
1616  if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(BaseExpr.get()))
1617  VK = POE->getSyntacticForm()->getValueKind();
1618  else
1619  VK = BaseExpr.get()->getValueKind();
1620  }
1621 
1622  QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc,
1623  Member, MemberLoc);
1624  if (ret.isNull())
1625  return ExprError();
1626  Qualifiers BaseQ =
1627  S.Context.getCanonicalType(BaseExpr.get()->getType()).getQualifiers();
1628  ret = S.Context.getQualifiedType(ret, BaseQ);
1629 
1630  return new (S.Context)
1631  ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc);
1632  }
1633 
1634  // Adjust builtin-sel to the appropriate redefinition type if that's
1635  // not just a pointer to builtin-sel again.
1636  if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1638  BaseExpr = S.ImpCastExprToType(
1639  BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast);
1640  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1641  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1642  }
1643 
1644  // Failure cases.
1645  fail:
1646 
1647  // Recover from dot accesses to pointers, e.g.:
1648  // type *foo;
1649  // foo.bar
1650  // This is actually well-formed in two cases:
1651  // - 'type' is an Objective C type
1652  // - 'bar' is a pseudo-destructor name which happens to refer to
1653  // the appropriate pointer type
1654  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1655  if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1656  MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
1657  S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1658  << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1659  << FixItHint::CreateReplacement(OpLoc, "->");
1660 
1661  // Recurse as an -> access.
1662  IsArrow = true;
1663  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1664  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1665  }
1666  }
1667 
1668  // If the user is trying to apply -> or . to a function name, it's probably
1669  // because they forgot parentheses to call that function.
1670  if (S.tryToRecoverWithCall(
1671  BaseExpr, S.PDiag(diag::err_member_reference_needs_call),
1672  /*complain*/ false,
1673  IsArrow ? &isPointerToRecordType : &isRecordType)) {
1674  if (BaseExpr.isInvalid())
1675  return ExprError();
1676  BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get());
1677  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1678  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1679  }
1680 
1681  S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1682  << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1683 
1684  return ExprError();
1685 }
1686 
1687 /// The main callback when the parser finds something like
1688 /// expression . [nested-name-specifier] identifier
1689 /// expression -> [nested-name-specifier] identifier
1690 /// where 'identifier' encompasses a fairly broad spectrum of
1691 /// possibilities, including destructor and operator references.
1692 ///
1693 /// \param OpKind either tok::arrow or tok::period
1694 /// \param ObjCImpDecl the current Objective-C \@implementation
1695 /// decl; this is an ugly hack around the fact that Objective-C
1696 /// \@implementations aren't properly put in the context chain
1698  SourceLocation OpLoc,
1699  tok::TokenKind OpKind,
1700  CXXScopeSpec &SS,
1701  SourceLocation TemplateKWLoc,
1702  UnqualifiedId &Id,
1703  Decl *ObjCImpDecl) {
1704  if (SS.isSet() && SS.isInvalid())
1705  return ExprError();
1706 
1707  // Warn about the explicit constructor calls Microsoft extension.
1708  if (getLangOpts().MicrosoftExt &&
1710  Diag(Id.getSourceRange().getBegin(),
1711  diag::ext_ms_explicit_constructor_call);
1712 
1713  TemplateArgumentListInfo TemplateArgsBuffer;
1714 
1715  // Decompose the name into its component parts.
1716  DeclarationNameInfo NameInfo;
1717  const TemplateArgumentListInfo *TemplateArgs;
1718  DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1719  NameInfo, TemplateArgs);
1720 
1721  DeclarationName Name = NameInfo.getName();
1722  bool IsArrow = (OpKind == tok::arrow);
1723 
1724  NamedDecl *FirstQualifierInScope
1725  = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep()));
1726 
1727  // This is a postfix expression, so get rid of ParenListExprs.
1728  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
1729  if (Result.isInvalid()) return ExprError();
1730  Base = Result.get();
1731 
1732  if (Base->getType()->isDependentType() || Name.isDependentName() ||
1733  isDependentScopeSpecifier(SS)) {
1734  return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS,
1735  TemplateKWLoc, FirstQualifierInScope,
1736  NameInfo, TemplateArgs);
1737  }
1738 
1739  ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl};
1740  ExprResult Res = BuildMemberReferenceExpr(
1741  Base, Base->getType(), OpLoc, IsArrow, SS, TemplateKWLoc,
1742  FirstQualifierInScope, NameInfo, TemplateArgs, S, &ExtraArgs);
1743 
1744  if (!Res.isInvalid() && isa<MemberExpr>(Res.get()))
1745  CheckMemberAccessOfNoDeref(cast<MemberExpr>(Res.get()));
1746 
1747  return Res;
1748 }
1749 
1750 void Sema::CheckMemberAccessOfNoDeref(const MemberExpr *E) {
1751  QualType ResultTy = E->getType();
1752 
1753  // Do not warn on member accesses to arrays since this returns an array
1754  // lvalue and does not actually dereference memory.
1755  if (isa<ArrayType>(ResultTy))
1756  return;
1757 
1758  if (E->isArrow()) {
1759  if (const auto *Ptr = dyn_cast<PointerType>(
1760  E->getBase()->getType().getDesugaredType(Context))) {
1761  if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
1762  ExprEvalContexts.back().PossibleDerefs.insert(E);
1763  }
1764  }
1765 }
1766 
1767 ExprResult
1768 Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
1769  SourceLocation OpLoc, const CXXScopeSpec &SS,
1770  FieldDecl *Field, DeclAccessPair FoundDecl,
1771  const DeclarationNameInfo &MemberNameInfo) {
1772  // x.a is an l-value if 'a' has a reference type. Otherwise:
1773  // x.a is an l-value/x-value/pr-value if the base is (and note
1774  // that *x is always an l-value), except that if the base isn't
1775  // an ordinary object then we must have an rvalue.
1776  ExprValueKind VK = VK_LValue;
1778  if (!IsArrow) {
1779  if (BaseExpr->getObjectKind() == OK_Ordinary)
1780  VK = BaseExpr->getValueKind();
1781  else
1782  VK = VK_RValue;
1783  }
1784  if (VK != VK_RValue && Field->isBitField())
1785  OK = OK_BitField;
1786 
1787  // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1788  QualType MemberType = Field->getType();
1789  if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1790  MemberType = Ref->getPointeeType();
1791  VK = VK_LValue;
1792  } else {
1793  QualType BaseType = BaseExpr->getType();
1794  if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1795 
1796  Qualifiers BaseQuals = BaseType.getQualifiers();
1797 
1798  // GC attributes are never picked up by members.
1799  BaseQuals.removeObjCGCAttr();
1800 
1801  // CVR attributes from the base are picked up by members,
1802  // except that 'mutable' members don't pick up 'const'.
1803  if (Field->isMutable()) BaseQuals.removeConst();
1804 
1805  Qualifiers MemberQuals =
1806  Context.getCanonicalType(MemberType).getQualifiers();
1807 
1808  assert(!MemberQuals.hasAddressSpace());
1809 
1810  Qualifiers Combined = BaseQuals + MemberQuals;
1811  if (Combined != MemberQuals)
1812  MemberType = Context.getQualifiedType(MemberType, Combined);
1813  }
1814 
1815  auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1816  if (!(CurMethod && CurMethod->isDefaulted()))
1817  UnusedPrivateFields.remove(Field);
1818 
1819  ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
1820  FoundDecl, Field);
1821  if (Base.isInvalid())
1822  return ExprError();
1823 
1824  // Build a reference to a private copy for non-static data members in
1825  // non-static member functions, privatized by OpenMP constructs.
1826  if (getLangOpts().OpenMP && IsArrow &&
1827  !CurContext->isDependentContext() &&
1828  isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
1829  if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
1830  return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
1831  MemberNameInfo.getLoc());
1832  }
1833  }
1834 
1835  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
1836  /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
1837  /*HadMultipleCandidates=*/false, MemberNameInfo,
1838  MemberType, VK, OK);
1839 }
1840 
1841 /// Builds an implicit member access expression. The current context
1842 /// is known to be an instance method, and the given unqualified lookup
1843 /// set is known to contain only instance members, at least one of which
1844 /// is from an appropriate type.
1845 ExprResult
1847  SourceLocation TemplateKWLoc,
1848  LookupResult &R,
1849  const TemplateArgumentListInfo *TemplateArgs,
1850  bool IsKnownInstance, const Scope *S) {
1851  assert(!R.empty() && !R.isAmbiguous());
1852 
1853  SourceLocation loc = R.getNameLoc();
1854 
1855  // If this is known to be an instance access, go ahead and build an
1856  // implicit 'this' expression now.
1857  // 'this' expression now.
1858  QualType ThisTy = getCurrentThisType();
1859  assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'");
1860 
1861  Expr *baseExpr = nullptr; // null signifies implicit access
1862  if (IsKnownInstance) {
1863  SourceLocation Loc = R.getNameLoc();
1864  if (SS.getRange().isValid())
1865  Loc = SS.getRange().getBegin();
1866  baseExpr = BuildCXXThisExpr(loc, ThisTy, /*IsImplicit=*/true);
1867  }
1868 
1869  return BuildMemberReferenceExpr(baseExpr, ThisTy,
1870  /*OpLoc*/ SourceLocation(),
1871  /*IsArrow*/ true,
1872  SS, TemplateKWLoc,
1873  /*FirstQualifierInScope*/ nullptr,
1874  R, TemplateArgs, S);
1875 }
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
This is the scope of a C++ try statement.
Definition: Scope.h:101
static const Decl * getCanonicalDecl(const Decl *D)
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.
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
Definition: Sema.h:713
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1440
Smart pointer class that efficiently represents Objective-C method names.
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:924
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2645
QualType getPointeeType() const
Definition: Type.h:2655
A (possibly-)qualified type.
Definition: Type.h:655
Simple class containing the result of Sema::CorrectTypo.
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1156
bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, ObjCMethodDecl *Method, ObjCIvarDecl *IV)
IvarBacksCurrentMethodAccessor - This routine returns &#39;true&#39; if &#39;IV&#39; is an ivar synthesized for &#39;Meth...
The reference may be to an instance member, but it might be invalid if so, because the context is not...
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1155
bool forallBases(ForallBasesCallback BaseMatches) const
Determines if the given callback holds for all the direct or indirect base classes of this type...
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1291
static void diagnoseInstanceReference(Sema &SemaRef, const CXXScopeSpec &SS, NamedDecl *Rep, const DeclarationNameInfo &nameInfo)
Diagnose a reference to a field with no object available.
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:961
VarDecl * getVarDecl() const
Definition: Decl.h:3035
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:248
QualType CXXThisTypeOverride
When non-NULL, the C++ &#39;this&#39; expression is allowed despite the current context not being a non-stati...
Definition: Sema.h:5867
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:627
IMAKind
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2961
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:1456
bool isRecordType() const
Definition: Type.h:6740
Expr * getBase() const
Definition: Expr.h:3127
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:190
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1914
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1517
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
bool isExtVectorType() const
Definition: Type.h:6756
void setType(QualType t)
Definition: Expr.h:143
Defines the C++ template declaration subclasses.
VarDecl * getVarTemplateSpecialization(VarTemplateDecl *VarTempl, const TemplateArgumentListInfo *TemplateArgs, const DeclarationNameInfo &MemberNameInfo, SourceLocation TemplateKWLoc)
The reference is definitely an implicit instance member access.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
Declaration of a variable template.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:3683
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
static bool IsInFnTryBlockHandler(const Scope *S)
Determine if the given scope is within a function-try-block handler.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
const DeclAccessPair & getPair() const
Definition: UnresolvedSet.h:54
This file provides some common utility functions for processing Lambda related AST Constructs...
Represents a variable declaration or definition.
Definition: Decl.h:820
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:243
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1482
DiagnosticsEngine & Diags
Definition: Sema.h:401
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7153
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
bool isAmbiguous() const
Definition: Lookup.h:301
bool isInvalidDecl() const
Definition: DeclBase.h:558
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1843
void setBegin(SourceLocation b)
bool isStatic() const
Definition: DeclCXX.cpp:2033
protocol_range protocols() const
Definition: DeclObjC.h:2120
Defines the clang::Expr interface and subclasses for C++ expressions.
iterator begin(Source *source, bool LocalOnly=false)
The collection of all-type qualifiers we support.
Definition: Type.h:144
Qualifiers getQualifiers() const
Retrieve all qualifiers.
Represents a struct/union/class.
Definition: Decl.h:3770
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1210
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Represents a class type in Objective C.
Definition: Type.h:5793
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:174
A C++ nested-name-specifier augmented with source location information.
bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, const LookupResult &R)
ObjCMethodFamily
A family of Objective-C methods.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Represents a member of a struct/union/class.
Definition: Decl.h:2746
The current expression is potentially evaluated at run time, which means that code may be generated t...
void removeConst()
Definition: Type.h:263
The reference may be to an unresolved using declaration and the context is not an instance method...
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base)
Given that normal member access failed on the given expression, and given that the expression&#39;s type ...
int Category
Definition: Format.cpp:2021
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6902
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1940
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3762
static int getPointAccessorIdx(char c)
Definition: Type.h:3356
bool isObjCSelType() const
Definition: Type.h:6817
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5724
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:486
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:127
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:955
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2824
Selector getNullarySelector(IdentifierInfo *ID)
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:479
Represents the results of name lookup.
Definition: Lookup.h:46
PtrTy get() const
Definition: Ownership.h:170
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
__device__ int
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1317
A convenient class for passing around template argument information.
Definition: TemplateBase.h:556
static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef, const LookupResult &R)
The given lookup names class member(s) and is not being used for an address-of-member expression...
bool hasAddressSpace() const
Definition: Type.h:359
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:417
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
static bool isRecordType(QualType T)
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:2536
The reference is a contextually-permitted abstract member reference.
CanQualType PseudoObjectTy
Definition: ASTContext.h:974
bool isArrow() const
Definition: Expr.h:3234
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:1635
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2952
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:493
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1198
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:6177
ObjCMethodDecl * lookupClassMethod(Selector Sel) const
Lookup a class method for a given selector.
Definition: DeclObjC.h:1843
ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:64
The current expression occurs within a discarded statement.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2055
Preprocessor & PP
Definition: Sema.h:398
const LangOptions & getLangOpts() const
Definition: Sema.h:1430
The reference may be an implicit instance member access.
An ordinary object is located at an address in memory.
Definition: Specifiers.h:143
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:8734
Represents an ObjC class declaration.
Definition: DeclObjC.h:1163
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:426
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3641
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:6029
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:151
unsigned getLength() const
Efficiently return the length of this identifier info.
Sema::RedeclarationKind redeclarationKind() const
Definition: Lookup.h:268
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2927
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
Definition: Expr.cpp:1567
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > BaseSet
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:8743
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:220
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:340
All possible referrents are instance members and the current context is not an instance method...
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3886
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
Definition: ScopeInfo.h:1020
SourceRange getRange() const
Definition: DeclSpec.h:69
QualType getUsageType(QualType objectType) const
Retrieve the type of this instance variable when viewed as a member of a specific object type...
Definition: DeclObjC.cpp:1838
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:153
static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, Expr *BaseExpr, const RecordType *RTy, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, bool HasTemplateArgs, SourceLocation TemplateKWLoc, TypoExpr *&TE)
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
TypoExpr * CorrectTypoDelayed(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
This represents one expression.
Definition: Expr.h:110
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:3629
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:124
static bool IsRGBA(char c)
Determine whether input char is from rgba component set.
int Id
Definition: ASTDiff.cpp:191
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7218
std::string getAsString() const
Retrieve the human-readable string for this name.
Defines the clang::Preprocessor interface.
All possible referrents are instance members of an unrelated class.
DeclContext * getDeclContext()
Definition: DeclBase.h:439
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1364
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1037
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
QualType getType() const
Definition: Expr.h:142
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:621
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:308
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1816
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2119
static void DiagnoseQualifiedMemberReference(Sema &SemaRef, Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, NamedDecl *rep, const DeclarationNameInfo &nameInfo)
We know that the given qualified member reference points only to declarations which do not belong to ...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:889
bool isUsable() const
Definition: Ownership.h:167
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:186
bool isObjCClass() const
Definition: Type.h:5862
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:424
bool isUnresolvableResult() const
Definition: Lookup.h:317
RecordDecl * getDecl() const
Definition: Type.h:4627
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:77
chain_iterator chain_end() const
Definition: Decl.h:3026
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:1622
static bool isPointerToRecordType(QualType T)
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Definition: Decl.h:3020
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5914
static ExprResult BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow, const CXXScopeSpec &SS, MSPropertyDecl *PD, const DeclarationNameInfo &NameInfo)
bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const
Definition: Type.h:3401
Encodes a location in the source.
QualType getObjCSelRedefinitionType() const
Retrieve the type that &#39;SEL&#39; has been defined to, which may be different from the built-in &#39;SEL&#39; if &#39;...
Definition: ASTContext.h:1648
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:8253
MemberExpr * BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS, SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK, ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs=nullptr)
DeclarationName getName() const
getName - Returns the embedded declaration name.
QualType getElementType() const
Definition: Type.h:3269
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:922
bool isOverloadedResult() const
Determines if the results are overloaded.
Definition: Lookup.h:313
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:141
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1960
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:606
The reference may be to an unresolved using declaration.
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, 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...
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:742
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:210
static Decl * FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1801
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
void removeObjCGCAttr()
Definition: Type.h:312
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:195
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2299
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition: Lookup.h:612
A POD class for pairing a NamedDecl* with an access specifier.
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:2620
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Canon=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
bool isObjCId() const
Definition: Type.h:5858
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
ObjCMethodDecl * lookupPrivateMethod(const Selector &Sel, bool Instance=true) const
Lookup a method in the classes implementation hierarchy.
Definition: DeclObjC.cpp:740
ObjCPropertyDecl * FindPropertyDeclaration(const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const
FindPropertyDeclaration - Finds declaration of the property given its name in &#39;PropertyId&#39; and return...
Definition: DeclObjC.cpp:236
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1303
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:228
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:534
bool isRecord() const
Definition: DeclBase.h:1895
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:3000
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:122
AccessSpecifier getAccess() const
Definition: DeclBase.h:478
static ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc)
Look up the given member of the given non-type-dependent expression.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
The name of a declaration.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2076
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.
Definition: Sema.cpp:2288
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:6087
ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Member, Decl *ObjCImpDecl)
The main callback when the parser finds something like expression .
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2947
ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, bool IsDefiniteInstance, const Scope *S)
Builds an implicit member access expression.
Represents a pointer to an Objective C object.
Definition: Type.h:6050
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2543
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
Definition: Expr.h:3260
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4617
This is the scope for a function-level C++ try or catch scope.
Definition: Scope.h:104
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
chain_iterator chain_begin() const
Definition: Decl.h:3025
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1312
bool isFunctionType() const
Definition: Type.h:6646
ExprResult HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super)
HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an objective C interface...
ExtVectorType - Extended vector type.
Definition: Type.h:3349
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2756
CanQualType BoundMemberTy
Definition: ASTContext.h:972
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1211
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
qual_range quals() const
Definition: Type.h:6169
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:146
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:548
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2259
bool isSet() const
Deprecated.
Definition: DeclSpec.h:210
The reference may be to an instance member, but it is invalid if so, because the context is from an u...
ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow)
Perform conversions on the LHS of a member access expression.
Reading or writing from this object requires a barrier call.
Definition: Type.h:175
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3050
ActionResult< Expr * > ExprResult
Definition: Ownership.h:263
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2821
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
bool isValid() const
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1608
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6429
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1936
bool isRValue() const
Definition: Expr.h:262
static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
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:133
iterator end() const
Definition: Lookup.h:336
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
ExprResult ExprError()
Definition: Ownership.h:279
unsigned getNumElements() const
Definition: Type.h:3270
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2185
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1178
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:232
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:829
bool isPointerType() const
Definition: Type.h:6650
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:420
The reference is definitely not an instance member access.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3969
QualType getType() const
Definition: Decl.h:630
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:131
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
static Decl * FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl *PDecl, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
static int getNumericAccessorIdx(char c)
Definition: Type.h:3366
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:399
This represents a decl that may have a name.
Definition: Decl.h:223
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:1078
AccessControl getAccessControl() const
Definition: DeclObjC.h:1975
iterator begin() const
Definition: Lookup.h:335
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:606
static QualType CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK, SourceLocation OpLoc, const IdentifierInfo *CompName, SourceLocation CompLoc)
Check an ext-vector component access expression.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:524
SourceLocation getBegin() const
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2490
__device__ __2f16 float c
The current expression occurs within a braced-init-list within an unevaluated operand.
SourceLocation getLocation() const
Definition: DeclBase.h:430
static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, const BaseSet &Bases)
Determines if the given class is provably not derived from all of the prospective base classes...
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1777
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:8774
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1102
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context, meaning that the members declared in this context are semantically declared in the nearest enclosing non-transparent (opaque) context but are lexically declared in this context.
Definition: DeclBase.cpp:1172