clang  15.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 
150  break;
151  }
152 
153  // If the current context is not an instance method, it can't be
154  // an implicit member reference.
155  if (isStaticContext) {
156  if (hasNonInstance)
158 
159  return AbstractInstanceResult ? AbstractInstanceResult
161  }
162 
163  CXXRecordDecl *contextClass;
164  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
165  contextClass = MD->getParent()->getCanonicalDecl();
166  else
167  contextClass = cast<CXXRecordDecl>(DC);
168 
169  // [class.mfct.non-static]p3:
170  // ...is used in the body of a non-static member function of class X,
171  // if name lookup (3.4.1) resolves the name in the id-expression to a
172  // non-static non-type member of some class C [...]
173  // ...if C is not X or a base class of X, the class member access expression
174  // is ill-formed.
175  if (R.getNamingClass() &&
176  contextClass->getCanonicalDecl() !=
177  R.getNamingClass()->getCanonicalDecl()) {
178  // If the naming class is not the current context, this was a qualified
179  // member name lookup, and it's sufficient to check that we have the naming
180  // class as a base class.
181  Classes.clear();
182  Classes.insert(R.getNamingClass()->getCanonicalDecl());
183  }
184 
185  // If we can prove that the current context is unrelated to all the
186  // declaring classes, it can't be an implicit member reference (in
187  // which case it's an error if any of those members are selected).
188  if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes))
189  return hasNonInstance ? IMA_Mixed_Unrelated :
190  AbstractInstanceResult ? AbstractInstanceResult :
192 
193  return (hasNonInstance ? IMA_Mixed : IMA_Instance);
194 }
195 
196 /// Diagnose a reference to a field with no object available.
197 static void diagnoseInstanceReference(Sema &SemaRef,
198  const CXXScopeSpec &SS,
199  NamedDecl *Rep,
200  const DeclarationNameInfo &nameInfo) {
201  SourceLocation Loc = nameInfo.getLoc();
202  SourceRange Range(Loc);
203  if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
204 
205  // Look through using shadow decls and aliases.
206  Rep = Rep->getUnderlyingDecl();
207 
208  DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
209  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
210  CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr;
211  CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
212 
213  bool InStaticMethod = Method && Method->isStatic();
214  bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep);
215 
216  if (IsField && InStaticMethod)
217  // "invalid use of member 'x' in static member function"
218  SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
219  << Range << nameInfo.getName();
220  else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod &&
221  !RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass))
222  // Unqualified lookup in a non-static member function found a member of an
223  // enclosing class.
224  SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
225  << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
226  else if (IsField)
227  SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
228  << nameInfo.getName() << Range;
229  else
230  SemaRef.Diag(Loc, diag::err_member_call_without_object)
231  << Range;
232 }
233 
234 /// Builds an expression which might be an implicit member expression.
236  const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
237  const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
238  UnresolvedLookupExpr *AsULE) {
239  switch (ClassifyImplicitMemberAccess(*this, R)) {
240  case IMA_Instance:
241  return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true, S);
242 
243  case IMA_Mixed:
244  case IMA_Mixed_Unrelated:
245  case IMA_Unresolved:
246  return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false,
247  S);
248 
250  Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use)
251  << R.getLookupNameInfo().getName();
252  LLVM_FALLTHROUGH;
253  case IMA_Static:
254  case IMA_Abstract:
257  if (TemplateArgs || TemplateKWLoc.isValid())
258  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs);
259  return AsULE ? AsULE : BuildDeclarationNameExpr(SS, R, false);
260 
262  case IMA_Error_Unrelated:
264  R.getLookupNameInfo());
265  return ExprError();
266  }
267 
268  llvm_unreachable("unexpected instance member access kind");
269 }
270 
271 /// Determine whether input char is from rgba component set.
272 static bool
273 IsRGBA(char c) {
274  switch (c) {
275  case 'r':
276  case 'g':
277  case 'b':
278  case 'a':
279  return true;
280  default:
281  return false;
282  }
283 }
284 
285 // OpenCL v1.1, s6.1.7
286 // The component swizzle length must be in accordance with the acceptable
287 // vector sizes.
288 static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
289 {
290  return (len >= 1 && len <= 4) || len == 8 || len == 16;
291 }
292 
293 /// Check an ext-vector component access expression.
294 ///
295 /// VK should be set in advance to the value kind of the base
296 /// expression.
297 static QualType
299  SourceLocation OpLoc, const IdentifierInfo *CompName,
300  SourceLocation CompLoc) {
301  // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
302  // see FIXME there.
303  //
304  // FIXME: This logic can be greatly simplified by splitting it along
305  // halving/not halving and reworking the component checking.
306  const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
307 
308  // The vector accessor can't exceed the number of elements.
309  const char *compStr = CompName->getNameStart();
310 
311  // This flag determines whether or not the component is one of the four
312  // special names that indicate a subset of exactly half the elements are
313  // to be selected.
314  bool HalvingSwizzle = false;
315 
316  // This flag determines whether or not CompName has an 's' char prefix,
317  // indicating that it is a string of hex values to be used as vector indices.
318  bool HexSwizzle = (*compStr == 's' || *compStr == 'S') && compStr[1];
319 
320  bool HasRepeated = false;
321  bool HasIndex[16] = {};
322 
323  int Idx;
324 
325  // Check that we've found one of the special components, or that the component
326  // names must come from the same set.
327  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
328  !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
329  HalvingSwizzle = true;
330  } else if (!HexSwizzle &&
331  (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
332  bool HasRGBA = IsRGBA(*compStr);
333  do {
334  // Ensure that xyzw and rgba components don't intermingle.
335  if (HasRGBA != IsRGBA(*compStr))
336  break;
337  if (HasIndex[Idx]) HasRepeated = true;
338  HasIndex[Idx] = true;
339  compStr++;
340  } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
341 
342  // Emit a warning if an rgba selector is used earlier than OpenCL C 3.0.
343  if (HasRGBA || (*compStr && IsRGBA(*compStr))) {
344  if (S.getLangOpts().OpenCL &&
346  const char *DiagBegin = HasRGBA ? CompName->getNameStart() : compStr;
347  S.Diag(OpLoc, diag::ext_opencl_ext_vector_type_rgba_selector)
348  << StringRef(DiagBegin, 1) << SourceRange(CompLoc);
349  }
350  }
351  } else {
352  if (HexSwizzle) compStr++;
353  while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
354  if (HasIndex[Idx]) HasRepeated = true;
355  HasIndex[Idx] = true;
356  compStr++;
357  }
358  }
359 
360  if (!HalvingSwizzle && *compStr) {
361  // We didn't get to the end of the string. This means the component names
362  // didn't come from the same set *or* we encountered an illegal name.
363  S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
364  << StringRef(compStr, 1) << SourceRange(CompLoc);
365  return QualType();
366  }
367 
368  // Ensure no component accessor exceeds the width of the vector type it
369  // operates on.
370  if (!HalvingSwizzle) {
371  compStr = CompName->getNameStart();
372 
373  if (HexSwizzle)
374  compStr++;
375 
376  while (*compStr) {
377  if (!vecType->isAccessorWithinNumElements(*compStr++, HexSwizzle)) {
378  S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
379  << baseType << SourceRange(CompLoc);
380  return QualType();
381  }
382  }
383  }
384 
385  // OpenCL mode requires swizzle length to be in accordance with accepted
386  // sizes. Clang however supports arbitrary lengths for other languages.
387  if (S.getLangOpts().OpenCL && !HalvingSwizzle) {
388  unsigned SwizzleLength = CompName->getLength();
389 
390  if (HexSwizzle)
391  SwizzleLength--;
392 
393  if (IsValidOpenCLComponentSwizzleLength(SwizzleLength) == false) {
394  S.Diag(OpLoc, diag::err_opencl_ext_vector_component_invalid_length)
395  << SwizzleLength << SourceRange(CompLoc);
396  return QualType();
397  }
398  }
399 
400  // The component accessor looks fine - now we need to compute the actual type.
401  // The vector type is implied by the component accessor. For example,
402  // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
403  // vec4.s0 is a float, vec4.s23 is a vec3, etc.
404  // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
405  unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2
406  : CompName->getLength();
407  if (HexSwizzle)
408  CompSize--;
409 
410  if (CompSize == 1)
411  return vecType->getElementType();
412 
413  if (HasRepeated)
414  VK = VK_PRValue;
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()) {
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() || NameInfo.getName().isDependentName() ||
508  isDependentScopeSpecifier(SS) ||
509  (TemplateArgs && llvm::any_of(TemplateArgs->arguments(),
510  [](const TemplateArgumentLoc &Arg) {
511  return Arg.getArgument().isDependent();
512  })));
513 
514  // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
515  // must have pointer type, and the accessed type is the pointee.
517  Context, BaseExpr, BaseType, IsArrow, OpLoc,
518  SS.getWithLocInContext(Context), TemplateKWLoc, FirstQualifierInScope,
519  NameInfo, TemplateArgs);
520 }
521 
522 /// We know that the given qualified member reference points only to
523 /// declarations which do not belong to the static type of the base
524 /// expression. Diagnose the problem.
526  Expr *BaseExpr,
527  QualType BaseType,
528  const CXXScopeSpec &SS,
529  NamedDecl *rep,
530  const DeclarationNameInfo &nameInfo) {
531  // If this is an implicit member access, use a different set of
532  // diagnostics.
533  if (!BaseExpr)
534  return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
535 
536  SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
537  << SS.getRange() << rep << BaseType;
538 }
539 
540 // Check whether the declarations we found through a nested-name
541 // specifier in a member expression are actually members of the base
542 // type. The restriction here is:
543 //
544 // C++ [expr.ref]p2:
545 // ... In these cases, the id-expression shall name a
546 // member of the class or of one of its base classes.
547 //
548 // So it's perfectly legitimate for the nested-name specifier to name
549 // an unrelated class, and for us to find an overload set including
550 // decls from classes which are not superclasses, as long as the decl
551 // we actually pick through overload resolution is from a superclass.
553  QualType BaseType,
554  const CXXScopeSpec &SS,
555  const LookupResult &R) {
556  CXXRecordDecl *BaseRecord =
557  cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType));
558  if (!BaseRecord) {
559  // We can't check this yet because the base type is still
560  // dependent.
561  assert(BaseType->isDependentType());
562  return false;
563  }
564 
565  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
566  // If this is an implicit member reference and we find a
567  // non-instance member, it's not an error.
568  if (!BaseExpr && !(*I)->isCXXInstanceMember())
569  return false;
570 
571  // Note that we use the DC of the decl, not the underlying decl.
572  DeclContext *DC = (*I)->getDeclContext()->getNonTransparentContext();
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 auto *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 auto *BSTy = BS.getType()->getAs<RecordType>()) {
621  if (BSTy->getDecl()->containsDecl(ND))
622  return true;
623  }
624  }
625  }
626 
627  return false;
628  }
629 
630  std::unique_ptr<CorrectionCandidateCallback> clone() override {
631  return std::make_unique<RecordMemberExprValidatorCCC>(*this);
632  }
633 
634 private:
635  const RecordDecl *const Record;
636 };
637 
638 }
639 
640 static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
641  Expr *BaseExpr,
642  const RecordType *RTy,
643  SourceLocation OpLoc, bool IsArrow,
644  CXXScopeSpec &SS, bool HasTemplateArgs,
645  SourceLocation TemplateKWLoc,
646  TypoExpr *&TE) {
647  SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange();
648  RecordDecl *RDecl = RTy->getDecl();
649  if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
650  SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
651  diag::err_typecheck_incomplete_tag,
652  BaseRange))
653  return true;
654 
655  if (HasTemplateArgs || TemplateKWLoc.isValid()) {
656  // LookupTemplateName doesn't expect these both to exist simultaneously.
657  QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
658 
659  bool MOUS;
660  return SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS,
661  TemplateKWLoc);
662  }
663 
664  DeclContext *DC = RDecl;
665  if (SS.isSet()) {
666  // If the member name was a qualified-id, look into the
667  // nested-name-specifier.
668  DC = SemaRef.computeDeclContext(SS, false);
669 
670  if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
671  SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
672  << SS.getRange() << DC;
673  return true;
674  }
675 
676  assert(DC && "Cannot handle non-computable dependent contexts in lookup");
677 
678  if (!isa<TypeDecl>(DC)) {
679  SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
680  << DC << SS.getRange();
681  return true;
682  }
683  }
684 
685  // The record definition is complete, now look up the member.
686  SemaRef.LookupQualifiedName(R, DC, SS);
687 
688  if (!R.empty())
689  return false;
690 
691  DeclarationName Typo = R.getLookupName();
692  SourceLocation TypoLoc = R.getNameLoc();
693 
694  struct QueryState {
695  Sema &SemaRef;
696  DeclarationNameInfo NameInfo;
697  Sema::LookupNameKind LookupKind;
699  };
700  QueryState Q = {R.getSema(), R.getLookupNameInfo(), R.getLookupKind(),
701  R.redeclarationKind()};
702  RecordMemberExprValidatorCCC CCC(RTy);
703  TE = SemaRef.CorrectTypoDelayed(
704  R.getLookupNameInfo(), R.getLookupKind(), nullptr, &SS, CCC,
705  [=, &SemaRef](const TypoCorrection &TC) {
706  if (TC) {
707  assert(!TC.isKeyword() &&
708  "Got a keyword as a correction for a member!");
709  bool DroppedSpecifier =
710  TC.WillReplaceSpecifier() &&
711  Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts());
712  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
713  << Typo << DC << DroppedSpecifier
714  << SS.getRange());
715  } else {
716  SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange;
717  }
718  },
719  [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
720  LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
721  R.clear(); // Ensure there's no decls lingering in the shared state.
722  R.suppressDiagnostics();
723  R.setLookupName(TC.getCorrection());
724  for (NamedDecl *ND : TC)
725  R.addDecl(ND);
726  R.resolveKind();
727  return SemaRef.BuildMemberReferenceExpr(
728  BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(),
729  nullptr, R, nullptr, nullptr);
730  },
732 
733  return false;
734 }
735 
737  ExprResult &BaseExpr, bool &IsArrow,
738  SourceLocation OpLoc, CXXScopeSpec &SS,
739  Decl *ObjCImpDecl, bool HasTemplateArgs,
740  SourceLocation TemplateKWLoc);
741 
744  SourceLocation OpLoc, bool IsArrow,
745  CXXScopeSpec &SS,
746  SourceLocation TemplateKWLoc,
747  NamedDecl *FirstQualifierInScope,
748  const DeclarationNameInfo &NameInfo,
749  const TemplateArgumentListInfo *TemplateArgs,
750  const Scope *S,
751  ActOnMemberAccessExtraArgs *ExtraArgs) {
752  if (BaseType->isDependentType() ||
753  (SS.isSet() && isDependentScopeSpecifier(SS)))
754  return ActOnDependentMemberExpr(Base, BaseType,
755  IsArrow, OpLoc,
756  SS, TemplateKWLoc, FirstQualifierInScope,
757  NameInfo, TemplateArgs);
758 
759  LookupResult R(*this, NameInfo, LookupMemberName);
760 
761  // Implicit member accesses.
762  if (!Base) {
763  TypoExpr *TE = nullptr;
764  QualType RecordTy = BaseType;
765  if (IsArrow) RecordTy = RecordTy->castAs<PointerType>()->getPointeeType();
767  *this, R, nullptr, RecordTy->getAs<RecordType>(), OpLoc, IsArrow,
768  SS, TemplateArgs != nullptr, TemplateKWLoc, TE))
769  return ExprError();
770  if (TE)
771  return TE;
772 
773  // Explicit member accesses.
774  } else {
776  ExprResult Result =
777  LookupMemberExpr(*this, R, BaseResult, IsArrow, OpLoc, SS,
778  ExtraArgs ? ExtraArgs->ObjCImpDecl : nullptr,
779  TemplateArgs != nullptr, TemplateKWLoc);
780 
781  if (BaseResult.isInvalid())
782  return ExprError();
783  Base = BaseResult.get();
784 
785  if (Result.isInvalid())
786  return ExprError();
787 
788  if (Result.get())
789  return Result;
790 
791  // LookupMemberExpr can modify Base, and thus change BaseType
792  BaseType = Base->getType();
793  }
794 
795  return BuildMemberReferenceExpr(Base, BaseType,
796  OpLoc, IsArrow, SS, TemplateKWLoc,
797  FirstQualifierInScope, R, TemplateArgs, S,
798  false, ExtraArgs);
799 }
800 
803  SourceLocation loc,
804  IndirectFieldDecl *indirectField,
805  DeclAccessPair foundDecl,
806  Expr *baseObjectExpr,
807  SourceLocation opLoc) {
808  // First, build the expression that refers to the base object.
809 
810  // Case 1: the base of the indirect field is not a field.
811  VarDecl *baseVariable = indirectField->getVarDecl();
812  CXXScopeSpec EmptySS;
813  if (baseVariable) {
814  assert(baseVariable->getType()->isRecordType());
815 
816  // In principle we could have a member access expression that
817  // accesses an anonymous struct/union that's a static member of
818  // the base object's class. However, under the current standard,
819  // static data members cannot be anonymous structs or unions.
820  // Supporting this is as easy as building a MemberExpr here.
821  assert(!baseObjectExpr && "anonymous struct/union is static data member?");
822 
823  DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
824 
825  ExprResult result
826  = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
827  if (result.isInvalid()) return ExprError();
828 
829  baseObjectExpr = result.get();
830  }
831 
832  assert((baseVariable || baseObjectExpr) &&
833  "referencing anonymous struct/union without a base variable or "
834  "expression");
835 
836  // Build the implicit member references to the field of the
837  // anonymous struct/union.
838  Expr *result = baseObjectExpr;
840  FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
841 
842  // Case 2: the base of the indirect field is a field and the user
843  // wrote a member expression.
844  if (!baseVariable) {
845  FieldDecl *field = cast<FieldDecl>(*FI);
846 
847  bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
848 
849  // Make a nameInfo that properly uses the anonymous name.
850  DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
851 
852  // Build the first member access in the chain with full information.
853  result =
854  BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
855  SS, field, foundDecl, memberNameInfo)
856  .get();
857  if (!result)
858  return ExprError();
859  }
860 
861  // In all cases, we should now skip the first declaration in the chain.
862  ++FI;
863 
864  while (FI != FEnd) {
865  FieldDecl *field = cast<FieldDecl>(*FI++);
866 
867  // FIXME: these are somewhat meaningless
868  DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
869  DeclAccessPair fakeFoundDecl =
870  DeclAccessPair::make(field, field->getAccess());
871 
872  result =
873  BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
874  (FI == FEnd ? SS : EmptySS), field,
875  fakeFoundDecl, memberNameInfo)
876  .get();
877  }
878 
879  return result;
880 }
881 
882 static ExprResult
883 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
884  const CXXScopeSpec &SS,
885  MSPropertyDecl *PD,
886  const DeclarationNameInfo &NameInfo) {
887  // Property names are always simple identifiers and therefore never
888  // require any interesting additional storage.
889  return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow,
892  NameInfo.getLoc());
893 }
894 
896  Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS,
897  SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
898  bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
900  const TemplateArgumentListInfo *TemplateArgs) {
903  return BuildMemberExpr(Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member,
904  FoundDecl, HadMultipleCandidates, MemberNameInfo, Ty,
905  VK, OK, TemplateArgs);
906 }
907 
909  Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS,
910  SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
911  bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
913  const TemplateArgumentListInfo *TemplateArgs) {
914  assert((!IsArrow || Base->isPRValue()) &&
915  "-> base must be a pointer prvalue");
916  MemberExpr *E =
917  MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc,
918  Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty,
920  E->setHadMultipleCandidates(HadMultipleCandidates);
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->isFnTryCatchScope())
944  return (S->getFlags() & Scope::TryScope) != Scope::TryScope;
945  }
946  return false;
947 }
948 
951  SourceLocation OpLoc, bool IsArrow,
952  const CXXScopeSpec &SS,
953  SourceLocation TemplateKWLoc,
954  NamedDecl *FirstQualifierInScope,
955  LookupResult &R,
956  const TemplateArgumentListInfo *TemplateArgs,
957  const Scope *S,
958  bool SuppressQualifierCheck,
959  ActOnMemberAccessExtraArgs *ExtraArgs) {
960  QualType BaseType = BaseExprType;
961  if (IsArrow) {
962  assert(BaseType->isPointerType());
963  BaseType = BaseType->castAs<PointerType>()->getPointeeType();
964  }
965  R.setBaseObjectType(BaseType);
966 
967  // C++1z [expr.ref]p2:
968  // For the first option (dot) the first expression shall be a glvalue [...]
969  if (!IsArrow && BaseExpr && BaseExpr->isPRValue()) {
970  ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
971  if (Converted.isInvalid())
972  return ExprError();
973  BaseExpr = Converted.get();
974  }
975 
976  const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
977  DeclarationName MemberName = MemberNameInfo.getName();
978  SourceLocation MemberLoc = MemberNameInfo.getLoc();
979 
980  if (R.isAmbiguous())
981  return ExprError();
982 
983  // [except.handle]p10: Referring to any non-static member or base class of an
984  // object in the handler for a function-try-block of a constructor or
985  // destructor for that object results in undefined behavior.
986  const auto *FD = getCurFunctionDecl();
987  if (S && BaseExpr && FD &&
988  (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) &&
989  isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) &&
991  Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr)
992  << isa<CXXDestructorDecl>(FD);
993 
994  if (R.empty()) {
995  // Rederive where we looked up.
996  DeclContext *DC = (SS.isSet()
997  ? computeDeclContext(SS, false)
998  : BaseType->castAs<RecordType>()->getDecl());
999 
1000  if (ExtraArgs) {
1001  ExprResult RetryExpr;
1002  if (!IsArrow && BaseExpr) {
1003  SFINAETrap Trap(*this, true);
1004  ParsedType ObjectType;
1005  bool MayBePseudoDestructor = false;
1006  RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
1007  OpLoc, tok::arrow, ObjectType,
1008  MayBePseudoDestructor);
1009  if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
1010  CXXScopeSpec TempSS(SS);
1011  RetryExpr = ActOnMemberAccessExpr(
1012  ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
1013  TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl);
1014  }
1015  if (Trap.hasErrorOccurred())
1016  RetryExpr = ExprError();
1017  }
1018  if (RetryExpr.isUsable()) {
1019  Diag(OpLoc, diag::err_no_member_overloaded_arrow)
1020  << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
1021  return RetryExpr;
1022  }
1023  }
1024 
1025  Diag(R.getNameLoc(), diag::err_no_member)
1026  << MemberName << DC
1027  << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
1028  return ExprError();
1029  }
1030 
1031  // Diagnose lookups that find only declarations from a non-base
1032  // type. This is possible for either qualified lookups (which may
1033  // have been qualified with an unrelated type) or implicit member
1034  // expressions (which were found with unqualified lookup and thus
1035  // may have come from an enclosing scope). Note that it's okay for
1036  // lookup to find declarations from a non-base type as long as those
1037  // aren't the ones picked by overload resolution.
1038  if ((SS.isSet() || !BaseExpr ||
1039  (isa<CXXThisExpr>(BaseExpr) &&
1040  cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
1041  !SuppressQualifierCheck &&
1042  CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
1043  return ExprError();
1044 
1045  // Construct an unresolved result if we in fact got an unresolved
1046  // result.
1047  if (R.isOverloadedResult() || R.isUnresolvableResult()) {
1048  // Suppress any lookup-related diagnostics; we'll do these when we
1049  // pick a member.
1050  R.suppressDiagnostics();
1051 
1052  UnresolvedMemberExpr *MemExpr
1054  BaseExpr, BaseExprType,
1055  IsArrow, OpLoc,
1057  TemplateKWLoc, MemberNameInfo,
1058  TemplateArgs, R.begin(), R.end());
1059 
1060  return MemExpr;
1061  }
1062 
1063  assert(R.isSingleResult());
1064  DeclAccessPair FoundDecl = R.begin().getPair();
1065  NamedDecl *MemberDecl = R.getFoundDecl();
1066 
1067  // FIXME: diagnose the presence of template arguments now.
1068 
1069  // If the decl being referenced had an error, return an error for this
1070  // sub-expr without emitting another error, in order to avoid cascading
1071  // error cases.
1072  if (MemberDecl->isInvalidDecl())
1073  return ExprError();
1074 
1075  // Handle the implicit-member-access case.
1076  if (!BaseExpr) {
1077  // If this is not an instance member, convert to a non-member access.
1078  if (!MemberDecl->isCXXInstanceMember()) {
1079  // We might have a variable template specialization (or maybe one day a
1080  // member concept-id).
1081  if (TemplateArgs || TemplateKWLoc.isValid())
1082  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/false, TemplateArgs);
1083 
1084  return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl,
1085  FoundDecl, TemplateArgs);
1086  }
1087  SourceLocation Loc = R.getNameLoc();
1088  if (SS.getRange().isValid())
1089  Loc = SS.getRange().getBegin();
1090  BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
1091  }
1092 
1093  // Check the use of this member.
1094  if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
1095  return ExprError();
1096 
1097  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1098  return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
1099  MemberNameInfo);
1100 
1101  if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1102  return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1103  MemberNameInfo);
1104 
1105  if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1106  // We may have found a field within an anonymous union or struct
1107  // (C++ [class.union]).
1108  return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1109  FoundDecl, BaseExpr,
1110  OpLoc);
1111 
1112  if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1113  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
1114  FoundDecl, /*HadMultipleCandidates=*/false,
1115  MemberNameInfo, Var->getType().getNonReferenceType(),
1117  }
1118 
1119  if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1120  ExprValueKind valueKind;
1121  QualType type;
1122  if (MemberFn->isInstance()) {
1123  valueKind = VK_PRValue;
1125  } else {
1126  valueKind = VK_LValue;
1127  type = MemberFn->getType();
1128  }
1129 
1130  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
1131  MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
1132  MemberNameInfo, type, valueKind, OK_Ordinary);
1133  }
1134  assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
1135 
1136  if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1137  return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
1138  FoundDecl, /*HadMultipleCandidates=*/false,
1139  MemberNameInfo, Enum->getType(), VK_PRValue,
1140  OK_Ordinary);
1141  }
1142 
1143  if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
1144  if (!TemplateArgs) {
1145  diagnoseMissingTemplateArguments(TemplateName(VarTempl), MemberLoc);
1146  return ExprError();
1147  }
1148 
1149  DeclResult VDecl = CheckVarTemplateId(VarTempl, TemplateKWLoc,
1150  MemberNameInfo.getLoc(), *TemplateArgs);
1151  if (VDecl.isInvalid())
1152  return ExprError();
1153 
1154  // Non-dependent member, but dependent template arguments.
1155  if (!VDecl.get())
1156  return ActOnDependentMemberExpr(
1157  BaseExpr, BaseExpr->getType(), IsArrow, OpLoc, SS, TemplateKWLoc,
1158  FirstQualifierInScope, MemberNameInfo, TemplateArgs);
1159 
1160  VarDecl *Var = cast<VarDecl>(VDecl.get());
1161  if (!Var->getTemplateSpecializationKind())
1163 
1164  return BuildMemberExpr(
1165  BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
1166  /*HadMultipleCandidates=*/false, MemberNameInfo,
1168  }
1169 
1170  // We found something that we didn't expect. Complain.
1171  if (isa<TypeDecl>(MemberDecl))
1172  Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1173  << MemberName << BaseType << int(IsArrow);
1174  else
1175  Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1176  << MemberName << BaseType << int(IsArrow);
1177 
1178  Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1179  << MemberName;
1180  R.suppressDiagnostics();
1181  return ExprError();
1182 }
1183 
1184 /// Given that normal member access failed on the given expression,
1185 /// and given that the expression's type involves builtin-id or
1186 /// builtin-Class, decide whether substituting in the redefinition
1187 /// types would be profitable. The redefinition type is whatever
1188 /// this translation unit tried to typedef to id/Class; we store
1189 /// it to the side and then re-use it in places like this.
1191  const ObjCObjectPointerType *opty
1192  = base.get()->getType()->getAs<ObjCObjectPointerType>();
1193  if (!opty) return false;
1194 
1195  const ObjCObjectType *ty = opty->getObjectType();
1196 
1197  QualType redef;
1198  if (ty->isObjCId()) {
1199  redef = S.Context.getObjCIdRedefinitionType();
1200  } else if (ty->isObjCClass()) {
1202  } else {
1203  return false;
1204  }
1205 
1206  // Do the substitution as long as the redefinition type isn't just a
1207  // possibly-qualified pointer to builtin-id or builtin-Class again.
1208  opty = redef->getAs<ObjCObjectPointerType>();
1209  if (opty && !opty->getObjectType()->getInterface())
1210  return false;
1211 
1212  base = S.ImpCastExprToType(base.get(), redef, CK_BitCast);
1213  return true;
1214 }
1215 
1216 static bool isRecordType(QualType T) {
1217  return T->isRecordType();
1218 }
1220  if (const PointerType *PT = T->getAs<PointerType>())
1221  return PT->getPointeeType()->isRecordType();
1222  return false;
1223 }
1224 
1225 /// Perform conversions on the LHS of a member access expression.
1226 ExprResult
1228  if (IsArrow && !Base->getType()->isFunctionType())
1230 
1231  return CheckPlaceholderExpr(Base);
1232 }
1233 
1234 /// Look up the given member of the given non-type-dependent
1235 /// expression. This can return in one of two ways:
1236 /// * If it returns a sentinel null-but-valid result, the caller will
1237 /// assume that lookup was performed and the results written into
1238 /// the provided structure. It will take over from there.
1239 /// * Otherwise, the returned expression will be produced in place of
1240 /// an ordinary member expression.
1241 ///
1242 /// The ObjCImpDecl bit is a gross hack that will need to be properly
1243 /// fixed for ObjC++.
1245  ExprResult &BaseExpr, bool &IsArrow,
1246  SourceLocation OpLoc, CXXScopeSpec &SS,
1247  Decl *ObjCImpDecl, bool HasTemplateArgs,
1248  SourceLocation TemplateKWLoc) {
1249  assert(BaseExpr.get() && "no base expression");
1250 
1251  // Perform default conversions.
1252  BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow);
1253  if (BaseExpr.isInvalid())
1254  return ExprError();
1255 
1256  QualType BaseType = BaseExpr.get()->getType();
1257  assert(!BaseType->isDependentType());
1258 
1259  DeclarationName MemberName = R.getLookupName();
1260  SourceLocation MemberLoc = R.getNameLoc();
1261 
1262  // For later type-checking purposes, turn arrow accesses into dot
1263  // accesses. The only access type we support that doesn't follow
1264  // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1265  // and those never use arrows, so this is unaffected.
1266  if (IsArrow) {
1267  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1268  BaseType = Ptr->getPointeeType();
1269  else if (const ObjCObjectPointerType *Ptr
1270  = BaseType->getAs<ObjCObjectPointerType>())
1271  BaseType = Ptr->getPointeeType();
1272  else if (BaseType->isRecordType()) {
1273  // Recover from arrow accesses to records, e.g.:
1274  // struct MyRecord foo;
1275  // foo->bar
1276  // This is actually well-formed in C++ if MyRecord has an
1277  // overloaded operator->, but that should have been dealt with
1278  // by now--or a diagnostic message already issued if a problem
1279  // was encountered while looking for the overloaded operator->.
1280  if (!S.getLangOpts().CPlusPlus) {
1281  S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1282  << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1283  << FixItHint::CreateReplacement(OpLoc, ".");
1284  }
1285  IsArrow = false;
1286  } else if (BaseType->isFunctionType()) {
1287  goto fail;
1288  } else {
1289  S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1290  << BaseType << BaseExpr.get()->getSourceRange();
1291  return ExprError();
1292  }
1293  }
1294 
1295  // If the base type is an atomic type, this access is undefined behavior per
1296  // C11 6.5.2.3p5. Instead of giving a typecheck error, we'll warn the user
1297  // about the UB and recover by converting the atomic lvalue into a non-atomic
1298  // lvalue. Because this is inherently unsafe as an atomic operation, the
1299  // warning defaults to an error.
1300  if (const auto *ATy = BaseType->getAs<AtomicType>()) {
1301  S.DiagRuntimeBehavior(OpLoc, nullptr,
1302  S.PDiag(diag::warn_atomic_member_access));
1303  BaseType = ATy->getValueType().getUnqualifiedType();
1304  BaseExpr = ImplicitCastExpr::Create(
1305  S.Context, IsArrow ? S.Context.getPointerType(BaseType) : BaseType,
1306  CK_AtomicToNonAtomic, BaseExpr.get(), nullptr,
1307  BaseExpr.get()->getValueKind(), FPOptionsOverride());
1308  }
1309 
1310  // Handle field access to simple records.
1311  if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
1312  TypoExpr *TE = nullptr;
1313  if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy, OpLoc, IsArrow, SS,
1314  HasTemplateArgs, TemplateKWLoc, TE))
1315  return ExprError();
1316 
1317  // Returning valid-but-null is how we indicate to the caller that
1318  // the lookup result was filled in. If typo correction was attempted and
1319  // failed, the lookup result will have been cleared--that combined with the
1320  // valid-but-null ExprResult will trigger the appropriate diagnostics.
1321  return ExprResult(TE);
1322  }
1323 
1324  // Handle ivar access to Objective-C objects.
1325  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
1326  if (!SS.isEmpty() && !SS.isInvalid()) {
1327  S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1328  << 1 << SS.getScopeRep()
1330  SS.clear();
1331  }
1332 
1333  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1334 
1335  // There are three cases for the base type:
1336  // - builtin id (qualified or unqualified)
1337  // - builtin Class (qualified or unqualified)
1338  // - an interface
1339  ObjCInterfaceDecl *IDecl = OTy->getInterface();
1340  if (!IDecl) {
1341  if (S.getLangOpts().ObjCAutoRefCount &&
1342  (OTy->isObjCId() || OTy->isObjCClass()))
1343  goto fail;
1344  // There's an implicit 'isa' ivar on all objects.
1345  // But we only actually find it this way on objects of type 'id',
1346  // apparently.
1347  if (OTy->isObjCId() && Member->isStr("isa"))
1348  return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc,
1349  OpLoc, S.Context.getObjCClassType());
1350  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1351  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1352  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1353  goto fail;
1354  }
1355 
1356  if (S.RequireCompleteType(OpLoc, BaseType,
1357  diag::err_typecheck_incomplete_tag,
1358  BaseExpr.get()))
1359  return ExprError();
1360 
1361  ObjCInterfaceDecl *ClassDeclared = nullptr;
1362  ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1363 
1364  if (!IV) {
1365  // Attempt to correct for typos in ivar names.
1366  DeclFilterCCC<ObjCIvarDecl> Validator{};
1367  Validator.IsObjCIvarLookup = IsArrow;
1368  if (TypoCorrection Corrected = S.CorrectTypo(
1369  R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
1370  Validator, Sema::CTK_ErrorRecovery, IDecl)) {
1371  IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1372  S.diagnoseTypo(
1373  Corrected,
1374  S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1375  << IDecl->getDeclName() << MemberName);
1376 
1377  // Figure out the class that declares the ivar.
1378  assert(!ClassDeclared);
1379 
1380  Decl *D = cast<Decl>(IV->getDeclContext());
1381  if (auto *Category = dyn_cast<ObjCCategoryDecl>(D))
1382  D = Category->getClassInterface();
1383 
1384  if (auto *Implementation = dyn_cast<ObjCImplementationDecl>(D))
1385  ClassDeclared = Implementation->getClassInterface();
1386  else if (auto *Interface = dyn_cast<ObjCInterfaceDecl>(D))
1387  ClassDeclared = Interface;
1388 
1389  assert(ClassDeclared && "cannot query interface");
1390  } else {
1391  if (IsArrow &&
1392  IDecl->FindPropertyDeclaration(
1394  S.Diag(MemberLoc, diag::err_property_found_suggest)
1395  << Member << BaseExpr.get()->getType()
1396  << FixItHint::CreateReplacement(OpLoc, ".");
1397  return ExprError();
1398  }
1399 
1400  S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1401  << IDecl->getDeclName() << MemberName
1402  << BaseExpr.get()->getSourceRange();
1403  return ExprError();
1404  }
1405  }
1406 
1407  assert(ClassDeclared);
1408 
1409  // If the decl being referenced had an error, return an error for this
1410  // sub-expr without emitting another error, in order to avoid cascading
1411  // error cases.
1412  if (IV->isInvalidDecl())
1413  return ExprError();
1414 
1415  // Check whether we can reference this field.
1416  if (S.DiagnoseUseOfDecl(IV, MemberLoc))
1417  return ExprError();
1418  if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1420  ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1421  if (ObjCMethodDecl *MD = S.getCurMethodDecl())
1422  ClassOfMethodDecl = MD->getClassInterface();
1423  else if (ObjCImpDecl && S.getCurFunctionDecl()) {
1424  // Case of a c-function declared inside an objc implementation.
1425  // FIXME: For a c-style function nested inside an objc implementation
1426  // class, there is no implementation context available, so we pass
1427  // down the context as argument to this routine. Ideally, this context
1428  // need be passed down in the AST node and somehow calculated from the
1429  // AST for a function decl.
1430  if (ObjCImplementationDecl *IMPD =
1431  dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1432  ClassOfMethodDecl = IMPD->getClassInterface();
1433  else if (ObjCCategoryImplDecl* CatImplClass =
1434  dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1435  ClassOfMethodDecl = CatImplClass->getClassInterface();
1436  }
1437  if (!S.getLangOpts().DebuggerSupport) {
1438  if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1439  if (!declaresSameEntity(ClassDeclared, IDecl) ||
1440  !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1441  S.Diag(MemberLoc, diag::err_private_ivar_access)
1442  << IV->getDeclName();
1443  } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1444  // @protected
1445  S.Diag(MemberLoc, diag::err_protected_ivar_access)
1446  << IV->getDeclName();
1447  }
1448  }
1449  bool warn = true;
1450  if (S.getLangOpts().ObjCWeak) {
1451  Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1452  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1453  if (UO->getOpcode() == UO_Deref)
1454  BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1455 
1456  if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1457  if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1458  S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);
1459  warn = false;
1460  }
1461  }
1462  if (warn) {
1463  if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
1464  ObjCMethodFamily MF = MD->getMethodFamily();
1465  warn = (MF != OMF_init && MF != OMF_dealloc &&
1466  MF != OMF_finalize &&
1467  !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1468  }
1469  if (warn)
1470  S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1471  }
1472 
1473  ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
1474  IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
1475  IsArrow);
1476 
1477  if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1478  if (!S.isUnevaluatedContext() &&
1479  !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
1480  S.getCurFunction()->recordUseOfWeak(Result);
1481  }
1482 
1483  return Result;
1484  }
1485 
1486  // Objective-C property access.
1487  const ObjCObjectPointerType *OPT;
1488  if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
1489  if (!SS.isEmpty() && !SS.isInvalid()) {
1490  S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1491  << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());
1492  SS.clear();
1493  }
1494 
1495  // This actually uses the base as an r-value.
1496  BaseExpr = S.DefaultLvalueConversion(BaseExpr.get());
1497  if (BaseExpr.isInvalid())
1498  return ExprError();
1499 
1500  assert(S.Context.hasSameUnqualifiedType(BaseType,
1501  BaseExpr.get()->getType()));
1502 
1503  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1504 
1505  const ObjCObjectType *OT = OPT->getObjectType();
1506 
1507  // id, with and without qualifiers.
1508  if (OT->isObjCId()) {
1509  // Check protocols on qualified interfaces.
1511  if (Decl *PMDecl =
1512  FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
1513  if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1514  // Check the use of this declaration
1515  if (S.DiagnoseUseOfDecl(PD, MemberLoc))
1516  return ExprError();
1517 
1518  return new (S.Context)
1520  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1521  }
1522 
1523  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1524  Selector SetterSel =
1526  S.PP.getSelectorTable(),
1527  Member);
1528  ObjCMethodDecl *SMD = nullptr;
1529  if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
1530  /*Property id*/ nullptr,
1531  SetterSel, S.Context))
1532  SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1533 
1534  return new (S.Context)
1536  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1537  }
1538  }
1539  // Use of id.member can only be for a property reference. Do not
1540  // use the 'id' redefinition in this case.
1541  if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1542  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1543  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1544 
1545  return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1546  << MemberName << BaseType);
1547  }
1548 
1549  // 'Class', unqualified only.
1550  if (OT->isObjCClass()) {
1551  // Only works in a method declaration (??!).
1552  ObjCMethodDecl *MD = S.getCurMethodDecl();
1553  if (!MD) {
1554  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1555  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1556  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1557 
1558  goto fail;
1559  }
1560 
1561  // Also must look for a getter name which uses property syntax.
1563  ObjCInterfaceDecl *IFace = MD->getClassInterface();
1564  if (!IFace)
1565  goto fail;
1566 
1567  ObjCMethodDecl *Getter;
1568  if ((Getter = IFace->lookupClassMethod(Sel))) {
1569  // Check the use of this method.
1570  if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
1571  return ExprError();
1572  } else
1573  Getter = IFace->lookupPrivateMethod(Sel, false);
1574  // If we found a getter then this may be a valid dot-reference, we
1575  // will look for the matching setter, in case it is needed.
1576  Selector SetterSel =
1578  S.PP.getSelectorTable(),
1579  Member);
1580  ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1581  if (!Setter) {
1582  // If this reference is in an @implementation, also check for 'private'
1583  // methods.
1584  Setter = IFace->lookupPrivateMethod(SetterSel, false);
1585  }
1586 
1587  if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))
1588  return ExprError();
1589 
1590  if (Getter || Setter) {
1591  return new (S.Context) ObjCPropertyRefExpr(
1592  Getter, Setter, S.Context.PseudoObjectTy, VK_LValue,
1593  OK_ObjCProperty, MemberLoc, BaseExpr.get());
1594  }
1595 
1596  if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1597  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1598  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1599 
1600  return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1601  << MemberName << BaseType);
1602  }
1603 
1604  // Normal property access.
1605  return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName,
1606  MemberLoc, SourceLocation(), QualType(),
1607  false);
1608  }
1609 
1610  if (BaseType->isExtVectorBoolType()) {
1611  // We disallow element access for ext_vector_type bool. There is no way to
1612  // materialize a reference to a vector element as a pointer (each element is
1613  // one bit in the vector).
1614  S.Diag(R.getNameLoc(), diag::err_ext_vector_component_name_illegal)
1615  << MemberName
1616  << (BaseExpr.get() ? BaseExpr.get()->getSourceRange() : SourceRange());
1617  return ExprError();
1618  }
1619 
1620  // Handle 'field access' to vectors, such as 'V.xx'.
1621  if (BaseType->isExtVectorType()) {
1622  // FIXME: this expr should store IsArrow.
1623  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1624  ExprValueKind VK;
1625  if (IsArrow)
1626  VK = VK_LValue;
1627  else {
1628  if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(BaseExpr.get()))
1629  VK = POE->getSyntacticForm()->getValueKind();
1630  else
1631  VK = BaseExpr.get()->getValueKind();
1632  }
1633 
1634  QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc,
1635  Member, MemberLoc);
1636  if (ret.isNull())
1637  return ExprError();
1638  Qualifiers BaseQ =
1639  S.Context.getCanonicalType(BaseExpr.get()->getType()).getQualifiers();
1640  ret = S.Context.getQualifiedType(ret, BaseQ);
1641 
1642  return new (S.Context)
1643  ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc);
1644  }
1645 
1646  // Adjust builtin-sel to the appropriate redefinition type if that's
1647  // not just a pointer to builtin-sel again.
1648  if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1650  BaseExpr = S.ImpCastExprToType(
1651  BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast);
1652  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1653  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1654  }
1655 
1656  // Failure cases.
1657  fail:
1658 
1659  // Recover from dot accesses to pointers, e.g.:
1660  // type *foo;
1661  // foo.bar
1662  // This is actually well-formed in two cases:
1663  // - 'type' is an Objective C type
1664  // - 'bar' is a pseudo-destructor name which happens to refer to
1665  // the appropriate pointer type
1666  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1667  if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1669  S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1670  << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1671  << FixItHint::CreateReplacement(OpLoc, "->");
1672 
1673  if (S.isSFINAEContext())
1674  return ExprError();
1675 
1676  // Recurse as an -> access.
1677  IsArrow = true;
1678  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1679  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1680  }
1681  }
1682 
1683  // If the user is trying to apply -> or . to a function name, it's probably
1684  // because they forgot parentheses to call that function.
1685  if (S.tryToRecoverWithCall(
1686  BaseExpr, S.PDiag(diag::err_member_reference_needs_call),
1687  /*complain*/ false,
1688  IsArrow ? &isPointerToRecordType : &isRecordType)) {
1689  if (BaseExpr.isInvalid())
1690  return ExprError();
1691  BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get());
1692  return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1693  ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1694  }
1695 
1696  S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1697  << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1698 
1699  return ExprError();
1700 }
1701 
1702 /// The main callback when the parser finds something like
1703 /// expression . [nested-name-specifier] identifier
1704 /// expression -> [nested-name-specifier] identifier
1705 /// where 'identifier' encompasses a fairly broad spectrum of
1706 /// possibilities, including destructor and operator references.
1707 ///
1708 /// \param OpKind either tok::arrow or tok::period
1709 /// \param ObjCImpDecl the current Objective-C \@implementation
1710 /// decl; this is an ugly hack around the fact that Objective-C
1711 /// \@implementations aren't properly put in the context chain
1713  SourceLocation OpLoc,
1714  tok::TokenKind OpKind,
1715  CXXScopeSpec &SS,
1716  SourceLocation TemplateKWLoc,
1717  UnqualifiedId &Id,
1718  Decl *ObjCImpDecl) {
1719  if (SS.isSet() && SS.isInvalid())
1720  return ExprError();
1721 
1722  // Warn about the explicit constructor calls Microsoft extension.
1723  if (getLangOpts().MicrosoftExt &&
1725  Diag(Id.getSourceRange().getBegin(),
1726  diag::ext_ms_explicit_constructor_call);
1727 
1728  TemplateArgumentListInfo TemplateArgsBuffer;
1729 
1730  // Decompose the name into its component parts.
1731  DeclarationNameInfo NameInfo;
1732  const TemplateArgumentListInfo *TemplateArgs;
1733  DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1734  NameInfo, TemplateArgs);
1735 
1736  DeclarationName Name = NameInfo.getName();
1737  bool IsArrow = (OpKind == tok::arrow);
1738 
1739  if (getLangOpts().HLSL && IsArrow)
1740  return ExprError(Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 2);
1741 
1742  NamedDecl *FirstQualifierInScope
1743  = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep()));
1744 
1745  // This is a postfix expression, so get rid of ParenListExprs.
1747  if (Result.isInvalid()) return ExprError();
1748  Base = Result.get();
1749 
1750  if (Base->getType()->isDependentType() || Name.isDependentName() ||
1752  return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS,
1753  TemplateKWLoc, FirstQualifierInScope,
1754  NameInfo, TemplateArgs);
1755  }
1756 
1757  ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl};
1759  Base, Base->getType(), OpLoc, IsArrow, SS, TemplateKWLoc,
1760  FirstQualifierInScope, NameInfo, TemplateArgs, S, &ExtraArgs);
1761 
1762  if (!Res.isInvalid() && isa<MemberExpr>(Res.get()))
1763  CheckMemberAccessOfNoDeref(cast<MemberExpr>(Res.get()));
1764 
1765  return Res;
1766 }
1767 
1768 void Sema::CheckMemberAccessOfNoDeref(const MemberExpr *E) {
1769  if (isUnevaluatedContext())
1770  return;
1771 
1772  QualType ResultTy = E->getType();
1773 
1774  // Member accesses have four cases:
1775  // 1: non-array member via "->": dereferences
1776  // 2: non-array member via ".": nothing interesting happens
1777  // 3: array member access via "->": nothing interesting happens
1778  // (this returns an array lvalue and does not actually dereference memory)
1779  // 4: array member access via ".": *adds* a layer of indirection
1780  if (ResultTy->isArrayType()) {
1781  if (!E->isArrow()) {
1782  // This might be something like:
1783  // (*structPtr).arrayMember
1784  // which behaves roughly like:
1785  // &(*structPtr).pointerMember
1786  // in that the apparent dereference in the base expression does not
1787  // actually happen.
1788  CheckAddressOfNoDeref(E->getBase());
1789  }
1790  } else if (E->isArrow()) {
1791  if (const auto *Ptr = dyn_cast<PointerType>(
1793  if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
1794  ExprEvalContexts.back().PossibleDerefs.insert(E);
1795  }
1796  }
1797 }
1798 
1799 ExprResult
1800 Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
1801  SourceLocation OpLoc, const CXXScopeSpec &SS,
1802  FieldDecl *Field, DeclAccessPair FoundDecl,
1803  const DeclarationNameInfo &MemberNameInfo) {
1804  // x.a is an l-value if 'a' has a reference type. Otherwise:
1805  // x.a is an l-value/x-value/pr-value if the base is (and note
1806  // that *x is always an l-value), except that if the base isn't
1807  // an ordinary object then we must have an rvalue.
1808  ExprValueKind VK = VK_LValue;
1810  if (!IsArrow) {
1811  if (BaseExpr->getObjectKind() == OK_Ordinary)
1812  VK = BaseExpr->getValueKind();
1813  else
1814  VK = VK_PRValue;
1815  }
1816  if (VK != VK_PRValue && Field->isBitField())
1817  OK = OK_BitField;
1818 
1819  // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1820  QualType MemberType = Field->getType();
1821  if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1822  MemberType = Ref->getPointeeType();
1823  VK = VK_LValue;
1824  } else {
1825  QualType BaseType = BaseExpr->getType();
1826  if (IsArrow) BaseType = BaseType->castAs<PointerType>()->getPointeeType();
1827 
1828  Qualifiers BaseQuals = BaseType.getQualifiers();
1829 
1830  // GC attributes are never picked up by members.
1831  BaseQuals.removeObjCGCAttr();
1832 
1833  // CVR attributes from the base are picked up by members,
1834  // except that 'mutable' members don't pick up 'const'.
1835  if (Field->isMutable()) BaseQuals.removeConst();
1836 
1837  Qualifiers MemberQuals =
1838  Context.getCanonicalType(MemberType).getQualifiers();
1839 
1840  assert(!MemberQuals.hasAddressSpace());
1841 
1842  Qualifiers Combined = BaseQuals + MemberQuals;
1843  if (Combined != MemberQuals)
1844  MemberType = Context.getQualifiedType(MemberType, Combined);
1845 
1846  // Pick up NoDeref from the base in case we end up using AddrOf on the
1847  // result. E.g. the expression
1848  // &someNoDerefPtr->pointerMember
1849  // should be a noderef pointer again.
1850  if (BaseType->hasAttr(attr::NoDeref))
1851  MemberType =
1852  Context.getAttributedType(attr::NoDeref, MemberType, MemberType);
1853  }
1854 
1855  auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1856  if (!(CurMethod && CurMethod->isDefaulted()))
1857  UnusedPrivateFields.remove(Field);
1858 
1860  FoundDecl, Field);
1861  if (Base.isInvalid())
1862  return ExprError();
1863 
1864  // Build a reference to a private copy for non-static data members in
1865  // non-static member functions, privatized by OpenMP constructs.
1866  if (getLangOpts().OpenMP && IsArrow &&
1868  isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
1869  if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
1870  return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
1871  MemberNameInfo.getLoc());
1872  }
1873  }
1874 
1875  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
1876  /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
1877  /*HadMultipleCandidates=*/false, MemberNameInfo,
1878  MemberType, VK, OK);
1879 }
1880 
1881 /// Builds an implicit member access expression. The current context
1882 /// is known to be an instance method, and the given unqualified lookup
1883 /// set is known to contain only instance members, at least one of which
1884 /// is from an appropriate type.
1885 ExprResult
1887  SourceLocation TemplateKWLoc,
1888  LookupResult &R,
1889  const TemplateArgumentListInfo *TemplateArgs,
1890  bool IsKnownInstance, const Scope *S) {
1891  assert(!R.empty() && !R.isAmbiguous());
1892 
1893  SourceLocation loc = R.getNameLoc();
1894 
1895  // If this is known to be an instance access, go ahead and build an
1896  // implicit 'this' expression now.
1897  QualType ThisTy = getCurrentThisType();
1898  assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'");
1899 
1900  Expr *baseExpr = nullptr; // null signifies implicit access
1901  if (IsKnownInstance) {
1902  SourceLocation Loc = R.getNameLoc();
1903  if (SS.getRange().isValid())
1904  Loc = SS.getRange().getBegin();
1905  baseExpr = BuildCXXThisExpr(loc, ThisTy, /*IsImplicit=*/true);
1906  }
1907 
1908  return BuildMemberReferenceExpr(baseExpr, ThisTy,
1909  /*OpLoc*/ SourceLocation(),
1910  /*IsArrow*/ true,
1911  SS, TemplateKWLoc,
1912  /*FirstQualifierInScope*/ nullptr,
1913  R, TemplateArgs, S);
1914 }
clang::CorrectionCandidateCallback::IsObjCIvarLookup
bool IsObjCIvarLookup
Definition: TypoCorrection.h:336
clang::UnqualifiedId
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:950
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1150
clang::Sema::BuildDeclarationNameExpr
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:3217
clang::Sema::CurContext
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:422
clang::Expr::getValueKind
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:430
clang::ASTContext::getQualifiedType
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2126
clang::ASTContext::getTypedefType
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
Definition: ASTContext.cpp:4603
clang::Sema::LookupTemplateName
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
Definition: SemaTemplate.cpp:374
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6838
clang::Sema::isDependentScopeSpecifier
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
Definition: SemaCXXScopeSpec.cpp:167
clang::Sema::CorrectTypoDelayed
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...
Definition: SemaLookup.cpp:5193
clang::QualType::getObjCLifetime
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1128
IMA_Instance
@ IMA_Instance
The reference is definitely an implicit instance member access.
Definition: SemaExprMember.cpp:56
clang::Sema::CheckPlaceholderExpr
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:20438
IMA_Field_Uneval_Context
@ IMA_Field_Uneval_Context
Definition: SemaExprMember.cpp:71
clang::ObjCProtocolDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2117
clang::Type::hasAttr
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
Definition: Type.cpp:1776
clang::IndirectFieldDecl::chain_begin
chain_iterator chain_begin() const
Definition: Decl.h:3134
clang::UnresolvedSetIterator::getPair
const DeclAccessPair & getPair() const
Definition: UnresolvedSet.h:54
clang::VarDecl::setTemplateSpecializationKind
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:2771
clang::OK_Ordinary
@ OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:136
clang::NamedDecl::isCXXInstanceMember
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1866
type
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:2092
clang::LangOptions::getOpenCLCompatibleVersion
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Definition: LangOptions.cpp:55
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::ObjCMethodFamily
ObjCMethodFamily
A family of Objective-C methods.
Definition: IdentifierTable.h:690
clang::LookupResult::end
iterator end() const
Definition: Lookup.h:336
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1356
clang::LookupResult::isSingleResult
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:308
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
clang::IndirectFieldDecl::chain_end
chain_iterator chain_end() const
Definition: Decl.h:3135
clang::Sema::MarkMemberReferenced
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
Definition: SemaExpr.cpp:19497
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2548
clang::Sema::isOpenMPCapturedDecl
VarDecl * isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo=false, unsigned StopAt=0)
Check if the specified variable is used in one of the private clauses (private, firstprivate,...
Definition: SemaOpenMP.cpp:2206
clang::Sema::getCurFunction
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1939
IMA_Static
@ IMA_Static
The reference is definitely not an instance member access.
Definition: SemaExprMember.cpp:42
Diag
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.
Definition: LiteralSupport.cpp:78
clang::Qualifiers::OCL_Weak
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:178
SemaInternal.h
clang::Sema::ExpressionEvaluationContext::UnevaluatedAbstract
@ UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
clang::ExtVectorType::getPointAccessorIdx
static int getPointAccessorIdx(char c)
Definition: Type.h:3370
clang::Sema::RequireCompleteDeclContext
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
Definition: SemaCXXScopeSpec.cpp:199
Lookup.h
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::MSPropertyRefExpr
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:923
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6527
clang::Sema::ActOnStartCXXMemberReference
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
Definition: SemaExprCXX.cpp:7443
clang::DiagnosticsEngine::isIgnored
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:910
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:219
clang::Sema::TemporaryMaterializationConversion
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
Definition: SemaInit.cpp:7978
clang::MemberExpr::Create
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:1625
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:457
clang::QualType::getNonReferenceType
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6696
clang::ASTContext::PseudoObjectTy
CanQualType PseudoObjectTy
Definition: ASTContext.h:1126
clang::ASTContext::getObjCSelRedefinitionType
QualType getObjCSelRedefinitionType() const
Retrieve the type that 'SEL' has been defined to, which may be different from the built-in 'SEL' if '...
Definition: ASTContext.h:1860
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
clang::UnresolvedMemberExpr
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
Definition: ExprCXX.h:3827
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:675
clang::Expr::getObjectKind
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:437
clang::ObjCIvarDecl::getAccessControl
AccessControl getAccessControl() const
Definition: DeclObjC.h:1972
clang::ObjCInterfaceDecl::lookupClassMethod
ObjCMethodDecl * lookupClassMethod(Selector Sel) const
Lookup a class method for a given selector.
Definition: DeclObjC.h:1830
clang::OMF_finalize
@ OMF_finalize
Definition: IdentifierTable.h:708
clang::OMF_init
@ OMF_init
Definition: IdentifierTable.h:700
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2855
clang::LookupResult
Represents the results of name lookup.
Definition: Lookup.h:46
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:147
clang::Sema::BuildMemberReferenceExpr
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)
Definition: SemaExprMember.cpp:743
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:773
clang::isUnresolvedExceptionSpec
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
Definition: ExceptionSpecificationType.h:49
clang::Sema::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: Sema.cpp:1871
DeclCXX.h
clang::Type::isObjCSelType
bool isObjCSelType() const
Definition: Type.h:6921
int
__device__ int
Definition: __clang_hip_libdevice_declares.h:63
clang::ObjCMethodDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1176
clang::Sema::ActOnMemberAccessExpr
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 .
Definition: SemaExprMember.cpp:1712
clang::ExprObjectKind
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:134
clang::SourceRange::isValid
bool isValid() const
Definition: SourceLocation.h:225
clang::Sema::ExpressionEvaluationContext::DiscardedStatement
@ DiscardedStatement
The current expression occurs within a discarded statement.
clang::Sema::LookupQualifiedName
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Definition: SemaLookup.cpp:2180
clang::Sema::ActOnMemberAccessExtraArgs::S
Scope * S
Definition: Sema.h:5508
llvm::SmallPtrSet
Definition: ASTContext.h:82
clang::UnaryOperator
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2163
clang::Expr::isPRValue
bool isPRValue() const
Definition: Expr.h:271
clang::Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
@ PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
IMA_Mixed_StaticContext
@ IMA_Mixed_StaticContext
The reference may be to an instance member, but it might be invalid if so, because the context is not...
Definition: SemaExprMember.cpp:49
clang::CXXScopeSpec
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:64
clang::ASTContext::getObjCIdRedefinitionType
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:1834
ASTLambda.h
clang::DeclarationName::getAsIdentifierInfo
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
Definition: DeclarationName.h:419
clang::Sema::ActOnMemberAccessExtraArgs::Id
UnqualifiedId & Id
Definition: Sema.h:5509
clang::ObjCIvarDecl::Public
@ Public
Definition: DeclObjC.h:1928
clang::Sema::ExprEvalContexts
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1360
FindGetterSetterNameDecl
static Decl * FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
Definition: SemaExprMember.cpp:449
clang::ObjCObjectType::getInterface
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
Definition: Type.h:6127
clang::Expr::IgnoreImpCasts
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2927
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::LookupResult::begin
iterator begin() const
Definition: Lookup.h:335
clang::LookupResult::getNameLoc
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:606
clang::ObjCObjectPointerType::getObjectType
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:6185
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:1001
clang::Sema::isUnevaluatedContext
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
Definition: Sema.h:9288
clang::sema::FunctionScopeInfo::recordUseOfWeak
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
Definition: ScopeInfo.h:1041
diagnoseInstanceReference
static void diagnoseInstanceReference(Sema &SemaRef, const CXXScopeSpec &SS, NamedDecl *Rep, const DeclarationNameInfo &nameInfo)
Diagnose a reference to a field with no object available.
Definition: SemaExprMember.cpp:197
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:410
Preprocessor.h
Overload.h
clang::Sema::BuildFieldReferenceExpr
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
Definition: SemaExprMember.cpp:1800
clang::DeclContext::getNonTransparentContext
DeclContext * getNonTransparentContext()
Definition: DeclBase.cpp:1233
clang::ExprError
ExprResult ExprError()
Definition: Ownership.h:278
clang::CXXScopeSpec::clear
void clear()
Definition: DeclSpec.h:212
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5892
clang::Sema::SFINAETrap
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:9303
clang::Type::isExtVectorType
bool isExtVectorType() const
Definition: Type.h:6854
DeclObjC.h
clang::ASTContext::getAttributedType
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
Definition: ASTContext.cpp:4680
clang::CXXScopeSpec::isSet
bool isSet() const
Deprecated.
Definition: DeclSpec.h:210
clang::LookupResult::isUnresolvableResult
bool isUnresolvableResult() const
Definition: Lookup.h:317
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::ASTContext::BoundMemberTy
CanQualType BoundMemberTy
Definition: ASTContext.h:1124
clang::Sema::getLangOpts
const LangOptions & getLangOpts() const
Definition: Sema.h:1607
clang::IndirectFieldDecl::chain_iterator
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Definition: Decl.h:3129
clang::ObjCObjectPointerType::quals
qual_range quals() const
Definition: Type.h:6267
clang::Sema::getCurFunctionDecl
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false)
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
Definition: Sema.cpp:1451
clang::Sema::LookupMemberName
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:4092
clang::Sema::RequireCompleteType
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:8523
IMA_Unresolved_StaticContext
@ IMA_Unresolved_StaticContext
The reference may be to an unresolved using declaration and the context is not an instance method.
Definition: SemaExprMember.cpp:66
clang::Sema::BuildAnonymousStructUnionMemberReference
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
Definition: SemaExprMember.cpp:802
clang::ASTContext::getExtVectorType
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
Definition: ASTContext.cpp:4056
clang::Sema::ExpressionEvaluationContext::UnevaluatedList
@ UnevaluatedList
The current expression occurs within a braced-init-list within an unevaluated operand.
clang::Sema::CheckVarTemplateId
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
Get the specialization of the given variable template corresponding to the specified argument list,...
Definition: SemaTemplate.cpp:4500
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4647
DeclTemplate.h
clang::UnresolvedLookupExpr
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3090
clang::TemplateArgumentListInfo
A convenient class for passing around template argument information.
Definition: TemplateBase.h:563
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
IsInFnTryBlockHandler
static bool IsInFnTryBlockHandler(const Scope *S)
Determine if the given scope is within a function-try-block handler.
Definition: SemaExprMember.cpp:938
clang::DeclAccessPair::make
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
Definition: DeclAccessPair.h:35
clang::Sema::HandleExprPropertyRefExpr
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.
Definition: SemaExprObjC.cpp:1976
DiagnoseQualifiedMemberReference
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 ...
Definition: SemaExprMember.cpp:525
Id
int Id
Definition: ASTDiff.cpp:191
clang::MemberExpr::setHadMultipleCandidates
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:3374
IMA_Abstract
@ IMA_Abstract
The reference is a contextually-permitted abstract member reference.
Definition: SemaExprMember.cpp:62
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::MemberExpr::isArrow
bool isArrow() const
Definition: Expr.h:3348
clang::DeclarationName::CXXDestructorName
@ CXXDestructorName
Definition: DeclarationName.h:213
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:220
clang::DeclAccessPair
A POD class for pairing a NamedDecl* with an access specifier.
Definition: DeclAccessPair.h:29
clang::OMF_dealloc
@ OMF_dealloc
Definition: IdentifierTable.h:707
clang::Sema::DefaultFunctionArrayConversion
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:502
clang::FPOptionsOverride
Represents difference between two FPOptions values.
Definition: LangOptions.h:713
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:208
clang::ExprResult
ActionResult< Expr * > ExprResult
Definition: Ownership.h:262
clang::ObjCInterfaceDecl::lookupPrivateMethod
ObjCMethodDecl * lookupPrivateMethod(const Selector &Sel, bool Instance=true) const
Lookup a method in the classes implementation hierarchy.
Definition: DeclObjC.cpp:749
clang::DeclaratorContext::Member
@ Member
clang::LazyVector::end
iterator end()
Definition: ExternalASTSource.h:545
clang::Qualifiers::removeConst
void removeConst()
Definition: Type.h:266
clang::Preprocessor::getSelectorTable
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:1003
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7243
clang::Sema::SFINAETrap::hasErrorOccurred
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:9334
clang::OK_BitField
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:139
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:553
clang::Sema::FindFirstQualifierInScope
NamedDecl * FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS)
If the given nested-name-specifier begins with a bare identifier (e.g., Base::), perform name lookup ...
Definition: SemaCXXScopeSpec.cpp:372
clang::Sema::ExpressionEvaluationContext::Unevaluated
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
IsRGBA
static bool IsRGBA(char c)
Determine whether input char is from rgba component set.
Definition: SemaExprMember.cpp:273
clang::ObjCInterfaceDecl::lookupInstanceVariable
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:630
clang::Sema::ActOnMemberAccessExtraArgs::ObjCImpDecl
Decl * ObjCImpDecl
Definition: Sema.h:5510
clang::CanQual::getQualifiers
Qualifiers getQualifiers() const
Retrieve all qualifiers.
Definition: CanonicalType.h:129
clang::IdentifierInfo::getLength
unsigned getLength() const
Efficiently return the length of this identifier info.
Definition: IdentifierTable.h:192
clang::Sema::Diags
DiagnosticsEngine & Diags
Definition: Sema.h:412
clang::Sema::DiagRuntimeBehavior
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:19716
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6100
clang::Sema::PDiag
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
clang::ImplicitCastExpr::Create
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition: Expr.cpp:1974
clang::Type::isFunctionType
bool isFunctionType() const
Definition: Type.h:6744
clang::Sema::ActOnDependentMemberExpr
ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: SemaExprMember.cpp:480
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
clang::UnqualifiedIdKind::IK_ConstructorName
@ IK_ConstructorName
A constructor name.
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::ASTContext::getObjCClassType
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:2055
Category
int Category
Definition: Format.cpp:2554
IMA_Unresolved
@ IMA_Unresolved
The reference may be to an unresolved using declaration.
Definition: SemaExprMember.cpp:59
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::Sema::DefaultFunctionArrayLvalueConversion
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:736
clang::ObjCIvarDecl::Private
@ Private
Definition: DeclObjC.h:1928
clang::Type::isExtVectorBoolType
bool isExtVectorBoolType() const
Definition: Type.h:6858
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Definition: DeclObjC.h:2495
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2508
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3070
clang::CXXRecordDecl::forallBases
bool forallBases(ForallBasesCallback BaseMatches) const
Determines if the given callback holds for all the direct or indirect base classes of this type.
Definition: CXXInheritance.cpp:127
ExprObjC.h
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::Qualifiers::hasAddressSpace
bool hasAddressSpace() const
Definition: Type.h:362
clang::LookupResult::getLookupName
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:243
ExprCXX.h
Base
clang::DeclContext::isRecord
bool isRecord() const
Definition: DeclBase.h:1955
clang::Sema::ResolveExceptionSpec
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Definition: SemaExceptionSpec.cpp:209
ClassifyImplicitMemberAccess
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.
Definition: SemaExprMember.cpp:88
IMA_Mixed
@ IMA_Mixed
The reference may be an implicit instance member access.
Definition: SemaExprMember.cpp:45
clang::Sema::getOpenMPCapturedExpr
ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK, ExprObjectKind OK, SourceLocation Loc)
Definition: SemaOpenMP.cpp:17158
clang::Sema::BuildMemberExpr
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)
Definition: SemaExprMember.cpp:895
isPointerToRecordType
static bool isPointerToRecordType(QualType T)
Definition: SemaExprMember.cpp:1219
clang::CXXScopeSpec::getWithLocInContext
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition: DeclSpec.cpp:151
clang::Sema::MaybeConvertParenListExprToParenExpr
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
Definition: SemaExpr.cpp:8051
clang::Sema::LookupNameKind
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:4080
clang::DeclarationName::isDependentName
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
Definition: DeclarationName.cpp:222
clang::DeclarationNameInfo::getName
DeclarationName getName() const
getName - Returns the embedded declaration name.
Definition: DeclarationName.h:790
clang::Sema::CorrectTypo
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...
Definition: SemaLookup.cpp:5058
FindGetterSetterNameDeclFromProtocolList
static Decl * FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl *PDecl, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
Definition: SemaExprMember.cpp:430
clang::OpaquePtr< QualType >
clang::Sema::UnusedPrivateFields
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:833
clang::VK_LValue
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:124
clang::Sema::diagnoseTypo
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Definition: SemaLookup.cpp:5355
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7310
clang::Sema::PerformObjectMemberConversion
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
Definition: SemaExpr.cpp:2996
clang::QualType::getDesugaredType
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:987
clang::Expr::IgnoreParenCasts
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2952
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:6148
clang::MemberExpr::getBase
Expr * getBase() const
Definition: Expr.h:3241
clang::Sema::BuildImplicitMemberExpr
ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, bool IsDefiniteInstance, const Scope *S)
Builds an implicit member access expression.
Definition: SemaExprMember.cpp:1886
clang::TemplateArgumentListInfo::arguments
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:591
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
IMA_Error_StaticContext
@ IMA_Error_StaticContext
All possible referrents are instance members and the current context is not an instance method.
Definition: SemaExprMember.cpp:75
clang::Sema::getExternalSource
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1617
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
clang::Sema::computeDeclContext
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Definition: SemaCXXScopeSpec.cpp:53
clang::Sema::CTK_ErrorRecovery
@ CTK_ErrorRecovery
Definition: Sema.h:4322
clang::Type::isDependentType
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2185
clang::VK_PRValue
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:120
clang::LookupResult::suppressDiagnostics
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
clang::Sema::ImpCastExprToType
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:632
clang::LookupResult::empty
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
clang::Sema::CheckQualifiedMemberReference
bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, const LookupResult &R)
Definition: SemaExprMember.cpp:552
clang::Type::isPointerType
bool isPointerType() const
Definition: Type.h:6748
clang::ObjCObjectType::isObjCClass
bool isObjCClass() const
Definition: Type.h:5961
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:169
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::Sema::tryToRecoverWithCall
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:2581
BuildMSPropertyRefExpr
static ExprResult BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow, const CXXScopeSpec &SS, MSPropertyDecl *PD, const DeclarationNameInfo &NameInfo)
Definition: SemaExprMember.cpp:883
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
clang::Sema::RedeclarationKind
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:4134
isProvablyNotDerivedFrom
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.
Definition: SemaExprMember.cpp:32
IMA_Error_Unrelated
@ IMA_Error_Unrelated
All possible referrents are instance members of an unrelated class.
Definition: SemaExprMember.cpp:79
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3898
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1876
clang::SelectorTable::constructSetterSelector
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
Definition: IdentifierTable.cpp:694
BaseSet
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > BaseSet
Definition: SemaExprMember.cpp:28
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:740
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::LookupResult::setBaseObjectType
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:420
Scope.h
clang::Expr::IgnoreParenImpCasts
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2947
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:732
CheckExtVectorComponent
static QualType CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK, SourceLocation OpLoc, const IdentifierInfo *CompName, SourceLocation CompLoc)
Check an ext-vector component access expression.
Definition: SemaExprMember.cpp:298
clang::Sema::DefaultLvalueConversion
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:626
clang::ExtVectorType::isAccessorWithinNumElements
bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const
Definition: Type.h:3415
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:354
clang::ActionResult::isInvalid
bool isInvalid() const
Definition: Ownership.h:165
clang::Sema::DiagnoseUseOfDecl
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:221
clang::VarDecl::getTemplateSpecializationKind
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:2651
clang::Sema::IvarBacksCurrentMethodAccessor
bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, ObjCMethodDecl *Method, ObjCIvarDecl *IV)
IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is an ivar synthesized for 'Meth...
Definition: SemaObjCProperty.cpp:1837
clang::LazyVector::begin
iterator begin(Source *source, bool LocalOnly=false)
Definition: ExternalASTSource.h:536
clang::DeclContext::Encloses
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1222
clang::Sema::getCurMethodDecl
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1456
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:117
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::Sema::getFunctionLevelDeclContext
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false)
If AllowLambda is true, treat lambda as function.
Definition: Sema.cpp:1431
clang::Sema::isThisOutsideMemberFunctionBody
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...
Definition: SemaExprCXX.cpp:1400
clang::Qualifiers::removeObjCGCAttr
void removeObjCGCAttr()
Definition: Type.h:315
clang::Sema::BuildPossibleImplicitMemberExpr
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
Definition: SemaExprMember.cpp:235
clang::IdentifierInfo::getNameStart
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
Definition: IdentifierTable.h:189
clang::ActionResult< Expr * >
clang::SelectorTable::getNullarySelector
Selector getNullarySelector(IdentifierInfo *ID)
Definition: IdentifierTable.h:917
clang::DeclFilterCCC
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
Definition: TypoCorrection.h:366
clang::Sema::ExpressionEvaluationContext::ConstantEvaluated
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5910
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::Sema::ExtVectorDecls
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
Definition: Sema.h:825
clang::OK_ObjCProperty
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:146
clang::TypoExpr
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:6367
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2653
ScopeInfo.h
clang::ObjCPropertyQueryKind::OBJC_PR_query_instance
@ OBJC_PR_query_instance
isRecordType
static bool isRecordType(QualType T)
Definition: SemaExprMember.cpp:1216
IMAKind
IMAKind
Definition: SemaExprMember.cpp:40
clang::Sema::CXXThisTypeOverride
QualType CXXThisTypeOverride
When non-NULL, the C++ 'this' expression is allowed despite the current context not being a non-stati...
Definition: Sema.h:6364
clang::Sema::getCurScope
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:13167
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:393
clang::IndirectFieldDecl::getVarDecl
VarDecl * getVarDecl() const
Definition: Decl.h:3144
clang::Expr::setType
void setType(QualType t)
Definition: Expr.h:142
IMA_Mixed_Unrelated
@ IMA_Mixed_Unrelated
The reference may be to an instance member, but it is invalid if so, because the context is from an u...
Definition: SemaExprMember.cpp:53
clang
Definition: CalledOnceCheck.h:17
clang::ObjCContainerDecl::getInstanceMethod
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:1062
clang::IndirectFieldDecl
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3109
clang::Sema::PerformMemberExprBaseConversion
ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow)
Perform conversions on the LHS of a member access expression.
Definition: SemaExprMember.cpp:1227
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3283
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:752
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6814
clang::ExtVectorType::getNumericAccessorIdx
static int getNumericAccessorIdx(char c)
Definition: Type.h:3380
clang::ASTContext::getObjCClassRedefinitionType
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:1847
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1923
clang::MSPropertyDecl
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4107
clang::CXXRecordDecl::getCanonicalDecl
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:501
clang::ObjCIsaExpr
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1482
clang::TypoCorrection::getCorrectionDecl
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
Definition: TypoCorrection.h:151
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2052
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::CXXScopeSpec::getScopeRep
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:77
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::CorrectionCandidateCallback
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Definition: TypoCorrection.h:281
clang::Sema::ActOnMemberAccessExtraArgs
Definition: Sema.h:5507
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:311
clang::FixItHint::CreateRemoval
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:123
LookupMemberExpr
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.
Definition: SemaExprMember.cpp:1244
clang::DeclContext::isDependentContext
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1152
clang::LookupResult::getLookupKind
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
IsValidOpenCLComponentSwizzleLength
static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
Definition: SemaExprMember.cpp:288
clang::DeclarationNameInfo::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
Definition: DeclarationName.h:872
clang::Sema::isSFINAEContext
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Definition: SemaTemplateInstantiate.cpp:849
clang::ObjCContainerDecl::FindPropertyDeclaration
ObjCPropertyDecl * FindPropertyDeclaration(const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const
FindPropertyDeclaration - Finds declaration of the property given its name in 'PropertyId' and return...
Definition: DeclObjC.cpp:249
clang::ObjCObjectType::isObjCId
bool isObjCId() const
Definition: Type.h:5957
clang::Sema::BuildTemplateIdExpr
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
Definition: SemaTemplate.cpp:4720
clang::LookupResult::getFoundDecl
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
c
__device__ __2f16 float c
Definition: __clang_hip_libdevice_declares.h:315
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3164
clang::CXXDependentScopeMemberExpr::Create
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:1408
clang::ObjCInterfaceDecl::isSuperClassOf
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:1788
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4657
clang::ASTContext::getPointerType
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Definition: ASTContext.cpp:3260
clang::ExtVectorType
ExtVectorType - Extended vector type.
Definition: Type.h:3363
clang::Sema::diagnoseMissingTemplateArguments
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
Definition: SemaTemplate.cpp:4675
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2764
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2663
clang::LookupResult::getSema
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition: Lookup.h:612
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3284
clang::Sema::getNonOdrUseReasonInCurrentContext
NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D)
If D cannot be odr-used in the current expression evaluation context, return a reason explaining why.
Definition: SemaExpr.cpp:2045
clang::AtomicType
Definition: Type.h:6318
clang::Scope::TryScope
@ TryScope
This is the scope of a C++ try statement.
Definition: Scope.h:101
clang::CXXRecordDecl::isProvablyNotDerivedFrom
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
Definition: CXXInheritance.cpp:109
clang::ObjCIvarDecl::getUsageType
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:1870
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:685
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3096
clang::ASTContext::hasSameUnqualifiedType
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2548
clang::Sema::DecomposeUnqualifiedId
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Decomposes the given name into a DeclarationNameInfo, its location, and possibly a list of template a...
Definition: SemaExpr.cpp:2143
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::CXXScopeSpec::isEmpty
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:190
clang::Type::isSpecificBuiltinType
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:7006
clang::CXXScopeSpec::getRange
SourceRange getRange() const
Definition: DeclSpec.h:69
clang::Sema::getCurrentThisType
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
Definition: SemaExprCXX.cpp:1188
clang::TSK_ImplicitInstantiation
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:179
clang::Sema::PP
Preprocessor & PP
Definition: Sema.h:409
clang::DeclarationNameInfo::getLoc
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
Definition: DeclarationName.h:796
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:767
clang::UnresolvedMemberExpr::Create
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:1500
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:425
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1223
ShouldTryAgainWithRedefinitionType
static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base)
Given that normal member access failed on the given expression, and given that the expression's type ...
Definition: SemaExprMember.cpp:1190
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3901
clang::DeclContext::Equals
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2000
clang::LookupResult::getLookupNameInfo
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
clang::ObjCIvarRefExpr
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:548
clang::ActionResult::isUsable
bool isUsable() const
Definition: Ownership.h:166
clang::LookupResult::getRepresentativeDecl
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:524
clang::LookupResult::isOverloadedResult
bool isOverloadedResult() const
Determines if the results are overloaded.
Definition: Lookup.h:313
clang::FixItHint::CreateReplacement
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:134
LookupMemberExprInRecord
static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, Expr *BaseExpr, const RecordType *RTy, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, bool HasTemplateArgs, SourceLocation TemplateKWLoc, TypoExpr *&TE)
Definition: SemaExprMember.cpp:640
clang::Sema::BuildCXXThisExpr
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
Definition: SemaExprCXX.cpp:1389
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1207
clang::Sema::ExpressionEvaluationContext::ImmediateFunctionContext
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2083
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1968
clang::CXXScopeSpec::isInvalid
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:195
clang::ObjCIvarDecl::Package
@ Package
Definition: DeclObjC.h:1928
clang::LookupResult::isAmbiguous
bool isAmbiguous() const
Definition: Lookup.h:301
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:434
clang::LookupResult::redeclarationKind
Sema::RedeclarationKind redeclarationKind() const
Definition: Lookup.h:268
clang::Sema::ExpressionEvaluationContext::PotentiallyEvaluated
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...