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