Bug Summary

File:clang/lib/Sema/SemaExprMember.cpp
Warning:line 412, column 12
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaExprMember.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-09-002921-48462-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp
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"
23#include "clang/Sema/SemaInternal.h"
24
25using namespace clang;
26using namespace sema;
27
28typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> BaseSet;
29
30/// Determines if the given class is provably not derived from all of
31/// the prospective base classes.
32static 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
40enum IMAKind {
41 /// The reference is definitely not an instance member access.
42 IMA_Static,
43
44 /// The reference may be an implicit instance member access.
45 IMA_Mixed,
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.
49 IMA_Mixed_StaticContext,
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.
53 IMA_Mixed_Unrelated,
54
55 /// The reference is definitely an implicit instance member access.
56 IMA_Instance,
57
58 /// The reference may be to an unresolved using declaration.
59 IMA_Unresolved,
60
61 /// The reference is a contextually-permitted abstract member reference.
62 IMA_Abstract,
63
64 /// The reference may be to an unresolved using declaration and the
65 /// context is not an instance method.
66 IMA_Unresolved_StaticContext,
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.
71 IMA_Field_Uneval_Context,
72
73 /// All possible referrents are instance members and the current
74 /// context is not an instance method.
75 IMA_Error_StaticContext,
76
77 /// All possible referrents are instance members of an unrelated
78 /// class.
79 IMA_Error_Unrelated
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.
88static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef,
89 const LookupResult &R) {
90 assert(!R.empty() && (*R.begin())->isCXXClassMember())((!R.empty() && (*R.begin())->isCXXClassMember()) ?
static_cast<void> (0) : __assert_fail ("!R.empty() && (*R.begin())->isCXXClassMember()"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 90, __PRETTY_FUNCTION__))
;
91
92 DeclContext *DC = SemaRef.getFunctionLevelDeclContext();
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)((!AbstractInstanceResult) ? static_cast<void> (0) : __assert_fail
("!AbstractInstanceResult", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 133, __PRETTY_FUNCTION__))
;
134 switch (SemaRef.ExprEvalContexts.back().Context) {
135 case Sema::ExpressionEvaluationContext::Unevaluated:
136 case Sema::ExpressionEvaluationContext::UnevaluatedList:
137 if (isField && SemaRef.getLangOpts().CPlusPlus11)
138 AbstractInstanceResult = IMA_Field_Uneval_Context;
139 break;
140
141 case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
142 AbstractInstanceResult = IMA_Abstract;
143 break;
144
145 case Sema::ExpressionEvaluationContext::DiscardedStatement:
146 case Sema::ExpressionEvaluationContext::ConstantEvaluated:
147 case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
148 case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
149 break;
150 }
151
152 // If the current context is not an instance method, it can't be
153 // an implicit member reference.
154 if (isStaticContext) {
155 if (hasNonInstance)
156 return IMA_Mixed_StaticContext;
157
158 return AbstractInstanceResult ? AbstractInstanceResult
159 : IMA_Error_StaticContext;
160 }
161
162 CXXRecordDecl *contextClass;
163 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
164 contextClass = MD->getParent()->getCanonicalDecl();
165 else
166 contextClass = cast<CXXRecordDecl>(DC);
167
168 // [class.mfct.non-static]p3:
169 // ...is used in the body of a non-static member function of class X,
170 // if name lookup (3.4.1) resolves the name in the id-expression to a
171 // non-static non-type member of some class C [...]
172 // ...if C is not X or a base class of X, the class member access expression
173 // is ill-formed.
174 if (R.getNamingClass() &&
175 contextClass->getCanonicalDecl() !=
176 R.getNamingClass()->getCanonicalDecl()) {
177 // If the naming class is not the current context, this was a qualified
178 // member name lookup, and it's sufficient to check that we have the naming
179 // class as a base class.
180 Classes.clear();
181 Classes.insert(R.getNamingClass()->getCanonicalDecl());
182 }
183
184 // If we can prove that the current context is unrelated to all the
185 // declaring classes, it can't be an implicit member reference (in
186 // which case it's an error if any of those members are selected).
187 if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes))
188 return hasNonInstance ? IMA_Mixed_Unrelated :
189 AbstractInstanceResult ? AbstractInstanceResult :
190 IMA_Error_Unrelated;
191
192 return (hasNonInstance ? IMA_Mixed : IMA_Instance);
193}
194
195/// Diagnose a reference to a field with no object available.
196static void diagnoseInstanceReference(Sema &SemaRef,
197 const CXXScopeSpec &SS,
198 NamedDecl *Rep,
199 const DeclarationNameInfo &nameInfo) {
200 SourceLocation Loc = nameInfo.getLoc();
201 SourceRange Range(Loc);
202 if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
203
204 // Look through using shadow decls and aliases.
205 Rep = Rep->getUnderlyingDecl();
206
207 DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
208 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
209 CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr;
210 CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
211
212 bool InStaticMethod = Method && Method->isStatic();
213 bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep);
214
215 if (IsField && InStaticMethod)
216 // "invalid use of member 'x' in static member function"
217 SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
218 << Range << nameInfo.getName();
219 else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod &&
220 !RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass))
221 // Unqualified lookup in a non-static member function found a member of an
222 // enclosing class.
223 SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
224 << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
225 else if (IsField)
226 SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
227 << nameInfo.getName() << Range;
228 else
229 SemaRef.Diag(Loc, diag::err_member_call_without_object)
230 << Range;
231}
232
233/// Builds an expression which might be an implicit member expression.
234ExprResult
235Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
236 SourceLocation TemplateKWLoc,
237 LookupResult &R,
238 const TemplateArgumentListInfo *TemplateArgs,
239 const Scope *S) {
240 switch (ClassifyImplicitMemberAccess(*this, R)) {
241 case IMA_Instance:
242 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true, S);
243
244 case IMA_Mixed:
245 case IMA_Mixed_Unrelated:
246 case IMA_Unresolved:
247 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false,
248 S);
249
250 case IMA_Field_Uneval_Context:
251 Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use)
252 << R.getLookupNameInfo().getName();
253 LLVM_FALLTHROUGH[[gnu::fallthrough]];
254 case IMA_Static:
255 case IMA_Abstract:
256 case IMA_Mixed_StaticContext:
257 case IMA_Unresolved_StaticContext:
258 if (TemplateArgs || TemplateKWLoc.isValid())
259 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs);
260 return BuildDeclarationNameExpr(SS, R, false);
261
262 case IMA_Error_StaticContext:
263 case IMA_Error_Unrelated:
264 diagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(),
265 R.getLookupNameInfo());
266 return ExprError();
267 }
268
269 llvm_unreachable("unexpected instance member access kind")::llvm::llvm_unreachable_internal("unexpected instance member access kind"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 269)
;
270}
271
272/// Determine whether input char is from rgba component set.
273static bool
274IsRGBA(char c) {
275 switch (c) {
276 case 'r':
277 case 'g':
278 case 'b':
279 case 'a':
280 return true;
281 default:
282 return false;
283 }
284}
285
286// OpenCL v1.1, s6.1.7
287// The component swizzle length must be in accordance with the acceptable
288// vector sizes.
289static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
290{
291 return (len >= 1 && len <= 4) || len == 8 || len == 16;
292}
293
294/// Check an ext-vector component access expression.
295///
296/// VK should be set in advance to the value kind of the base
297/// expression.
298static QualType
299CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK,
300 SourceLocation OpLoc, const IdentifierInfo *CompName,
301 SourceLocation CompLoc) {
302 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
303 // see FIXME there.
304 //
305 // FIXME: This logic can be greatly simplified by splitting it along
306 // halving/not halving and reworking the component checking.
307 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
20
Assuming the object is not a 'ExtVectorType'
21
'vecType' initialized to a null pointer value
308
309 // The vector accessor can't exceed the number of elements.
310 const char *compStr = CompName->getNameStart();
311
312 // This flag determines whether or not the component is one of the four
313 // special names that indicate a subset of exactly half the elements are
314 // to be selected.
315 bool HalvingSwizzle = false;
316
317 // This flag determines whether or not CompName has an 's' char prefix,
318 // indicating that it is a string of hex values to be used as vector indices.
319 bool HexSwizzle = (*compStr == 's' || *compStr == 'S') && compStr[1];
22
Assuming the condition is false
23
Assuming the condition is false
320
321 bool HasRepeated = false;
322 bool HasIndex[16] = {};
323
324 int Idx;
325
326 // Check that we've found one of the special components, or that the component
327 // names must come from the same set.
328 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
24
Assuming the condition is false
25
Assuming the condition is false
28
Taking false branch
329 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
26
Assuming the condition is false
27
Assuming the condition is false
330 HalvingSwizzle = true;
331 } else if (!HexSwizzle
28.1
'HexSwizzle' is false
&&
29
Taking false branch
332 (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
333 bool HasRGBA = IsRGBA(*compStr);
334 do {
335 // Ensure that xyzw and rgba components don't intermingle.
336 if (HasRGBA != IsRGBA(*compStr))
337 break;
338 if (HasIndex[Idx]) HasRepeated = true;
339 HasIndex[Idx] = true;
340 compStr++;
341 } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
342
343 // Emit a warning if an rgba selector is used earlier than OpenCL 2.2
344 if (HasRGBA || (*compStr && IsRGBA(*compStr))) {
345 if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion < 220) {
346 const char *DiagBegin = HasRGBA ? CompName->getNameStart() : compStr;
347 S.Diag(OpLoc, diag::ext_opencl_ext_vector_type_rgba_selector)
348 << StringRef(DiagBegin, 1)
349 << S.getLangOpts().OpenCLVersion << SourceRange(CompLoc);
350 }
351 }
352 } else {
353 if (HexSwizzle
29.1
'HexSwizzle' is false
) compStr++;
30
Taking false branch
354 while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
31
Loop condition is false. Execution continues on line 361
355 if (HasIndex[Idx]) HasRepeated = true;
356 HasIndex[Idx] = true;
357 compStr++;
358 }
359 }
360
361 if (!HalvingSwizzle
31.1
'HalvingSwizzle' is false
&& *compStr) {
32
Assuming the condition is false
33
Taking false branch
362 // We didn't get to the end of the string. This means the component names
363 // didn't come from the same set *or* we encountered an illegal name.
364 S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
365 << StringRef(compStr, 1) << SourceRange(CompLoc);
366 return QualType();
367 }
368
369 // Ensure no component accessor exceeds the width of the vector type it
370 // operates on.
371 if (!HalvingSwizzle
33.1
'HalvingSwizzle' is false
) {
34
Taking true branch
372 compStr = CompName->getNameStart();
373
374 if (HexSwizzle
34.1
'HexSwizzle' is false
)
35
Taking false branch
375 compStr++;
376
377 while (*compStr) {
36
Loop condition is false. Execution continues on line 388
378 if (!vecType->isAccessorWithinNumElements(*compStr++, HexSwizzle)) {
379 S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
380 << baseType << SourceRange(CompLoc);
381 return QualType();
382 }
383 }
384 }
385
386 // OpenCL mode requires swizzle length to be in accordance with accepted
387 // sizes. Clang however supports arbitrary lengths for other languages.
388 if (S.getLangOpts().OpenCL && !HalvingSwizzle) {
37
Assuming field 'OpenCL' is 0
389 unsigned SwizzleLength = CompName->getLength();
390
391 if (HexSwizzle)
392 SwizzleLength--;
393
394 if (IsValidOpenCLComponentSwizzleLength(SwizzleLength) == false) {
395 S.Diag(OpLoc, diag::err_opencl_ext_vector_component_invalid_length)
396 << SwizzleLength << SourceRange(CompLoc);
397 return QualType();
398 }
399 }
400
401 // The component accessor looks fine - now we need to compute the actual type.
402 // The vector type is implied by the component accessor. For example,
403 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
404 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
405 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
406 unsigned CompSize = HalvingSwizzle
37.1
'HalvingSwizzle' is false
? (vecType->getNumElements() + 1) / 2
38
'?' condition is false
407 : CompName->getLength();
408 if (HexSwizzle
38.1
'HexSwizzle' is false
)
39
Taking false branch
409 CompSize--;
410
411 if (CompSize == 1)
40
Assuming 'CompSize' is equal to 1
41
Taking true branch
412 return vecType->getElementType();
42
Called C++ object pointer is null
413
414 if (HasRepeated) VK = VK_RValue;
415
416 QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
417 // Now look up the TypeDefDecl from the vector type. Without this,
418 // diagostics look bad. We want extended vector types to appear built-in.
419 for (Sema::ExtVectorDeclsType::iterator
420 I = S.ExtVectorDecls.begin(S.getExternalSource()),
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
430static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
431 IdentifierInfo *Member,
432 const Selector &Sel,
433 ASTContext &Context) {
434 if (Member)
435 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(
436 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance))
437 return PD;
438 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
439 return OMD;
440
441 for (const auto *I : PDecl->protocols()) {
442 if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel,
443 Context))
444 return D;
445 }
446 return nullptr;
447}
448
449static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy,
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(
458 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
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
479ExprResult
480Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType,
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")((BaseExpr && "cannot happen with implicit member accesses"
) ? static_cast<void> (0) : __assert_fail ("BaseExpr && \"cannot happen with implicit member accesses\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 500, __PRETTY_FUNCTION__))
;
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() ||((BaseType->isDependentType() || NameInfo.getName().isDependentName
() || isDependentScopeSpecifier(SS)) ? static_cast<void>
(0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 509, __PRETTY_FUNCTION__))
508 NameInfo.getName().isDependentName() ||((BaseType->isDependentType() || NameInfo.getName().isDependentName
() || isDependentScopeSpecifier(SS)) ? static_cast<void>
(0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 509, __PRETTY_FUNCTION__))
509 isDependentScopeSpecifier(SS))((BaseType->isDependentType() || NameInfo.getName().isDependentName
() || isDependentScopeSpecifier(SS)) ? static_cast<void>
(0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 509, __PRETTY_FUNCTION__))
;
510
511 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
512 // must have pointer type, and the accessed type is the pointee.
513 return CXXDependentScopeMemberExpr::Create(
514 Context, BaseExpr, BaseType, IsArrow, OpLoc,
515 SS.getWithLocInContext(Context), TemplateKWLoc, FirstQualifierInScope,
516 NameInfo, TemplateArgs);
517}
518
519/// We know that the given qualified member reference points only to
520/// declarations which do not belong to the static type of the base
521/// expression. Diagnose the problem.
522static void DiagnoseQualifiedMemberReference(Sema &SemaRef,
523 Expr *BaseExpr,
524 QualType BaseType,
525 const CXXScopeSpec &SS,
526 NamedDecl *rep,
527 const DeclarationNameInfo &nameInfo) {
528 // If this is an implicit member access, use a different set of
529 // diagnostics.
530 if (!BaseExpr)
531 return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
532
533 SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
534 << SS.getRange() << rep << BaseType;
535}
536
537// Check whether the declarations we found through a nested-name
538// specifier in a member expression are actually members of the base
539// type. The restriction here is:
540//
541// C++ [expr.ref]p2:
542// ... In these cases, the id-expression shall name a
543// member of the class or of one of its base classes.
544//
545// So it's perfectly legitimate for the nested-name specifier to name
546// an unrelated class, and for us to find an overload set including
547// decls from classes which are not superclasses, as long as the decl
548// we actually pick through overload resolution is from a superclass.
549bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr,
550 QualType BaseType,
551 const CXXScopeSpec &SS,
552 const LookupResult &R) {
553 CXXRecordDecl *BaseRecord =
554 cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType));
555 if (!BaseRecord) {
556 // We can't check this yet because the base type is still
557 // dependent.
558 assert(BaseType->isDependentType())((BaseType->isDependentType()) ? static_cast<void> (
0) : __assert_fail ("BaseType->isDependentType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 558, __PRETTY_FUNCTION__))
;
559 return false;
560 }
561
562 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
563 // If this is an implicit member reference and we find a
564 // non-instance member, it's not an error.
565 if (!BaseExpr && !(*I)->isCXXInstanceMember())
566 return false;
567
568 // Note that we use the DC of the decl, not the underlying decl.
569 DeclContext *DC = (*I)->getDeclContext();
570 while (DC->isTransparentContext())
571 DC = DC->getParent();
572
573 if (!DC->isRecord())
574 continue;
575
576 CXXRecordDecl *MemberRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
577 if (BaseRecord->getCanonicalDecl() == MemberRecord ||
578 !BaseRecord->isProvablyNotDerivedFrom(MemberRecord))
579 return false;
580 }
581
582 DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS,
583 R.getRepresentativeDecl(),
584 R.getLookupNameInfo());
585 return true;
586}
587
588namespace {
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.
593class RecordMemberExprValidatorCCC final : public CorrectionCandidateCallback {
594public:
595 explicit RecordMemberExprValidatorCCC(const RecordType *RTy)
596 : Record(RTy->getDecl()) {
597 // Don't add bare keywords to the consumer since they will always fail
598 // validation by virtue of not being associated with any decls.
599 WantTypeSpecifiers = false;
600 WantExpressionKeywords = false;
601 WantCXXNamedCasts = false;
602 WantFunctionLikeCasts = false;
603 WantRemainingKeywords = false;
604 }
605
606 bool ValidateCandidate(const TypoCorrection &candidate) override {
607 NamedDecl *ND = candidate.getCorrectionDecl();
608 // Don't accept candidates that cannot be member functions, constants,
609 // variables, or templates.
610 if (!ND || !(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)))
611 return false;
612
613 // Accept candidates that occur in the current record.
614 if (Record->containsDecl(ND))
615 return true;
616
617 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) {
618 // Accept candidates that occur in any of the current class' base classes.
619 for (const auto &BS : RD->bases()) {
620 if (const RecordType *BSTy =
621 dyn_cast_or_null<RecordType>(BS.getType().getTypePtrOrNull())) {
622 if (BSTy->getDecl()->containsDecl(ND))
623 return true;
624 }
625 }
626 }
627
628 return false;
629 }
630
631 std::unique_ptr<CorrectionCandidateCallback> clone() override {
632 return std::make_unique<RecordMemberExprValidatorCCC>(*this);
633 }
634
635private:
636 const RecordDecl *const Record;
637};
638
639}
640
641static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
642 Expr *BaseExpr,
643 const RecordType *RTy,
644 SourceLocation OpLoc, bool IsArrow,
645 CXXScopeSpec &SS, bool HasTemplateArgs,
646 SourceLocation TemplateKWLoc,
647 TypoExpr *&TE) {
648 SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange();
649 RecordDecl *RDecl = RTy->getDecl();
650 if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
651 SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
652 diag::err_typecheck_incomplete_tag,
653 BaseRange))
654 return true;
655
656 if (HasTemplateArgs || TemplateKWLoc.isValid()) {
657 // LookupTemplateName doesn't expect these both to exist simultaneously.
658 QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
659
660 bool MOUS;
661 return SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS,
662 TemplateKWLoc);
663 }
664
665 DeclContext *DC = RDecl;
666 if (SS.isSet()) {
667 // If the member name was a qualified-id, look into the
668 // nested-name-specifier.
669 DC = SemaRef.computeDeclContext(SS, false);
670
671 if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
672 SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
673 << SS.getRange() << DC;
674 return true;
675 }
676
677 assert(DC && "Cannot handle non-computable dependent contexts in lookup")((DC && "Cannot handle non-computable dependent contexts in lookup"
) ? static_cast<void> (0) : __assert_fail ("DC && \"Cannot handle non-computable dependent contexts in lookup\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 677, __PRETTY_FUNCTION__))
;
678
679 if (!isa<TypeDecl>(DC)) {
680 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
681 << DC << SS.getRange();
682 return true;
683 }
684 }
685
686 // The record definition is complete, now look up the member.
687 SemaRef.LookupQualifiedName(R, DC, SS);
688
689 if (!R.empty())
690 return false;
691
692 DeclarationName Typo = R.getLookupName();
693 SourceLocation TypoLoc = R.getNameLoc();
694
695 struct QueryState {
696 Sema &SemaRef;
697 DeclarationNameInfo NameInfo;
698 Sema::LookupNameKind LookupKind;
699 Sema::RedeclarationKind Redecl;
700 };
701 QueryState Q = {R.getSema(), R.getLookupNameInfo(), R.getLookupKind(),
702 R.redeclarationKind()};
703 RecordMemberExprValidatorCCC CCC(RTy);
704 TE = SemaRef.CorrectTypoDelayed(
705 R.getLookupNameInfo(), R.getLookupKind(), nullptr, &SS, CCC,
706 [=, &SemaRef](const TypoCorrection &TC) {
707 if (TC) {
708 assert(!TC.isKeyword() &&((!TC.isKeyword() && "Got a keyword as a correction for a member!"
) ? static_cast<void> (0) : __assert_fail ("!TC.isKeyword() && \"Got a keyword as a correction for a member!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 709, __PRETTY_FUNCTION__))
709 "Got a keyword as a correction for a member!")((!TC.isKeyword() && "Got a keyword as a correction for a member!"
) ? static_cast<void> (0) : __assert_fail ("!TC.isKeyword() && \"Got a keyword as a correction for a member!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 709, __PRETTY_FUNCTION__))
;
710 bool DroppedSpecifier =
711 TC.WillReplaceSpecifier() &&
712 Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts());
713 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
714 << Typo << DC << DroppedSpecifier
715 << SS.getRange());
716 } else {
717 SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange;
718 }
719 },
720 [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
721 LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
722 R.clear(); // Ensure there's no decls lingering in the shared state.
723 R.suppressDiagnostics();
724 R.setLookupName(TC.getCorrection());
725 for (NamedDecl *ND : TC)
726 R.addDecl(ND);
727 R.resolveKind();
728 return SemaRef.BuildMemberReferenceExpr(
729 BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(),
730 nullptr, R, nullptr, nullptr);
731 },
732 Sema::CTK_ErrorRecovery, DC);
733
734 return false;
735}
736
737static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
738 ExprResult &BaseExpr, bool &IsArrow,
739 SourceLocation OpLoc, CXXScopeSpec &SS,
740 Decl *ObjCImpDecl, bool HasTemplateArgs,
741 SourceLocation TemplateKWLoc);
742
743ExprResult
744Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
745 SourceLocation OpLoc, bool IsArrow,
746 CXXScopeSpec &SS,
747 SourceLocation TemplateKWLoc,
748 NamedDecl *FirstQualifierInScope,
749 const DeclarationNameInfo &NameInfo,
750 const TemplateArgumentListInfo *TemplateArgs,
751 const Scope *S,
752 ActOnMemberAccessExtraArgs *ExtraArgs) {
753 if (BaseType->isDependentType() ||
754 (SS.isSet() && isDependentScopeSpecifier(SS)))
755 return ActOnDependentMemberExpr(Base, BaseType,
756 IsArrow, OpLoc,
757 SS, TemplateKWLoc, FirstQualifierInScope,
758 NameInfo, TemplateArgs);
759
760 LookupResult R(*this, NameInfo, LookupMemberName);
761
762 // Implicit member accesses.
763 if (!Base) {
764 TypoExpr *TE = nullptr;
765 QualType RecordTy = BaseType;
766 if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType();
767 if (LookupMemberExprInRecord(
768 *this, R, nullptr, RecordTy->getAs<RecordType>(), OpLoc, IsArrow,
769 SS, TemplateArgs != nullptr, TemplateKWLoc, TE))
770 return ExprError();
771 if (TE)
772 return TE;
773
774 // Explicit member accesses.
775 } else {
776 ExprResult BaseResult = Base;
777 ExprResult Result =
778 LookupMemberExpr(*this, R, BaseResult, IsArrow, OpLoc, SS,
779 ExtraArgs ? ExtraArgs->ObjCImpDecl : nullptr,
780 TemplateArgs != nullptr, TemplateKWLoc);
781
782 if (BaseResult.isInvalid())
783 return ExprError();
784 Base = BaseResult.get();
785
786 if (Result.isInvalid())
787 return ExprError();
788
789 if (Result.get())
790 return Result;
791
792 // LookupMemberExpr can modify Base, and thus change BaseType
793 BaseType = Base->getType();
794 }
795
796 return BuildMemberReferenceExpr(Base, BaseType,
797 OpLoc, IsArrow, SS, TemplateKWLoc,
798 FirstQualifierInScope, R, TemplateArgs, S,
799 false, ExtraArgs);
800}
801
802ExprResult
803Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
804 SourceLocation loc,
805 IndirectFieldDecl *indirectField,
806 DeclAccessPair foundDecl,
807 Expr *baseObjectExpr,
808 SourceLocation opLoc) {
809 // First, build the expression that refers to the base object.
810
811 // Case 1: the base of the indirect field is not a field.
812 VarDecl *baseVariable = indirectField->getVarDecl();
813 CXXScopeSpec EmptySS;
814 if (baseVariable) {
815 assert(baseVariable->getType()->isRecordType())((baseVariable->getType()->isRecordType()) ? static_cast
<void> (0) : __assert_fail ("baseVariable->getType()->isRecordType()"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 815, __PRETTY_FUNCTION__))
;
816
817 // In principle we could have a member access expression that
818 // accesses an anonymous struct/union that's a static member of
819 // the base object's class. However, under the current standard,
820 // static data members cannot be anonymous structs or unions.
821 // Supporting this is as easy as building a MemberExpr here.
822 assert(!baseObjectExpr && "anonymous struct/union is static data member?")((!baseObjectExpr && "anonymous struct/union is static data member?"
) ? static_cast<void> (0) : __assert_fail ("!baseObjectExpr && \"anonymous struct/union is static data member?\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 822, __PRETTY_FUNCTION__))
;
823
824 DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
825
826 ExprResult result
827 = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
828 if (result.isInvalid()) return ExprError();
829
830 baseObjectExpr = result.get();
831 }
832
833 assert((baseVariable || baseObjectExpr) &&(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or "
"expression") ? static_cast<void> (0) : __assert_fail (
"(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 835, __PRETTY_FUNCTION__))
834 "referencing anonymous struct/union without a base variable or "(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or "
"expression") ? static_cast<void> (0) : __assert_fail (
"(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 835, __PRETTY_FUNCTION__))
835 "expression")(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or "
"expression") ? static_cast<void> (0) : __assert_fail (
"(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 835, __PRETTY_FUNCTION__))
;
836
837 // Build the implicit member references to the field of the
838 // anonymous struct/union.
839 Expr *result = baseObjectExpr;
840 IndirectFieldDecl::chain_iterator
841 FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
842
843 // Case 2: the base of the indirect field is a field and the user
844 // wrote a member expression.
845 if (!baseVariable) {
846 FieldDecl *field = cast<FieldDecl>(*FI);
847
848 bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
849
850 // Make a nameInfo that properly uses the anonymous name.
851 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
852
853 // Build the first member access in the chain with full information.
854 result =
855 BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
856 SS, field, foundDecl, memberNameInfo)
857 .get();
858 if (!result)
859 return ExprError();
860 }
861
862 // In all cases, we should now skip the first declaration in the chain.
863 ++FI;
864
865 while (FI != FEnd) {
866 FieldDecl *field = cast<FieldDecl>(*FI++);
867
868 // FIXME: these are somewhat meaningless
869 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
870 DeclAccessPair fakeFoundDecl =
871 DeclAccessPair::make(field, field->getAccess());
872
873 result =
874 BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
875 (FI == FEnd ? SS : EmptySS), field,
876 fakeFoundDecl, memberNameInfo)
877 .get();
878 }
879
880 return result;
881}
882
883static ExprResult
884BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
885 const CXXScopeSpec &SS,
886 MSPropertyDecl *PD,
887 const DeclarationNameInfo &NameInfo) {
888 // Property names are always simple identifiers and therefore never
889 // require any interesting additional storage.
890 return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow,
891 S.Context.PseudoObjectTy, VK_LValue,
892 SS.getWithLocInContext(S.Context),
893 NameInfo.getLoc());
894}
895
896MemberExpr *Sema::BuildMemberExpr(
897 Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS,
898 SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
899 bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
900 QualType Ty, ExprValueKind VK, ExprObjectKind OK,
901 const TemplateArgumentListInfo *TemplateArgs) {
902 NestedNameSpecifierLoc NNS =
903 SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc();
904 return BuildMemberExpr(Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member,
905 FoundDecl, HadMultipleCandidates, MemberNameInfo, Ty,
906 VK, OK, TemplateArgs);
907}
908
909MemberExpr *Sema::BuildMemberExpr(
910 Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS,
911 SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
912 bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
913 QualType Ty, ExprValueKind VK, ExprObjectKind OK,
914 const TemplateArgumentListInfo *TemplateArgs) {
915 assert((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue")(((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue"
) ? static_cast<void> (0) : __assert_fail ("(!IsArrow || Base->isRValue()) && \"-> base must be a pointer rvalue\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 915, __PRETTY_FUNCTION__))
;
916 MemberExpr *E =
917 MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc,
918 Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty,
919 VK, OK, getNonOdrUseReasonInCurrentContext(Member));
920 E->setHadMultipleCandidates(HadMultipleCandidates);
921 MarkMemberReferenced(E);
922 return E;
923}
924
925/// Determine if the given scope is within a function-try-block handler.
926static bool IsInFnTryBlockHandler(const Scope *S) {
927 // Walk the scope stack until finding a FnTryCatchScope, or leave the
928 // function scope. If a FnTryCatchScope is found, check whether the TryScope
929 // flag is set. If it is not, it's a function-try-block handler.
930 for (; S != S->getFnParent(); S = S->getParent()) {
931 if (S->getFlags() & Scope::FnTryCatchScope)
932 return (S->getFlags() & Scope::TryScope) != Scope::TryScope;
933 }
934 return false;
935}
936
937VarDecl *
938Sema::getVarTemplateSpecialization(VarTemplateDecl *VarTempl,
939 const TemplateArgumentListInfo *TemplateArgs,
940 const DeclarationNameInfo &MemberNameInfo,
941 SourceLocation TemplateKWLoc) {
942 if (!TemplateArgs) {
943 diagnoseMissingTemplateArguments(TemplateName(VarTempl),
944 MemberNameInfo.getBeginLoc());
945 return nullptr;
946 }
947
948 DeclResult VDecl = CheckVarTemplateId(VarTempl, TemplateKWLoc,
949 MemberNameInfo.getLoc(), *TemplateArgs);
950 if (VDecl.isInvalid())
951 return nullptr;
952 VarDecl *Var = cast<VarDecl>(VDecl.get());
953 if (!Var->getTemplateSpecializationKind())
954 Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
955 MemberNameInfo.getLoc());
956 return Var;
957}
958
959ExprResult
960Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
961 SourceLocation OpLoc, bool IsArrow,
962 const CXXScopeSpec &SS,
963 SourceLocation TemplateKWLoc,
964 NamedDecl *FirstQualifierInScope,
965 LookupResult &R,
966 const TemplateArgumentListInfo *TemplateArgs,
967 const Scope *S,
968 bool SuppressQualifierCheck,
969 ActOnMemberAccessExtraArgs *ExtraArgs) {
970 QualType BaseType = BaseExprType;
971 if (IsArrow) {
972 assert(BaseType->isPointerType())((BaseType->isPointerType()) ? static_cast<void> (0)
: __assert_fail ("BaseType->isPointerType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 972, __PRETTY_FUNCTION__))
;
973 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
974 }
975 R.setBaseObjectType(BaseType);
976
977 // C++1z [expr.ref]p2:
978 // For the first option (dot) the first expression shall be a glvalue [...]
979 if (!IsArrow && BaseExpr && BaseExpr->isRValue()) {
980 ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
981 if (Converted.isInvalid())
982 return ExprError();
983 BaseExpr = Converted.get();
984 }
985
986
987 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
988 DeclarationName MemberName = MemberNameInfo.getName();
989 SourceLocation MemberLoc = MemberNameInfo.getLoc();
990
991 if (R.isAmbiguous())
992 return ExprError();
993
994 // [except.handle]p10: Referring to any non-static member or base class of an
995 // object in the handler for a function-try-block of a constructor or
996 // destructor for that object results in undefined behavior.
997 const auto *FD = getCurFunctionDecl();
998 if (S && BaseExpr && FD &&
999 (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) &&
1000 isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) &&
1001 IsInFnTryBlockHandler(S))
1002 Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr)
1003 << isa<CXXDestructorDecl>(FD);
1004
1005 if (R.empty()) {
1006 // Rederive where we looked up.
1007 DeclContext *DC = (SS.isSet()
1008 ? computeDeclContext(SS, false)
1009 : BaseType->castAs<RecordType>()->getDecl());
1010
1011 if (ExtraArgs) {
1012 ExprResult RetryExpr;
1013 if (!IsArrow && BaseExpr) {
1014 SFINAETrap Trap(*this, true);
1015 ParsedType ObjectType;
1016 bool MayBePseudoDestructor = false;
1017 RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
1018 OpLoc, tok::arrow, ObjectType,
1019 MayBePseudoDestructor);
1020 if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
1021 CXXScopeSpec TempSS(SS);
1022 RetryExpr = ActOnMemberAccessExpr(
1023 ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
1024 TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl);
1025 }
1026 if (Trap.hasErrorOccurred())
1027 RetryExpr = ExprError();
1028 }
1029 if (RetryExpr.isUsable()) {
1030 Diag(OpLoc, diag::err_no_member_overloaded_arrow)
1031 << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
1032 return RetryExpr;
1033 }
1034 }
1035
1036 Diag(R.getNameLoc(), diag::err_no_member)
1037 << MemberName << DC
1038 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
1039 return ExprError();
1040 }
1041
1042 // Diagnose lookups that find only declarations from a non-base
1043 // type. This is possible for either qualified lookups (which may
1044 // have been qualified with an unrelated type) or implicit member
1045 // expressions (which were found with unqualified lookup and thus
1046 // may have come from an enclosing scope). Note that it's okay for
1047 // lookup to find declarations from a non-base type as long as those
1048 // aren't the ones picked by overload resolution.
1049 if ((SS.isSet() || !BaseExpr ||
1050 (isa<CXXThisExpr>(BaseExpr) &&
1051 cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
1052 !SuppressQualifierCheck &&
1053 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
1054 return ExprError();
1055
1056 // Construct an unresolved result if we in fact got an unresolved
1057 // result.
1058 if (R.isOverloadedResult() || R.isUnresolvableResult()) {
1059 // Suppress any lookup-related diagnostics; we'll do these when we
1060 // pick a member.
1061 R.suppressDiagnostics();
1062
1063 UnresolvedMemberExpr *MemExpr
1064 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(),
1065 BaseExpr, BaseExprType,
1066 IsArrow, OpLoc,
1067 SS.getWithLocInContext(Context),
1068 TemplateKWLoc, MemberNameInfo,
1069 TemplateArgs, R.begin(), R.end());
1070
1071 return MemExpr;
1072 }
1073
1074 assert(R.isSingleResult())((R.isSingleResult()) ? static_cast<void> (0) : __assert_fail
("R.isSingleResult()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1074, __PRETTY_FUNCTION__))
;
1075 DeclAccessPair FoundDecl = R.begin().getPair();
1076 NamedDecl *MemberDecl = R.getFoundDecl();
1077
1078 // FIXME: diagnose the presence of template arguments now.
1079
1080 // If the decl being referenced had an error, return an error for this
1081 // sub-expr without emitting another error, in order to avoid cascading
1082 // error cases.
1083 if (MemberDecl->isInvalidDecl())
1084 return ExprError();
1085
1086 // Handle the implicit-member-access case.
1087 if (!BaseExpr) {
1088 // If this is not an instance member, convert to a non-member access.
1089 if (!MemberDecl->isCXXInstanceMember()) {
1090 // If this is a variable template, get the instantiated variable
1091 // declaration corresponding to the supplied template arguments
1092 // (while emitting diagnostics as necessary) that will be referenced
1093 // by this expression.
1094 assert((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&(((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&
"How did we get template arguments here sans a variable template"
) ? static_cast<void> (0) : __assert_fail ("(!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && \"How did we get template arguments here sans a variable template\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1095, __PRETTY_FUNCTION__))
1095 "How did we get template arguments here sans a variable template")(((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&
"How did we get template arguments here sans a variable template"
) ? static_cast<void> (0) : __assert_fail ("(!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && \"How did we get template arguments here sans a variable template\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1095, __PRETTY_FUNCTION__))
;
1096 if (isa<VarTemplateDecl>(MemberDecl)) {
1097 MemberDecl = getVarTemplateSpecialization(
1098 cast<VarTemplateDecl>(MemberDecl), TemplateArgs,
1099 R.getLookupNameInfo(), TemplateKWLoc);
1100 if (!MemberDecl)
1101 return ExprError();
1102 }
1103 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl,
1104 FoundDecl, TemplateArgs);
1105 }
1106 SourceLocation Loc = R.getNameLoc();
1107 if (SS.getRange().isValid())
1108 Loc = SS.getRange().getBegin();
1109 BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
1110 }
1111
1112 // Check the use of this member.
1113 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
1114 return ExprError();
1115
1116 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1117 return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
1118 MemberNameInfo);
1119
1120 if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1121 return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1122 MemberNameInfo);
1123
1124 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1125 // We may have found a field within an anonymous union or struct
1126 // (C++ [class.union]).
1127 return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1128 FoundDecl, BaseExpr,
1129 OpLoc);
1130
1131 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1132 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
1133 FoundDecl, /*HadMultipleCandidates=*/false,
1134 MemberNameInfo, Var->getType().getNonReferenceType(),
1135 VK_LValue, OK_Ordinary);
1136 }
1137
1138 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1139 ExprValueKind valueKind;
1140 QualType type;
1141 if (MemberFn->isInstance()) {
1142 valueKind = VK_RValue;
1143 type = Context.BoundMemberTy;
1144 } else {
1145 valueKind = VK_LValue;
1146 type = MemberFn->getType();
1147 }
1148
1149 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
1150 MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
1151 MemberNameInfo, type, valueKind, OK_Ordinary);
1152 }
1153 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?")((!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?"
) ? static_cast<void> (0) : __assert_fail ("!isa<FunctionDecl>(MemberDecl) && \"member function not C++ method?\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1153, __PRETTY_FUNCTION__))
;
1154
1155 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1156 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
1157 FoundDecl, /*HadMultipleCandidates=*/false,
1158 MemberNameInfo, Enum->getType(), VK_RValue,
1159 OK_Ordinary);
1160 }
1161 if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
1162 if (VarDecl *Var = getVarTemplateSpecialization(
1163 VarTempl, TemplateArgs, MemberNameInfo, TemplateKWLoc))
1164 return BuildMemberExpr(
1165 BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
1166 /*HadMultipleCandidates=*/false, MemberNameInfo,
1167 Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary);
1168 return ExprError();
1169 }
1170
1171 // We found something that we didn't expect. Complain.
1172 if (isa<TypeDecl>(MemberDecl))
1173 Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1174 << MemberName << BaseType << int(IsArrow);
1175 else
1176 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1177 << MemberName << BaseType << int(IsArrow);
1178
1179 Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1180 << MemberName;
1181 R.suppressDiagnostics();
1182 return ExprError();
1183}
1184
1185/// Given that normal member access failed on the given expression,
1186/// and given that the expression's type involves builtin-id or
1187/// builtin-Class, decide whether substituting in the redefinition
1188/// types would be profitable. The redefinition type is whatever
1189/// this translation unit tried to typedef to id/Class; we store
1190/// it to the side and then re-use it in places like this.
1191static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) {
1192 const ObjCObjectPointerType *opty
1193 = base.get()->getType()->getAs<ObjCObjectPointerType>();
1194 if (!opty) return false;
1195
1196 const ObjCObjectType *ty = opty->getObjectType();
1197
1198 QualType redef;
1199 if (ty->isObjCId()) {
1200 redef = S.Context.getObjCIdRedefinitionType();
1201 } else if (ty->isObjCClass()) {
1202 redef = S.Context.getObjCClassRedefinitionType();
1203 } else {
1204 return false;
1205 }
1206
1207 // Do the substitution as long as the redefinition type isn't just a
1208 // possibly-qualified pointer to builtin-id or builtin-Class again.
1209 opty = redef->getAs<ObjCObjectPointerType>();
1210 if (opty && !opty->getObjectType()->getInterface())
1211 return false;
1212
1213 base = S.ImpCastExprToType(base.get(), redef, CK_BitCast);
1214 return true;
1215}
1216
1217static bool isRecordType(QualType T) {
1218 return T->isRecordType();
1219}
1220static bool isPointerToRecordType(QualType T) {
1221 if (const PointerType *PT = T->getAs<PointerType>())
1222 return PT->getPointeeType()->isRecordType();
1223 return false;
1224}
1225
1226/// Perform conversions on the LHS of a member access expression.
1227ExprResult
1228Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
1229 if (IsArrow && !Base->getType()->isFunctionType())
1230 return DefaultFunctionArrayLvalueConversion(Base);
1231
1232 return CheckPlaceholderExpr(Base);
1233}
1234
1235/// Look up the given member of the given non-type-dependent
1236/// expression. This can return in one of two ways:
1237/// * If it returns a sentinel null-but-valid result, the caller will
1238/// assume that lookup was performed and the results written into
1239/// the provided structure. It will take over from there.
1240/// * Otherwise, the returned expression will be produced in place of
1241/// an ordinary member expression.
1242///
1243/// The ObjCImpDecl bit is a gross hack that will need to be properly
1244/// fixed for ObjC++.
1245static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
1246 ExprResult &BaseExpr, bool &IsArrow,
1247 SourceLocation OpLoc, CXXScopeSpec &SS,
1248 Decl *ObjCImpDecl, bool HasTemplateArgs,
1249 SourceLocation TemplateKWLoc) {
1250 assert(BaseExpr.get() && "no base expression")((BaseExpr.get() && "no base expression") ? static_cast
<void> (0) : __assert_fail ("BaseExpr.get() && \"no base expression\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1250, __PRETTY_FUNCTION__))
;
1
Assuming the condition is true
2
'?' condition is true
1251
1252 // Perform default conversions.
1253 BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow);
1254 if (BaseExpr.isInvalid())
3
Assuming the condition is false
4
Taking false branch
1255 return ExprError();
1256
1257 QualType BaseType = BaseExpr.get()->getType();
1258 assert(!BaseType->isDependentType())((!BaseType->isDependentType()) ? static_cast<void> (
0) : __assert_fail ("!BaseType->isDependentType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1258, __PRETTY_FUNCTION__))
;
5
Assuming the condition is true
6
'?' condition is true
1259
1260 DeclarationName MemberName = R.getLookupName();
1261 SourceLocation MemberLoc = R.getNameLoc();
1262
1263 // For later type-checking purposes, turn arrow accesses into dot
1264 // accesses. The only access type we support that doesn't follow
1265 // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1266 // and those never use arrows, so this is unaffected.
1267 if (IsArrow
6.1
'IsArrow' is false
) {
7
Taking false branch
1268 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1269 BaseType = Ptr->getPointeeType();
1270 else if (const ObjCObjectPointerType *Ptr
1271 = BaseType->getAs<ObjCObjectPointerType>())
1272 BaseType = Ptr->getPointeeType();
1273 else if (BaseType->isRecordType()) {
1274 // Recover from arrow accesses to records, e.g.:
1275 // struct MyRecord foo;
1276 // foo->bar
1277 // This is actually well-formed in C++ if MyRecord has an
1278 // overloaded operator->, but that should have been dealt with
1279 // by now--or a diagnostic message already issued if a problem
1280 // was encountered while looking for the overloaded operator->.
1281 if (!S.getLangOpts().CPlusPlus) {
1282 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1283 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1284 << FixItHint::CreateReplacement(OpLoc, ".");
1285 }
1286 IsArrow = false;
1287 } else if (BaseType->isFunctionType()) {
1288 goto fail;
1289 } else {
1290 S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1291 << BaseType << BaseExpr.get()->getSourceRange();
1292 return ExprError();
1293 }
1294 }
1295
1296 // Handle field access to simple records.
1297 if (const RecordType *RTy
8.1
'RTy' is null
= BaseType->getAs<RecordType>()) {
8
Assuming the object is not a 'RecordType'
9
Taking false branch
1298 TypoExpr *TE = nullptr;
1299 if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy, OpLoc, IsArrow, SS,
1300 HasTemplateArgs, TemplateKWLoc, TE))
1301 return ExprError();
1302
1303 // Returning valid-but-null is how we indicate to the caller that
1304 // the lookup result was filled in. If typo correction was attempted and
1305 // failed, the lookup result will have been cleared--that combined with the
1306 // valid-but-null ExprResult will trigger the appropriate diagnostics.
1307 return ExprResult(TE);
1308 }
1309
1310 // Handle ivar access to Objective-C objects.
1311 if (const ObjCObjectType *OTy
10.1
'OTy' is null
= BaseType->getAs<ObjCObjectType>()) {
10
Assuming the object is not a 'ObjCObjectType'
11
Taking false branch
1312 if (!SS.isEmpty() && !SS.isInvalid()) {
1313 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1314 << 1 << SS.getScopeRep()
1315 << FixItHint::CreateRemoval(SS.getRange());
1316 SS.clear();
1317 }
1318
1319 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1320
1321 // There are three cases for the base type:
1322 // - builtin id (qualified or unqualified)
1323 // - builtin Class (qualified or unqualified)
1324 // - an interface
1325 ObjCInterfaceDecl *IDecl = OTy->getInterface();
1326 if (!IDecl) {
1327 if (S.getLangOpts().ObjCAutoRefCount &&
1328 (OTy->isObjCId() || OTy->isObjCClass()))
1329 goto fail;
1330 // There's an implicit 'isa' ivar on all objects.
1331 // But we only actually find it this way on objects of type 'id',
1332 // apparently.
1333 if (OTy->isObjCId() && Member->isStr("isa"))
1334 return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc,
1335 OpLoc, S.Context.getObjCClassType());
1336 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1337 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1338 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1339 goto fail;
1340 }
1341
1342 if (S.RequireCompleteType(OpLoc, BaseType,
1343 diag::err_typecheck_incomplete_tag,
1344 BaseExpr.get()))
1345 return ExprError();
1346
1347 ObjCInterfaceDecl *ClassDeclared = nullptr;
1348 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1349
1350 if (!IV) {
1351 // Attempt to correct for typos in ivar names.
1352 DeclFilterCCC<ObjCIvarDecl> Validator{};
1353 Validator.IsObjCIvarLookup = IsArrow;
1354 if (TypoCorrection Corrected = S.CorrectTypo(
1355 R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
1356 Validator, Sema::CTK_ErrorRecovery, IDecl)) {
1357 IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1358 S.diagnoseTypo(
1359 Corrected,
1360 S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1361 << IDecl->getDeclName() << MemberName);
1362
1363 // Figure out the class that declares the ivar.
1364 assert(!ClassDeclared)((!ClassDeclared) ? static_cast<void> (0) : __assert_fail
("!ClassDeclared", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1364, __PRETTY_FUNCTION__))
;
1365
1366 Decl *D = cast<Decl>(IV->getDeclContext());
1367 if (auto *Category = dyn_cast<ObjCCategoryDecl>(D))
1368 D = Category->getClassInterface();
1369
1370 if (auto *Implementation = dyn_cast<ObjCImplementationDecl>(D))
1371 ClassDeclared = Implementation->getClassInterface();
1372 else if (auto *Interface = dyn_cast<ObjCInterfaceDecl>(D))
1373 ClassDeclared = Interface;
1374
1375 assert(ClassDeclared && "cannot query interface")((ClassDeclared && "cannot query interface") ? static_cast
<void> (0) : __assert_fail ("ClassDeclared && \"cannot query interface\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1375, __PRETTY_FUNCTION__))
;
1376 } else {
1377 if (IsArrow &&
1378 IDecl->FindPropertyDeclaration(
1379 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
1380 S.Diag(MemberLoc, diag::err_property_found_suggest)
1381 << Member << BaseExpr.get()->getType()
1382 << FixItHint::CreateReplacement(OpLoc, ".");
1383 return ExprError();
1384 }
1385
1386 S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1387 << IDecl->getDeclName() << MemberName
1388 << BaseExpr.get()->getSourceRange();
1389 return ExprError();
1390 }
1391 }
1392
1393 assert(ClassDeclared)((ClassDeclared) ? static_cast<void> (0) : __assert_fail
("ClassDeclared", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1393, __PRETTY_FUNCTION__))
;
1394
1395 // If the decl being referenced had an error, return an error for this
1396 // sub-expr without emitting another error, in order to avoid cascading
1397 // error cases.
1398 if (IV->isInvalidDecl())
1399 return ExprError();
1400
1401 // Check whether we can reference this field.
1402 if (S.DiagnoseUseOfDecl(IV, MemberLoc))
1403 return ExprError();
1404 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1405 IV->getAccessControl() != ObjCIvarDecl::Package) {
1406 ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1407 if (ObjCMethodDecl *MD = S.getCurMethodDecl())
1408 ClassOfMethodDecl = MD->getClassInterface();
1409 else if (ObjCImpDecl && S.getCurFunctionDecl()) {
1410 // Case of a c-function declared inside an objc implementation.
1411 // FIXME: For a c-style function nested inside an objc implementation
1412 // class, there is no implementation context available, so we pass
1413 // down the context as argument to this routine. Ideally, this context
1414 // need be passed down in the AST node and somehow calculated from the
1415 // AST for a function decl.
1416 if (ObjCImplementationDecl *IMPD =
1417 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1418 ClassOfMethodDecl = IMPD->getClassInterface();
1419 else if (ObjCCategoryImplDecl* CatImplClass =
1420 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1421 ClassOfMethodDecl = CatImplClass->getClassInterface();
1422 }
1423 if (!S.getLangOpts().DebuggerSupport) {
1424 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1425 if (!declaresSameEntity(ClassDeclared, IDecl) ||
1426 !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1427 S.Diag(MemberLoc, diag::err_private_ivar_access)
1428 << IV->getDeclName();
1429 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1430 // @protected
1431 S.Diag(MemberLoc, diag::err_protected_ivar_access)
1432 << IV->getDeclName();
1433 }
1434 }
1435 bool warn = true;
1436 if (S.getLangOpts().ObjCWeak) {
1437 Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1438 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1439 if (UO->getOpcode() == UO_Deref)
1440 BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1441
1442 if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1443 if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1444 S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);
1445 warn = false;
1446 }
1447 }
1448 if (warn) {
1449 if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
1450 ObjCMethodFamily MF = MD->getMethodFamily();
1451 warn = (MF != OMF_init && MF != OMF_dealloc &&
1452 MF != OMF_finalize &&
1453 !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1454 }
1455 if (warn)
1456 S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1457 }
1458
1459 ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
1460 IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
1461 IsArrow);
1462
1463 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1464 if (!S.isUnevaluatedContext() &&
1465 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
1466 S.getCurFunction()->recordUseOfWeak(Result);
1467 }
1468
1469 return Result;
1470 }
1471
1472 // Objective-C property access.
1473 const ObjCObjectPointerType *OPT;
1474 if (!IsArrow
11.1
'IsArrow' is false
&& (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
12
Assuming the object is not a 'ObjCObjectPointerType'
13
Assuming 'OPT' is null
14
Taking false branch
1475 if (!SS.isEmpty() && !SS.isInvalid()) {
1476 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1477 << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());
1478 SS.clear();
1479 }
1480
1481 // This actually uses the base as an r-value.
1482 BaseExpr = S.DefaultLvalueConversion(BaseExpr.get());
1483 if (BaseExpr.isInvalid())
1484 return ExprError();
1485
1486 assert(S.Context.hasSameUnqualifiedType(BaseType,((S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->
getType())) ? static_cast<void> (0) : __assert_fail ("S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType())"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1487, __PRETTY_FUNCTION__))
1487 BaseExpr.get()->getType()))((S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->
getType())) ? static_cast<void> (0) : __assert_fail ("S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType())"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1487, __PRETTY_FUNCTION__))
;
1488
1489 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1490
1491 const ObjCObjectType *OT = OPT->getObjectType();
1492
1493 // id, with and without qualifiers.
1494 if (OT->isObjCId()) {
1495 // Check protocols on qualified interfaces.
1496 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1497 if (Decl *PMDecl =
1498 FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
1499 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1500 // Check the use of this declaration
1501 if (S.DiagnoseUseOfDecl(PD, MemberLoc))
1502 return ExprError();
1503
1504 return new (S.Context)
1505 ObjCPropertyRefExpr(PD, S.Context.PseudoObjectTy, VK_LValue,
1506 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1507 }
1508
1509 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1510 Selector SetterSel =
1511 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1512 S.PP.getSelectorTable(),
1513 Member);
1514 ObjCMethodDecl *SMD = nullptr;
1515 if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
1516 /*Property id*/ nullptr,
1517 SetterSel, S.Context))
1518 SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1519
1520 return new (S.Context)
1521 ObjCPropertyRefExpr(OMD, SMD, S.Context.PseudoObjectTy, VK_LValue,
1522 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1523 }
1524 }
1525 // Use of id.member can only be for a property reference. Do not
1526 // use the 'id' redefinition in this case.
1527 if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1528 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1529 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1530
1531 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1532 << MemberName << BaseType);
1533 }
1534
1535 // 'Class', unqualified only.
1536 if (OT->isObjCClass()) {
1537 // Only works in a method declaration (??!).
1538 ObjCMethodDecl *MD = S.getCurMethodDecl();
1539 if (!MD) {
1540 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1541 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1542 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1543
1544 goto fail;
1545 }
1546
1547 // Also must look for a getter name which uses property syntax.
1548 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1549 ObjCInterfaceDecl *IFace = MD->getClassInterface();
1550 if (!IFace)
1551 goto fail;
1552
1553 ObjCMethodDecl *Getter;
1554 if ((Getter = IFace->lookupClassMethod(Sel))) {
1555 // Check the use of this method.
1556 if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
1557 return ExprError();
1558 } else
1559 Getter = IFace->lookupPrivateMethod(Sel, false);
1560 // If we found a getter then this may be a valid dot-reference, we
1561 // will look for the matching setter, in case it is needed.
1562 Selector SetterSel =
1563 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1564 S.PP.getSelectorTable(),
1565 Member);
1566 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1567 if (!Setter) {
1568 // If this reference is in an @implementation, also check for 'private'
1569 // methods.
1570 Setter = IFace->lookupPrivateMethod(SetterSel, false);
1571 }
1572
1573 if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))
1574 return ExprError();
1575
1576 if (Getter || Setter) {
1577 return new (S.Context) ObjCPropertyRefExpr(
1578 Getter, Setter, S.Context.PseudoObjectTy, VK_LValue,
1579 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1580 }
1581
1582 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1583 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1584 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1585
1586 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1587 << MemberName << BaseType);
1588 }
1589
1590 // Normal property access.
1591 return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName,
1592 MemberLoc, SourceLocation(), QualType(),
1593 false);
1594 }
1595
1596 // Handle 'field access' to vectors, such as 'V.xx'.
1597 if (BaseType->isExtVectorType()) {
15
Taking true branch
1598 // FIXME: this expr should store IsArrow.
1599 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1600 ExprValueKind VK;
1601 if (IsArrow
15.1
'IsArrow' is false
)
16
Taking false branch
1602 VK = VK_LValue;
1603 else {
1604 if (PseudoObjectExpr *POE
17.1
'POE' is non-null
= dyn_cast<PseudoObjectExpr>(BaseExpr.get()))
17
Assuming the object is a 'PseudoObjectExpr'
18
Taking true branch
1605 VK = POE->getSyntacticForm()->getValueKind();
1606 else
1607 VK = BaseExpr.get()->getValueKind();
1608 }
1609
1610 QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc,
19
Calling 'CheckExtVectorComponent'
1611 Member, MemberLoc);
1612 if (ret.isNull())
1613 return ExprError();
1614 Qualifiers BaseQ =
1615 S.Context.getCanonicalType(BaseExpr.get()->getType()).getQualifiers();
1616 ret = S.Context.getQualifiedType(ret, BaseQ);
1617
1618 return new (S.Context)
1619 ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc);
1620 }
1621
1622 // Adjust builtin-sel to the appropriate redefinition type if that's
1623 // not just a pointer to builtin-sel again.
1624 if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1625 !S.Context.getObjCSelRedefinitionType()->isObjCSelType()) {
1626 BaseExpr = S.ImpCastExprToType(
1627 BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast);
1628 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1629 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1630 }
1631
1632 // Failure cases.
1633 fail:
1634
1635 // Recover from dot accesses to pointers, e.g.:
1636 // type *foo;
1637 // foo.bar
1638 // This is actually well-formed in two cases:
1639 // - 'type' is an Objective C type
1640 // - 'bar' is a pseudo-destructor name which happens to refer to
1641 // the appropriate pointer type
1642 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1643 if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1644 MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
1645 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1646 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1647 << FixItHint::CreateReplacement(OpLoc, "->");
1648
1649 // Recurse as an -> access.
1650 IsArrow = true;
1651 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1652 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1653 }
1654 }
1655
1656 // If the user is trying to apply -> or . to a function name, it's probably
1657 // because they forgot parentheses to call that function.
1658 if (S.tryToRecoverWithCall(
1659 BaseExpr, S.PDiag(diag::err_member_reference_needs_call),
1660 /*complain*/ false,
1661 IsArrow ? &isPointerToRecordType : &isRecordType)) {
1662 if (BaseExpr.isInvalid())
1663 return ExprError();
1664 BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get());
1665 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1666 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1667 }
1668
1669 S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1670 << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1671
1672 return ExprError();
1673}
1674
1675/// The main callback when the parser finds something like
1676/// expression . [nested-name-specifier] identifier
1677/// expression -> [nested-name-specifier] identifier
1678/// where 'identifier' encompasses a fairly broad spectrum of
1679/// possibilities, including destructor and operator references.
1680///
1681/// \param OpKind either tok::arrow or tok::period
1682/// \param ObjCImpDecl the current Objective-C \@implementation
1683/// decl; this is an ugly hack around the fact that Objective-C
1684/// \@implementations aren't properly put in the context chain
1685ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
1686 SourceLocation OpLoc,
1687 tok::TokenKind OpKind,
1688 CXXScopeSpec &SS,
1689 SourceLocation TemplateKWLoc,
1690 UnqualifiedId &Id,
1691 Decl *ObjCImpDecl) {
1692 if (SS.isSet() && SS.isInvalid())
1693 return ExprError();
1694
1695 // Warn about the explicit constructor calls Microsoft extension.
1696 if (getLangOpts().MicrosoftExt &&
1697 Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
1698 Diag(Id.getSourceRange().getBegin(),
1699 diag::ext_ms_explicit_constructor_call);
1700
1701 TemplateArgumentListInfo TemplateArgsBuffer;
1702
1703 // Decompose the name into its component parts.
1704 DeclarationNameInfo NameInfo;
1705 const TemplateArgumentListInfo *TemplateArgs;
1706 DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1707 NameInfo, TemplateArgs);
1708
1709 DeclarationName Name = NameInfo.getName();
1710 bool IsArrow = (OpKind == tok::arrow);
1711
1712 NamedDecl *FirstQualifierInScope
1713 = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep()));
1714
1715 // This is a postfix expression, so get rid of ParenListExprs.
1716 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
1717 if (Result.isInvalid()) return ExprError();
1718 Base = Result.get();
1719
1720 if (Base->getType()->isDependentType() || Name.isDependentName() ||
1721 isDependentScopeSpecifier(SS)) {
1722 return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS,
1723 TemplateKWLoc, FirstQualifierInScope,
1724 NameInfo, TemplateArgs);
1725 }
1726
1727 ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl};
1728 ExprResult Res = BuildMemberReferenceExpr(
1729 Base, Base->getType(), OpLoc, IsArrow, SS, TemplateKWLoc,
1730 FirstQualifierInScope, NameInfo, TemplateArgs, S, &ExtraArgs);
1731
1732 if (!Res.isInvalid() && isa<MemberExpr>(Res.get()))
1733 CheckMemberAccessOfNoDeref(cast<MemberExpr>(Res.get()));
1734
1735 return Res;
1736}
1737
1738void Sema::CheckMemberAccessOfNoDeref(const MemberExpr *E) {
1739 QualType ResultTy = E->getType();
1740
1741 // Do not warn on member accesses to arrays since this returns an array
1742 // lvalue and does not actually dereference memory.
1743 if (isa<ArrayType>(ResultTy))
1744 return;
1745
1746 if (E->isArrow()) {
1747 if (const auto *Ptr = dyn_cast<PointerType>(
1748 E->getBase()->getType().getDesugaredType(Context))) {
1749 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
1750 ExprEvalContexts.back().PossibleDerefs.insert(E);
1751 }
1752 }
1753}
1754
1755ExprResult
1756Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
1757 SourceLocation OpLoc, const CXXScopeSpec &SS,
1758 FieldDecl *Field, DeclAccessPair FoundDecl,
1759 const DeclarationNameInfo &MemberNameInfo) {
1760 // x.a is an l-value if 'a' has a reference type. Otherwise:
1761 // x.a is an l-value/x-value/pr-value if the base is (and note
1762 // that *x is always an l-value), except that if the base isn't
1763 // an ordinary object then we must have an rvalue.
1764 ExprValueKind VK = VK_LValue;
1765 ExprObjectKind OK = OK_Ordinary;
1766 if (!IsArrow) {
1767 if (BaseExpr->getObjectKind() == OK_Ordinary)
1768 VK = BaseExpr->getValueKind();
1769 else
1770 VK = VK_RValue;
1771 }
1772 if (VK != VK_RValue && Field->isBitField())
1773 OK = OK_BitField;
1774
1775 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1776 QualType MemberType = Field->getType();
1777 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1778 MemberType = Ref->getPointeeType();
1779 VK = VK_LValue;
1780 } else {
1781 QualType BaseType = BaseExpr->getType();
1782 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1783
1784 Qualifiers BaseQuals = BaseType.getQualifiers();
1785
1786 // GC attributes are never picked up by members.
1787 BaseQuals.removeObjCGCAttr();
1788
1789 // CVR attributes from the base are picked up by members,
1790 // except that 'mutable' members don't pick up 'const'.
1791 if (Field->isMutable()) BaseQuals.removeConst();
1792
1793 Qualifiers MemberQuals =
1794 Context.getCanonicalType(MemberType).getQualifiers();
1795
1796 assert(!MemberQuals.hasAddressSpace())((!MemberQuals.hasAddressSpace()) ? static_cast<void> (
0) : __assert_fail ("!MemberQuals.hasAddressSpace()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1796, __PRETTY_FUNCTION__))
;
1797
1798 Qualifiers Combined = BaseQuals + MemberQuals;
1799 if (Combined != MemberQuals)
1800 MemberType = Context.getQualifiedType(MemberType, Combined);
1801 }
1802
1803 auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1804 if (!(CurMethod && CurMethod->isDefaulted()))
1805 UnusedPrivateFields.remove(Field);
1806
1807 ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
1808 FoundDecl, Field);
1809 if (Base.isInvalid())
1810 return ExprError();
1811
1812 // Build a reference to a private copy for non-static data members in
1813 // non-static member functions, privatized by OpenMP constructs.
1814 if (getLangOpts().OpenMP && IsArrow &&
1815 !CurContext->isDependentContext() &&
1816 isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
1817 if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
1818 return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
1819 MemberNameInfo.getLoc());
1820 }
1821 }
1822
1823 return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
1824 /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
1825 /*HadMultipleCandidates=*/false, MemberNameInfo,
1826 MemberType, VK, OK);
1827}
1828
1829/// Builds an implicit member access expression. The current context
1830/// is known to be an instance method, and the given unqualified lookup
1831/// set is known to contain only instance members, at least one of which
1832/// is from an appropriate type.
1833ExprResult
1834Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,
1835 SourceLocation TemplateKWLoc,
1836 LookupResult &R,
1837 const TemplateArgumentListInfo *TemplateArgs,
1838 bool IsKnownInstance, const Scope *S) {
1839 assert(!R.empty() && !R.isAmbiguous())((!R.empty() && !R.isAmbiguous()) ? static_cast<void
> (0) : __assert_fail ("!R.empty() && !R.isAmbiguous()"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1839, __PRETTY_FUNCTION__))
;
1840
1841 SourceLocation loc = R.getNameLoc();
1842
1843 // If this is known to be an instance access, go ahead and build an
1844 // implicit 'this' expression now.
1845 // 'this' expression now.
1846 QualType ThisTy = getCurrentThisType();
1847 assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'")((!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'"
) ? static_cast<void> (0) : __assert_fail ("!ThisTy.isNull() && \"didn't correctly pre-flight capture of 'this'\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp"
, 1847, __PRETTY_FUNCTION__))
;
1848
1849 Expr *baseExpr = nullptr; // null signifies implicit access
1850 if (IsKnownInstance) {
1851 SourceLocation Loc = R.getNameLoc();
1852 if (SS.getRange().isValid())
1853 Loc = SS.getRange().getBegin();
1854 baseExpr = BuildCXXThisExpr(loc, ThisTy, /*IsImplicit=*/true);
1855 }
1856
1857 return BuildMemberReferenceExpr(baseExpr, ThisTy,
1858 /*OpLoc*/ SourceLocation(),
1859 /*IsArrow*/ true,
1860 SS, TemplateKWLoc,
1861 /*FirstQualifierInScope*/ nullptr,
1862 R, TemplateArgs, S);
1863}