1//===--- SemaPseudoObject.cpp - Semantic Analysis for Pseudo-Objects ------===//
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 for expressions involving
10// pseudo-object references. Pseudo-objects are conceptual objects
11// whose storage is entirely abstract and all accesses to which are
12// translated through some sort of abstraction barrier.
13//
14// For example, Objective-C objects can have "properties", either
15// declared or undeclared. A property may be accessed by writing
16// expr.prop
17// where 'expr' is an r-value of Objective-C pointer type and 'prop'
18// is the name of the property. If this expression is used in a context
19// needing an r-value, it is treated as if it were a message-send
20// of the associated 'getter' selector, typically:
21// [expr prop]
22// If it is used as the LHS of a simple assignment, it is treated
23// as a message-send of the associated 'setter' selector, typically:
24// [expr setProp: RHS]
25// If it is used as the LHS of a compound assignment, or the operand
26// of a unary increment or decrement, both are required; for example,
27// 'expr.prop *= 100' would be translated to:
28// [expr setProp: [expr prop] * 100]
29//
30//===----------------------------------------------------------------------===//
31
32#include "clang/Sema/SemaInternal.h"
33#include "clang/AST/ExprCXX.h"
34#include "clang/AST/ExprObjC.h"
35#include "clang/Basic/CharInfo.h"
36#include "clang/Lex/Preprocessor.h"
37#include "clang/Sema/Initialization.h"
38#include "clang/Sema/ScopeInfo.h"
39#include "llvm/ADT/SmallString.h"
40
41using namespace clang;
42using namespace sema;
43
44namespace {
45 // Basically just a very focused copy of TreeTransform.
46 struct Rebuilder {
47 Sema &S;
48 unsigned MSPropertySubscriptCount;
49 typedef llvm::function_ref<Expr *(Expr *, unsigned)> SpecificRebuilderRefTy;
50 const SpecificRebuilderRefTy &SpecificCallback;
51 Rebuilder(Sema &S, const SpecificRebuilderRefTy &SpecificCallback)
52 : S(S), MSPropertySubscriptCount(0),
53 SpecificCallback(SpecificCallback) {}
54
55 Expr *rebuildObjCPropertyRefExpr(ObjCPropertyRefExpr *refExpr) {
56 // Fortunately, the constraint that we're rebuilding something
57 // with a base limits the number of cases here.
58 if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
59 return refExpr;
60
61 if (refExpr->isExplicitProperty()) {
62 return new (S.Context) ObjCPropertyRefExpr(
63 refExpr->getExplicitProperty(), refExpr->getType(),
64 refExpr->getValueKind(), refExpr->getObjectKind(),
65 refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
66 }
67 return new (S.Context) ObjCPropertyRefExpr(
68 refExpr->getImplicitPropertyGetter(),
69 refExpr->getImplicitPropertySetter(), refExpr->getType(),
70 refExpr->getValueKind(), refExpr->getObjectKind(),
71 refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
72 }
73 Expr *rebuildObjCSubscriptRefExpr(ObjCSubscriptRefExpr *refExpr) {
74 assert(refExpr->getBaseExpr());
75 assert(refExpr->getKeyExpr());
76
77 return new (S.Context) ObjCSubscriptRefExpr(
78 SpecificCallback(refExpr->getBaseExpr(), 0),
79 SpecificCallback(refExpr->getKeyExpr(), 1), refExpr->getType(),
80 refExpr->getValueKind(), refExpr->getObjectKind(),
81 refExpr->getAtIndexMethodDecl(), refExpr->setAtIndexMethodDecl(),
82 refExpr->getRBracket());
83 }
84 Expr *rebuildMSPropertyRefExpr(MSPropertyRefExpr *refExpr) {
85 assert(refExpr->getBaseExpr());
86
87 return new (S.Context) MSPropertyRefExpr(
88 SpecificCallback(refExpr->getBaseExpr(), 0),
89 refExpr->getPropertyDecl(), refExpr->isArrow(), refExpr->getType(),
90 refExpr->getValueKind(), refExpr->getQualifierLoc(),
91 refExpr->getMemberLoc());
92 }
93 Expr *rebuildMSPropertySubscriptExpr(MSPropertySubscriptExpr *refExpr) {
94 assert(refExpr->getBase());
95 assert(refExpr->getIdx());
96
97 auto *NewBase = rebuild(e: refExpr->getBase());
98 ++MSPropertySubscriptCount;
99 return new (S.Context) MSPropertySubscriptExpr(
100 NewBase,
101 SpecificCallback(refExpr->getIdx(), MSPropertySubscriptCount),
102 refExpr->getType(), refExpr->getValueKind(), refExpr->getObjectKind(),
103 refExpr->getRBracketLoc());
104 }
105
106 Expr *rebuild(Expr *e) {
107 // Fast path: nothing to look through.
108 if (auto *PRE = dyn_cast<ObjCPropertyRefExpr>(Val: e))
109 return rebuildObjCPropertyRefExpr(refExpr: PRE);
110 if (auto *SRE = dyn_cast<ObjCSubscriptRefExpr>(Val: e))
111 return rebuildObjCSubscriptRefExpr(refExpr: SRE);
112 if (auto *MSPRE = dyn_cast<MSPropertyRefExpr>(Val: e))
113 return rebuildMSPropertyRefExpr(refExpr: MSPRE);
114 if (auto *MSPSE = dyn_cast<MSPropertySubscriptExpr>(Val: e))
115 return rebuildMSPropertySubscriptExpr(refExpr: MSPSE);
116
117 // Otherwise, we should look through and rebuild anything that
118 // IgnoreParens would.
119
120 if (ParenExpr *parens = dyn_cast<ParenExpr>(Val: e)) {
121 e = rebuild(e: parens->getSubExpr());
122 return new (S.Context) ParenExpr(parens->getLParen(),
123 parens->getRParen(),
124 e);
125 }
126
127 if (UnaryOperator *uop = dyn_cast<UnaryOperator>(Val: e)) {
128 assert(uop->getOpcode() == UO_Extension);
129 e = rebuild(e: uop->getSubExpr());
130 return UnaryOperator::Create(
131 C: S.Context, input: e, opc: uop->getOpcode(), type: uop->getType(), VK: uop->getValueKind(),
132 OK: uop->getObjectKind(), l: uop->getOperatorLoc(), CanOverflow: uop->canOverflow(),
133 FPFeatures: S.CurFPFeatureOverrides());
134 }
135
136 if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(Val: e)) {
137 assert(!gse->isResultDependent());
138 unsigned resultIndex = gse->getResultIndex();
139 unsigned numAssocs = gse->getNumAssocs();
140
141 SmallVector<Expr *, 8> assocExprs;
142 SmallVector<TypeSourceInfo *, 8> assocTypes;
143 assocExprs.reserve(N: numAssocs);
144 assocTypes.reserve(N: numAssocs);
145
146 for (const GenericSelectionExpr::Association assoc :
147 gse->associations()) {
148 Expr *assocExpr = assoc.getAssociationExpr();
149 if (assoc.isSelected())
150 assocExpr = rebuild(e: assocExpr);
151 assocExprs.push_back(Elt: assocExpr);
152 assocTypes.push_back(Elt: assoc.getTypeSourceInfo());
153 }
154
155 if (gse->isExprPredicate())
156 return GenericSelectionExpr::Create(
157 S.Context, gse->getGenericLoc(), gse->getControllingExpr(),
158 assocTypes, assocExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
159 gse->containsUnexpandedParameterPack(), resultIndex);
160 return GenericSelectionExpr::Create(
161 S.Context, gse->getGenericLoc(), gse->getControllingType(),
162 assocTypes, assocExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
163 gse->containsUnexpandedParameterPack(), resultIndex);
164 }
165
166 if (ChooseExpr *ce = dyn_cast<ChooseExpr>(Val: e)) {
167 assert(!ce->isConditionDependent());
168
169 Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
170 Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
171 rebuiltExpr = rebuild(e: rebuiltExpr);
172
173 return new (S.Context)
174 ChooseExpr(ce->getBuiltinLoc(), ce->getCond(), LHS, RHS,
175 rebuiltExpr->getType(), rebuiltExpr->getValueKind(),
176 rebuiltExpr->getObjectKind(), ce->getRParenLoc(),
177 ce->isConditionTrue());
178 }
179
180 llvm_unreachable("bad expression to rebuild!");
181 }
182 };
183
184 class PseudoOpBuilder {
185 public:
186 Sema &S;
187 unsigned ResultIndex;
188 SourceLocation GenericLoc;
189 bool IsUnique;
190 SmallVector<Expr *, 4> Semantics;
191
192 PseudoOpBuilder(Sema &S, SourceLocation genericLoc, bool IsUnique)
193 : S(S), ResultIndex(PseudoObjectExpr::NoResult),
194 GenericLoc(genericLoc), IsUnique(IsUnique) {}
195
196 virtual ~PseudoOpBuilder() {}
197
198 /// Add a normal semantic expression.
199 void addSemanticExpr(Expr *semantic) {
200 Semantics.push_back(Elt: semantic);
201 }
202
203 /// Add the 'result' semantic expression.
204 void addResultSemanticExpr(Expr *resultExpr) {
205 assert(ResultIndex == PseudoObjectExpr::NoResult);
206 ResultIndex = Semantics.size();
207 Semantics.push_back(Elt: resultExpr);
208 // An OVE is not unique if it is used as the result expression.
209 if (auto *OVE = dyn_cast<OpaqueValueExpr>(Val: Semantics.back()))
210 OVE->setIsUnique(false);
211 }
212
213 ExprResult buildRValueOperation(Expr *op);
214 ExprResult buildAssignmentOperation(Scope *Sc,
215 SourceLocation opLoc,
216 BinaryOperatorKind opcode,
217 Expr *LHS, Expr *RHS);
218 ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
219 UnaryOperatorKind opcode,
220 Expr *op);
221
222 virtual ExprResult complete(Expr *syntacticForm);
223
224 OpaqueValueExpr *capture(Expr *op);
225 OpaqueValueExpr *captureValueAsResult(Expr *op);
226
227 void setResultToLastSemantic() {
228 assert(ResultIndex == PseudoObjectExpr::NoResult);
229 ResultIndex = Semantics.size() - 1;
230 // An OVE is not unique if it is used as the result expression.
231 if (auto *OVE = dyn_cast<OpaqueValueExpr>(Val: Semantics.back()))
232 OVE->setIsUnique(false);
233 }
234
235 /// Return true if assignments have a non-void result.
236 static bool CanCaptureValue(Expr *exp) {
237 if (exp->isGLValue())
238 return true;
239 QualType ty = exp->getType();
240 assert(!ty->isIncompleteType());
241 assert(!ty->isDependentType());
242
243 if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
244 return ClassDecl->isTriviallyCopyable();
245 return true;
246 }
247
248 virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
249 virtual ExprResult buildGet() = 0;
250 virtual ExprResult buildSet(Expr *, SourceLocation,
251 bool captureSetValueAsResult) = 0;
252 /// Should the result of an assignment be the formal result of the
253 /// setter call or the value that was passed to the setter?
254 ///
255 /// Different pseudo-object language features use different language rules
256 /// for this.
257 /// The default is to use the set value. Currently, this affects the
258 /// behavior of simple assignments, compound assignments, and prefix
259 /// increment and decrement.
260 /// Postfix increment and decrement always use the getter result as the
261 /// expression result.
262 ///
263 /// If this method returns true, and the set value isn't capturable for
264 /// some reason, the result of the expression will be void.
265 virtual bool captureSetValueAsResult() const { return true; }
266 };
267
268 /// A PseudoOpBuilder for Objective-C \@properties.
269 class ObjCPropertyOpBuilder : public PseudoOpBuilder {
270 ObjCPropertyRefExpr *RefExpr;
271 ObjCPropertyRefExpr *SyntacticRefExpr;
272 OpaqueValueExpr *InstanceReceiver;
273 ObjCMethodDecl *Getter;
274
275 ObjCMethodDecl *Setter;
276 Selector SetterSelector;
277 Selector GetterSelector;
278
279 public:
280 ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr, bool IsUnique)
281 : PseudoOpBuilder(S, refExpr->getLocation(), IsUnique),
282 RefExpr(refExpr), SyntacticRefExpr(nullptr),
283 InstanceReceiver(nullptr), Getter(nullptr), Setter(nullptr) {
284 }
285
286 ExprResult buildRValueOperation(Expr *op);
287 ExprResult buildAssignmentOperation(Scope *Sc,
288 SourceLocation opLoc,
289 BinaryOperatorKind opcode,
290 Expr *LHS, Expr *RHS);
291 ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
292 UnaryOperatorKind opcode,
293 Expr *op);
294
295 bool tryBuildGetOfReference(Expr *op, ExprResult &result);
296 bool findSetter(bool warn=true);
297 bool findGetter();
298 void DiagnoseUnsupportedPropertyUse();
299
300 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
301 ExprResult buildGet() override;
302 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
303 ExprResult complete(Expr *SyntacticForm) override;
304
305 bool isWeakProperty() const;
306 };
307
308 /// A PseudoOpBuilder for Objective-C array/dictionary indexing.
309 class ObjCSubscriptOpBuilder : public PseudoOpBuilder {
310 ObjCSubscriptRefExpr *RefExpr;
311 OpaqueValueExpr *InstanceBase;
312 OpaqueValueExpr *InstanceKey;
313 ObjCMethodDecl *AtIndexGetter;
314 Selector AtIndexGetterSelector;
315
316 ObjCMethodDecl *AtIndexSetter;
317 Selector AtIndexSetterSelector;
318
319 public:
320 ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr, bool IsUnique)
321 : PseudoOpBuilder(S, refExpr->getSourceRange().getBegin(), IsUnique),
322 RefExpr(refExpr), InstanceBase(nullptr), InstanceKey(nullptr),
323 AtIndexGetter(nullptr), AtIndexSetter(nullptr) {}
324
325 ExprResult buildRValueOperation(Expr *op);
326 ExprResult buildAssignmentOperation(Scope *Sc,
327 SourceLocation opLoc,
328 BinaryOperatorKind opcode,
329 Expr *LHS, Expr *RHS);
330 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
331
332 bool findAtIndexGetter();
333 bool findAtIndexSetter();
334
335 ExprResult buildGet() override;
336 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
337 };
338
339 class MSPropertyOpBuilder : public PseudoOpBuilder {
340 MSPropertyRefExpr *RefExpr;
341 OpaqueValueExpr *InstanceBase;
342 SmallVector<Expr *, 4> CallArgs;
343
344 MSPropertyRefExpr *getBaseMSProperty(MSPropertySubscriptExpr *E);
345
346 public:
347 MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr, bool IsUnique)
348 : PseudoOpBuilder(S, refExpr->getSourceRange().getBegin(), IsUnique),
349 RefExpr(refExpr), InstanceBase(nullptr) {}
350 MSPropertyOpBuilder(Sema &S, MSPropertySubscriptExpr *refExpr, bool IsUnique)
351 : PseudoOpBuilder(S, refExpr->getSourceRange().getBegin(), IsUnique),
352 InstanceBase(nullptr) {
353 RefExpr = getBaseMSProperty(E: refExpr);
354 }
355
356 Expr *rebuildAndCaptureObject(Expr *) override;
357 ExprResult buildGet() override;
358 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
359 bool captureSetValueAsResult() const override { return false; }
360 };
361}
362
363/// Capture the given expression in an OpaqueValueExpr.
364OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
365 // Make a new OVE whose source is the given expression.
366 OpaqueValueExpr *captured =
367 new (S.Context) OpaqueValueExpr(GenericLoc, e->getType(),
368 e->getValueKind(), e->getObjectKind(),
369 e);
370 if (IsUnique)
371 captured->setIsUnique(true);
372
373 // Make sure we bind that in the semantics.
374 addSemanticExpr(captured);
375 return captured;
376}
377
378/// Capture the given expression as the result of this pseudo-object
379/// operation. This routine is safe against expressions which may
380/// already be captured.
381///
382/// \returns the captured expression, which will be the
383/// same as the input if the input was already captured
384OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
385 assert(ResultIndex == PseudoObjectExpr::NoResult);
386
387 // If the expression hasn't already been captured, just capture it
388 // and set the new semantic
389 if (!isa<OpaqueValueExpr>(Val: e)) {
390 OpaqueValueExpr *cap = capture(e);
391 setResultToLastSemantic();
392 return cap;
393 }
394
395 // Otherwise, it must already be one of our semantic expressions;
396 // set ResultIndex to its index.
397 unsigned index = 0;
398 for (;; ++index) {
399 assert(index < Semantics.size() &&
400 "captured expression not found in semantics!");
401 if (e == Semantics[index]) break;
402 }
403 ResultIndex = index;
404 // An OVE is not unique if it is used as the result expression.
405 cast<OpaqueValueExpr>(Val: e)->setIsUnique(false);
406 return cast<OpaqueValueExpr>(Val: e);
407}
408
409/// The routine which creates the final PseudoObjectExpr.
410ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
411 return PseudoObjectExpr::Create(Context: S.Context, syntactic,
412 semantic: Semantics, resultIndex: ResultIndex);
413}
414
415/// The main skeleton for building an r-value operation.
416ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
417 Expr *syntacticBase = rebuildAndCaptureObject(op);
418
419 ExprResult getExpr = buildGet();
420 if (getExpr.isInvalid()) return ExprError();
421 addResultSemanticExpr(resultExpr: getExpr.get());
422
423 return complete(syntactic: syntacticBase);
424}
425
426/// The basic skeleton for building a simple or compound
427/// assignment operation.
428ExprResult
429PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
430 BinaryOperatorKind opcode,
431 Expr *LHS, Expr *RHS) {
432 assert(BinaryOperator::isAssignmentOp(opcode));
433
434 Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
435 OpaqueValueExpr *capturedRHS = capture(e: RHS);
436
437 // In some very specific cases, semantic analysis of the RHS as an
438 // expression may require it to be rewritten. In these cases, we
439 // cannot safely keep the OVE around. Fortunately, we don't really
440 // need to: we don't use this particular OVE in multiple places, and
441 // no clients rely that closely on matching up expressions in the
442 // semantic expression with expressions from the syntactic form.
443 Expr *semanticRHS = capturedRHS;
444 if (RHS->hasPlaceholderType() || isa<InitListExpr>(Val: RHS)) {
445 semanticRHS = RHS;
446 Semantics.pop_back();
447 }
448
449 Expr *syntactic;
450
451 ExprResult result;
452 if (opcode == BO_Assign) {
453 result = semanticRHS;
454 syntactic = BinaryOperator::Create(C: S.Context, lhs: syntacticLHS, rhs: capturedRHS,
455 opc: opcode, ResTy: capturedRHS->getType(),
456 VK: capturedRHS->getValueKind(), OK: OK_Ordinary,
457 opLoc: opcLoc, FPFeatures: S.CurFPFeatureOverrides());
458
459 } else {
460 ExprResult opLHS = buildGet();
461 if (opLHS.isInvalid()) return ExprError();
462
463 // Build an ordinary, non-compound operation.
464 BinaryOperatorKind nonCompound =
465 BinaryOperator::getOpForCompoundAssignment(Opc: opcode);
466 result = S.BuildBinOp(S: Sc, OpLoc: opcLoc, Opc: nonCompound, LHSExpr: opLHS.get(), RHSExpr: semanticRHS);
467 if (result.isInvalid()) return ExprError();
468
469 syntactic = CompoundAssignOperator::Create(
470 S.Context, syntacticLHS, capturedRHS, opcode, result.get()->getType(),
471 result.get()->getValueKind(), OK_Ordinary, opcLoc,
472 S.CurFPFeatureOverrides(), opLHS.get()->getType(),
473 result.get()->getType());
474 }
475
476 // The result of the assignment, if not void, is the value set into
477 // the l-value.
478 result = buildSet(result.get(), opcLoc, captureSetValueAsResult: captureSetValueAsResult());
479 if (result.isInvalid()) return ExprError();
480 addSemanticExpr(semantic: result.get());
481 if (!captureSetValueAsResult() && !result.get()->getType()->isVoidType() &&
482 (result.get()->isTypeDependent() || CanCaptureValue(exp: result.get())))
483 setResultToLastSemantic();
484
485 return complete(syntactic);
486}
487
488/// The basic skeleton for building an increment or decrement
489/// operation.
490ExprResult
491PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
492 UnaryOperatorKind opcode,
493 Expr *op) {
494 assert(UnaryOperator::isIncrementDecrementOp(opcode));
495
496 Expr *syntacticOp = rebuildAndCaptureObject(op);
497
498 // Load the value.
499 ExprResult result = buildGet();
500 if (result.isInvalid()) return ExprError();
501
502 QualType resultType = result.get()->getType();
503
504 // That's the postfix result.
505 if (UnaryOperator::isPostfix(Op: opcode) &&
506 (result.get()->isTypeDependent() || CanCaptureValue(exp: result.get()))) {
507 result = capture(e: result.get());
508 setResultToLastSemantic();
509 }
510
511 // Add or subtract a literal 1.
512 llvm::APInt oneV(S.Context.getTypeSize(S.Context.IntTy), 1);
513 Expr *one = IntegerLiteral::Create(S.Context, oneV, S.Context.IntTy,
514 GenericLoc);
515
516 if (UnaryOperator::isIncrementOp(Op: opcode)) {
517 result = S.BuildBinOp(S: Sc, OpLoc: opcLoc, Opc: BO_Add, LHSExpr: result.get(), RHSExpr: one);
518 } else {
519 result = S.BuildBinOp(S: Sc, OpLoc: opcLoc, Opc: BO_Sub, LHSExpr: result.get(), RHSExpr: one);
520 }
521 if (result.isInvalid()) return ExprError();
522
523 // Store that back into the result. The value stored is the result
524 // of a prefix operation.
525 result = buildSet(result.get(), opcLoc, captureSetValueAsResult: UnaryOperator::isPrefix(Op: opcode) &&
526 captureSetValueAsResult());
527 if (result.isInvalid()) return ExprError();
528 addSemanticExpr(semantic: result.get());
529 if (UnaryOperator::isPrefix(Op: opcode) && !captureSetValueAsResult() &&
530 !result.get()->getType()->isVoidType() &&
531 (result.get()->isTypeDependent() || CanCaptureValue(exp: result.get())))
532 setResultToLastSemantic();
533
534 UnaryOperator *syntactic =
535 UnaryOperator::Create(C: S.Context, input: syntacticOp, opc: opcode, type: resultType,
536 VK: VK_LValue, OK: OK_Ordinary, l: opcLoc,
537 CanOverflow: !resultType->isDependentType()
538 ? S.Context.getTypeSize(T: resultType) >=
539 S.Context.getTypeSize(S.Context.IntTy)
540 : false,
541 FPFeatures: S.CurFPFeatureOverrides());
542 return complete(syntactic);
543}
544
545
546//===----------------------------------------------------------------------===//
547// Objective-C @property and implicit property references
548//===----------------------------------------------------------------------===//
549
550/// Look up a method in the receiver type of an Objective-C property
551/// reference.
552static ObjCMethodDecl *LookupMethodInReceiverType(Sema &S, Selector sel,
553 const ObjCPropertyRefExpr *PRE) {
554 if (PRE->isObjectReceiver()) {
555 const ObjCObjectPointerType *PT =
556 PRE->getBase()->getType()->castAs<ObjCObjectPointerType>();
557
558 // Special case for 'self' in class method implementations.
559 if (PT->isObjCClassType() &&
560 S.isSelfExpr(RExpr: const_cast<Expr*>(PRE->getBase()))) {
561 // This cast is safe because isSelfExpr is only true within
562 // methods.
563 ObjCMethodDecl *method =
564 cast<ObjCMethodDecl>(Val: S.CurContext->getNonClosureAncestor());
565 return S.LookupMethodInObjectType(Sel: sel,
566 Ty: S.Context.getObjCInterfaceType(Decl: method->getClassInterface()),
567 /*instance*/ IsInstance: false);
568 }
569
570 return S.LookupMethodInObjectType(Sel: sel, Ty: PT->getPointeeType(), IsInstance: true);
571 }
572
573 if (PRE->isSuperReceiver()) {
574 if (const ObjCObjectPointerType *PT =
575 PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
576 return S.LookupMethodInObjectType(Sel: sel, Ty: PT->getPointeeType(), IsInstance: true);
577
578 return S.LookupMethodInObjectType(Sel: sel, Ty: PRE->getSuperReceiverType(), IsInstance: false);
579 }
580
581 assert(PRE->isClassReceiver() && "Invalid expression");
582 QualType IT = S.Context.getObjCInterfaceType(Decl: PRE->getClassReceiver());
583 return S.LookupMethodInObjectType(Sel: sel, Ty: IT, IsInstance: false);
584}
585
586bool ObjCPropertyOpBuilder::isWeakProperty() const {
587 QualType T;
588 if (RefExpr->isExplicitProperty()) {
589 const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
590 if (Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_weak)
591 return true;
592
593 T = Prop->getType();
594 } else if (Getter) {
595 T = Getter->getReturnType();
596 } else {
597 return false;
598 }
599
600 return T.getObjCLifetime() == Qualifiers::OCL_Weak;
601}
602
603bool ObjCPropertyOpBuilder::findGetter() {
604 if (Getter) return true;
605
606 // For implicit properties, just trust the lookup we already did.
607 if (RefExpr->isImplicitProperty()) {
608 if ((Getter = RefExpr->getImplicitPropertyGetter())) {
609 GetterSelector = Getter->getSelector();
610 return true;
611 }
612 else {
613 // Must build the getter selector the hard way.
614 ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter();
615 assert(setter && "both setter and getter are null - cannot happen");
616 IdentifierInfo *setterName =
617 setter->getSelector().getIdentifierInfoForSlot(argIndex: 0);
618 IdentifierInfo *getterName =
619 &S.Context.Idents.get(Name: setterName->getName().substr(Start: 3));
620 GetterSelector =
621 S.PP.getSelectorTable().getNullarySelector(getterName);
622 return false;
623 }
624 }
625
626 ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
627 Getter = LookupMethodInReceiverType(S, sel: prop->getGetterName(), PRE: RefExpr);
628 return (Getter != nullptr);
629}
630
631/// Try to find the most accurate setter declaration for the property
632/// reference.
633///
634/// \return true if a setter was found, in which case Setter
635bool ObjCPropertyOpBuilder::findSetter(bool warn) {
636 // For implicit properties, just trust the lookup we already did.
637 if (RefExpr->isImplicitProperty()) {
638 if (ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter()) {
639 Setter = setter;
640 SetterSelector = setter->getSelector();
641 return true;
642 } else {
643 IdentifierInfo *getterName =
644 RefExpr->getImplicitPropertyGetter()->getSelector()
645 .getIdentifierInfoForSlot(argIndex: 0);
646 SetterSelector =
647 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
648 S.PP.getSelectorTable(),
649 getterName);
650 return false;
651 }
652 }
653
654 // For explicit properties, this is more involved.
655 ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
656 SetterSelector = prop->getSetterName();
657
658 // Do a normal method lookup first.
659 if (ObjCMethodDecl *setter =
660 LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {
661 if (setter->isPropertyAccessor() && warn)
662 if (const ObjCInterfaceDecl *IFace =
663 dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {
664 StringRef thisPropertyName = prop->getName();
665 // Try flipping the case of the first character.
666 char front = thisPropertyName.front();
667 front = isLowercase(c: front) ? toUppercase(c: front) : toLowercase(c: front);
668 SmallString<100> PropertyName = thisPropertyName;
669 PropertyName[0] = front;
670 IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(Name: PropertyName);
671 if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(
672 AltMember, prop->getQueryKind()))
673 if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
674 S.Diag(RefExpr->getExprLoc(), diag::err_property_setter_ambiguous_use)
675 << prop << prop1 << setter->getSelector();
676 S.Diag(prop->getLocation(), diag::note_property_declare);
677 S.Diag(prop1->getLocation(), diag::note_property_declare);
678 }
679 }
680 Setter = setter;
681 return true;
682 }
683
684 // That can fail in the somewhat crazy situation that we're
685 // type-checking a message send within the @interface declaration
686 // that declared the @property. But it's not clear that that's
687 // valuable to support.
688
689 return false;
690}
691
692void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
693 if (S.getCurLexicalContext()->isObjCContainer() &&
694 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
695 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
696 if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
697 S.Diag(RefExpr->getLocation(),
698 diag::err_property_function_in_objc_container);
699 S.Diag(prop->getLocation(), diag::note_property_declare);
700 }
701 }
702}
703
704/// Capture the base object of an Objective-C property expression.
705Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
706 assert(InstanceReceiver == nullptr);
707
708 // If we have a base, capture it in an OVE and rebuild the syntactic
709 // form to use the OVE as its base.
710 if (RefExpr->isObjectReceiver()) {
711 InstanceReceiver = capture(RefExpr->getBase());
712 syntacticBase = Rebuilder(S, [=](Expr *, unsigned) -> Expr * {
713 return InstanceReceiver;
714 }).rebuild(e: syntacticBase);
715 }
716
717 if (ObjCPropertyRefExpr *
718 refE = dyn_cast<ObjCPropertyRefExpr>(Val: syntacticBase->IgnoreParens()))
719 SyntacticRefExpr = refE;
720
721 return syntacticBase;
722}
723
724/// Load from an Objective-C property reference.
725ExprResult ObjCPropertyOpBuilder::buildGet() {
726 findGetter();
727 if (!Getter) {
728 DiagnoseUnsupportedPropertyUse();
729 return ExprError();
730 }
731
732 if (SyntacticRefExpr)
733 SyntacticRefExpr->setIsMessagingGetter();
734
735 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
736 if (!Getter->isImplicit())
737 S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
738 // Build a message-send.
739 ExprResult msg;
740 if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
741 RefExpr->isObjectReceiver()) {
742 assert(InstanceReceiver || RefExpr->isSuperReceiver());
743 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
744 GenericLoc, Getter->getSelector(),
745 Getter, std::nullopt);
746 } else {
747 msg = S.BuildClassMessageImplicit(ReceiverType: receiverType, isSuperReceiver: RefExpr->isSuperReceiver(),
748 Loc: GenericLoc, Sel: Getter->getSelector(), Method: Getter,
749 Args: std::nullopt);
750 }
751 return msg;
752}
753
754/// Store to an Objective-C property reference.
755///
756/// \param captureSetValueAsResult If true, capture the actual
757/// value being set as the value of the property operation.
758ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
759 bool captureSetValueAsResult) {
760 if (!findSetter(warn: false)) {
761 DiagnoseUnsupportedPropertyUse();
762 return ExprError();
763 }
764
765 if (SyntacticRefExpr)
766 SyntacticRefExpr->setIsMessagingSetter();
767
768 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
769
770 // Use assignment constraints when possible; they give us better
771 // diagnostics. "When possible" basically means anything except a
772 // C++ class type.
773 if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
774 QualType paramType = (*Setter->param_begin())->getType()
775 .substObjCMemberType(
776 receiverType,
777 Setter->getDeclContext(),
778 ObjCSubstitutionContext::Parameter);
779 if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
780 ExprResult opResult = op;
781 Sema::AssignConvertType assignResult
782 = S.CheckSingleAssignmentConstraints(LHSType: paramType, RHS&: opResult);
783 if (opResult.isInvalid() ||
784 S.DiagnoseAssignmentResult(ConvTy: assignResult, Loc: opcLoc, DstType: paramType,
785 SrcType: op->getType(), SrcExpr: opResult.get(),
786 Action: Sema::AA_Assigning))
787 return ExprError();
788
789 op = opResult.get();
790 assert(op && "successful assignment left argument invalid?");
791 }
792 }
793
794 // Arguments.
795 Expr *args[] = { op };
796
797 // Build a message-send.
798 ExprResult msg;
799 if (!Setter->isImplicit())
800 S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
801 if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
802 RefExpr->isObjectReceiver()) {
803 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
804 GenericLoc, SetterSelector, Setter,
805 MultiExprArg(args, 1));
806 } else {
807 msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
808 GenericLoc,
809 SetterSelector, Setter,
810 MultiExprArg(args, 1));
811 }
812
813 if (!msg.isInvalid() && captureSetValueAsResult) {
814 ObjCMessageExpr *msgExpr =
815 cast<ObjCMessageExpr>(Val: msg.get()->IgnoreImplicit());
816 Expr *arg = msgExpr->getArg(Arg: 0);
817 if (CanCaptureValue(exp: arg))
818 msgExpr->setArg(Arg: 0, ArgExpr: captureValueAsResult(arg));
819 }
820
821 return msg;
822}
823
824/// @property-specific behavior for doing lvalue-to-rvalue conversion.
825ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
826 // Explicit properties always have getters, but implicit ones don't.
827 // Check that before proceeding.
828 if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
829 S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
830 << RefExpr->getSourceRange();
831 return ExprError();
832 }
833
834 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
835 if (result.isInvalid()) return ExprError();
836
837 if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
838 S.DiagnosePropertyAccessorMismatch(PD: RefExpr->getExplicitProperty(),
839 Getter, Loc: RefExpr->getLocation());
840
841 // As a special case, if the method returns 'id', try to get
842 // a better type from the property.
843 if (RefExpr->isExplicitProperty() && result.get()->isPRValue()) {
844 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
845 QualType propType = RefExpr->getExplicitProperty()
846 ->getUsageType(objectType: receiverType);
847 if (result.get()->getType()->isObjCIdType()) {
848 if (const ObjCObjectPointerType *ptr
849 = propType->getAs<ObjCObjectPointerType>()) {
850 if (!ptr->isObjCIdType())
851 result = S.ImpCastExprToType(E: result.get(), Type: propType, CK: CK_BitCast);
852 }
853 }
854 if (propType.getObjCLifetime() == Qualifiers::OCL_Weak &&
855 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
856 RefExpr->getLocation()))
857 S.getCurFunction()->markSafeWeakUse(RefExpr);
858 }
859
860 return result;
861}
862
863/// Try to build this as a call to a getter that returns a reference.
864///
865/// \return true if it was possible, whether or not it actually
866/// succeeded
867bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
868 ExprResult &result) {
869 if (!S.getLangOpts().CPlusPlus) return false;
870
871 findGetter();
872 if (!Getter) {
873 // The property has no setter and no getter! This can happen if the type is
874 // invalid. Error have already been reported.
875 result = ExprError();
876 return true;
877 }
878
879 // Only do this if the getter returns an l-value reference type.
880 QualType resultType = Getter->getReturnType();
881 if (!resultType->isLValueReferenceType()) return false;
882
883 result = buildRValueOperation(op);
884 return true;
885}
886
887/// @property-specific behavior for doing assignments.
888ExprResult
889ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
890 SourceLocation opcLoc,
891 BinaryOperatorKind opcode,
892 Expr *LHS, Expr *RHS) {
893 assert(BinaryOperator::isAssignmentOp(opcode));
894
895 // If there's no setter, we have no choice but to try to assign to
896 // the result of the getter.
897 if (!findSetter()) {
898 ExprResult result;
899 if (tryBuildGetOfReference(op: LHS, result)) {
900 if (result.isInvalid()) return ExprError();
901 return S.BuildBinOp(S: Sc, OpLoc: opcLoc, Opc: opcode, LHSExpr: result.get(), RHSExpr: RHS);
902 }
903
904 // Otherwise, it's an error.
905 S.Diag(opcLoc, diag::err_nosetter_property_assignment)
906 << unsigned(RefExpr->isImplicitProperty())
907 << SetterSelector
908 << LHS->getSourceRange() << RHS->getSourceRange();
909 return ExprError();
910 }
911
912 // If there is a setter, we definitely want to use it.
913
914 // Verify that we can do a compound assignment.
915 if (opcode != BO_Assign && !findGetter()) {
916 S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
917 << LHS->getSourceRange() << RHS->getSourceRange();
918 return ExprError();
919 }
920
921 ExprResult result =
922 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
923 if (result.isInvalid()) return ExprError();
924
925 // Various warnings about property assignments in ARC.
926 if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
927 S.checkRetainCycles(receiver: InstanceReceiver->getSourceExpr(), argument: RHS);
928 S.checkUnsafeExprAssigns(Loc: opcLoc, LHS, RHS);
929 }
930
931 return result;
932}
933
934/// @property-specific behavior for doing increments and decrements.
935ExprResult
936ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
937 UnaryOperatorKind opcode,
938 Expr *op) {
939 // If there's no setter, we have no choice but to try to assign to
940 // the result of the getter.
941 if (!findSetter()) {
942 ExprResult result;
943 if (tryBuildGetOfReference(op, result)) {
944 if (result.isInvalid()) return ExprError();
945 return S.BuildUnaryOp(S: Sc, OpLoc: opcLoc, Opc: opcode, Input: result.get());
946 }
947
948 // Otherwise, it's an error.
949 S.Diag(opcLoc, diag::err_nosetter_property_incdec)
950 << unsigned(RefExpr->isImplicitProperty())
951 << unsigned(UnaryOperator::isDecrementOp(opcode))
952 << SetterSelector
953 << op->getSourceRange();
954 return ExprError();
955 }
956
957 // If there is a setter, we definitely want to use it.
958
959 // We also need a getter.
960 if (!findGetter()) {
961 assert(RefExpr->isImplicitProperty());
962 S.Diag(opcLoc, diag::err_nogetter_property_incdec)
963 << unsigned(UnaryOperator::isDecrementOp(opcode))
964 << GetterSelector
965 << op->getSourceRange();
966 return ExprError();
967 }
968
969 return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
970}
971
972ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
973 if (isWeakProperty() && !S.isUnevaluatedContext() &&
974 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
975 SyntacticForm->getBeginLoc()))
976 S.getCurFunction()->recordUseOfWeak(E: SyntacticRefExpr,
977 IsRead: SyntacticRefExpr->isMessagingGetter());
978
979 return PseudoOpBuilder::complete(SyntacticForm);
980}
981
982// ObjCSubscript build stuff.
983//
984
985/// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
986/// conversion.
987/// FIXME. Remove this routine if it is proven that no additional
988/// specifity is needed.
989ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
990 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
991 if (result.isInvalid()) return ExprError();
992 return result;
993}
994
995/// objective-c subscripting-specific behavior for doing assignments.
996ExprResult
997ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
998 SourceLocation opcLoc,
999 BinaryOperatorKind opcode,
1000 Expr *LHS, Expr *RHS) {
1001 assert(BinaryOperator::isAssignmentOp(opcode));
1002 // There must be a method to do the Index'ed assignment.
1003 if (!findAtIndexSetter())
1004 return ExprError();
1005
1006 // Verify that we can do a compound assignment.
1007 if (opcode != BO_Assign && !findAtIndexGetter())
1008 return ExprError();
1009
1010 ExprResult result =
1011 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
1012 if (result.isInvalid()) return ExprError();
1013
1014 // Various warnings about objc Index'ed assignments in ARC.
1015 if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
1016 S.checkRetainCycles(receiver: InstanceBase->getSourceExpr(), argument: RHS);
1017 S.checkUnsafeExprAssigns(Loc: opcLoc, LHS, RHS);
1018 }
1019
1020 return result;
1021}
1022
1023/// Capture the base object of an Objective-C Index'ed expression.
1024Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1025 assert(InstanceBase == nullptr);
1026
1027 // Capture base expression in an OVE and rebuild the syntactic
1028 // form to use the OVE as its base expression.
1029 InstanceBase = capture(RefExpr->getBaseExpr());
1030 InstanceKey = capture(RefExpr->getKeyExpr());
1031
1032 syntacticBase =
1033 Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1034 switch (Idx) {
1035 case 0:
1036 return InstanceBase;
1037 case 1:
1038 return InstanceKey;
1039 default:
1040 llvm_unreachable("Unexpected index for ObjCSubscriptExpr");
1041 }
1042 }).rebuild(e: syntacticBase);
1043
1044 return syntacticBase;
1045}
1046
1047/// CheckSubscriptingKind - This routine decide what type
1048/// of indexing represented by "FromE" is being done.
1049Sema::ObjCSubscriptKind
1050 Sema::CheckSubscriptingKind(Expr *FromE) {
1051 // If the expression already has integral or enumeration type, we're golden.
1052 QualType T = FromE->getType();
1053 if (T->isIntegralOrEnumerationType())
1054 return OS_Array;
1055
1056 // If we don't have a class type in C++, there's no way we can get an
1057 // expression of integral or enumeration type.
1058 const RecordType *RecordTy = T->getAs<RecordType>();
1059 if (!RecordTy &&
1060 (T->isObjCObjectPointerType() || T->isVoidPointerType()))
1061 // All other scalar cases are assumed to be dictionary indexing which
1062 // caller handles, with diagnostics if needed.
1063 return OS_Dictionary;
1064 if (!getLangOpts().CPlusPlus ||
1065 !RecordTy || RecordTy->isIncompleteType()) {
1066 // No indexing can be done. Issue diagnostics and quit.
1067 const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1068 if (isa<StringLiteral>(IndexExpr))
1069 Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1070 << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1071 else
1072 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1073 << T;
1074 return OS_Error;
1075 }
1076
1077 // We must have a complete class type.
1078 if (RequireCompleteType(FromE->getExprLoc(), T,
1079 diag::err_objc_index_incomplete_class_type, FromE))
1080 return OS_Error;
1081
1082 // Look for a conversion to an integral, enumeration type, or
1083 // objective-C pointer type.
1084 int NoIntegrals=0, NoObjCIdPointers=0;
1085 SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1086
1087 for (NamedDecl *D : cast<CXXRecordDecl>(Val: RecordTy->getDecl())
1088 ->getVisibleConversionFunctions()) {
1089 if (CXXConversionDecl *Conversion =
1090 dyn_cast<CXXConversionDecl>(Val: D->getUnderlyingDecl())) {
1091 QualType CT = Conversion->getConversionType().getNonReferenceType();
1092 if (CT->isIntegralOrEnumerationType()) {
1093 ++NoIntegrals;
1094 ConversionDecls.push_back(Elt: Conversion);
1095 }
1096 else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1097 ++NoObjCIdPointers;
1098 ConversionDecls.push_back(Elt: Conversion);
1099 }
1100 }
1101 }
1102 if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1103 return OS_Array;
1104 if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1105 return OS_Dictionary;
1106 if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1107 // No conversion function was found. Issue diagnostic and return.
1108 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1109 << FromE->getType();
1110 return OS_Error;
1111 }
1112 Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1113 << FromE->getType();
1114 for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1115 Diag(ConversionDecls[i]->getLocation(),
1116 diag::note_conv_function_declared_at);
1117
1118 return OS_Error;
1119}
1120
1121/// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1122/// objects used as dictionary subscript key objects.
1123static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1124 Expr *Key) {
1125 if (ContainerT.isNull())
1126 return;
1127 // dictionary subscripting.
1128 // - (id)objectForKeyedSubscript:(id)key;
1129 IdentifierInfo *KeyIdents[] = {
1130 &S.Context.Idents.get(Name: "objectForKeyedSubscript")
1131 };
1132 Selector GetterSelector = S.Context.Selectors.getSelector(NumArgs: 1, IIV: KeyIdents);
1133 ObjCMethodDecl *Getter = S.LookupMethodInObjectType(Sel: GetterSelector, Ty: ContainerT,
1134 IsInstance: true /*instance*/);
1135 if (!Getter)
1136 return;
1137 QualType T = Getter->parameters()[0]->getType();
1138 S.CheckObjCConversion(castRange: Key->getSourceRange(), castType: T, op&: Key,
1139 CCK: Sema::CCK_ImplicitConversion);
1140}
1141
1142bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1143 if (AtIndexGetter)
1144 return true;
1145
1146 Expr *BaseExpr = RefExpr->getBaseExpr();
1147 QualType BaseT = BaseExpr->getType();
1148
1149 QualType ResultType;
1150 if (const ObjCObjectPointerType *PTy =
1151 BaseT->getAs<ObjCObjectPointerType>()) {
1152 ResultType = PTy->getPointeeType();
1153 }
1154 Sema::ObjCSubscriptKind Res =
1155 S.CheckSubscriptingKind(FromE: RefExpr->getKeyExpr());
1156 if (Res == Sema::OS_Error) {
1157 if (S.getLangOpts().ObjCAutoRefCount)
1158 CheckKeyForObjCARCConversion(S, ContainerT: ResultType,
1159 Key: RefExpr->getKeyExpr());
1160 return false;
1161 }
1162 bool arrayRef = (Res == Sema::OS_Array);
1163
1164 if (ResultType.isNull()) {
1165 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1166 << BaseExpr->getType() << arrayRef;
1167 return false;
1168 }
1169 if (!arrayRef) {
1170 // dictionary subscripting.
1171 // - (id)objectForKeyedSubscript:(id)key;
1172 IdentifierInfo *KeyIdents[] = {
1173 &S.Context.Idents.get(Name: "objectForKeyedSubscript")
1174 };
1175 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1176 }
1177 else {
1178 // - (id)objectAtIndexedSubscript:(size_t)index;
1179 IdentifierInfo *KeyIdents[] = {
1180 &S.Context.Idents.get(Name: "objectAtIndexedSubscript")
1181 };
1182
1183 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1184 }
1185
1186 AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1187 true /*instance*/);
1188
1189 if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1190 AtIndexGetter = ObjCMethodDecl::Create(
1191 S.Context, SourceLocation(), SourceLocation(), AtIndexGetterSelector,
1192 S.Context.getObjCIdType() /*ReturnType*/, nullptr /*TypeSourceInfo */,
1193 S.Context.getTranslationUnitDecl(), true /*Instance*/,
1194 false /*isVariadic*/,
1195 /*isPropertyAccessor=*/false,
1196 /*isSynthesizedAccessorStub=*/false,
1197 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1198 ObjCImplementationControl::Required, false);
1199 ParmVarDecl *Argument = ParmVarDecl::Create(C&: S.Context, DC: AtIndexGetter,
1200 StartLoc: SourceLocation(), IdLoc: SourceLocation(),
1201 Id: arrayRef ? &S.Context.Idents.get(Name: "index")
1202 : &S.Context.Idents.get(Name: "key"),
1203 T: arrayRef ? S.Context.UnsignedLongTy
1204 : S.Context.getObjCIdType(),
1205 /*TInfo=*/nullptr,
1206 S: SC_None,
1207 DefArg: nullptr);
1208 AtIndexGetter->setMethodParams(C&: S.Context, Params: Argument, SelLocs: std::nullopt);
1209 }
1210
1211 if (!AtIndexGetter) {
1212 if (!BaseT->isObjCIdType()) {
1213 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1214 << BaseExpr->getType() << 0 << arrayRef;
1215 return false;
1216 }
1217 AtIndexGetter =
1218 S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1219 RefExpr->getSourceRange(),
1220 true);
1221 }
1222
1223 if (AtIndexGetter) {
1224 QualType T = AtIndexGetter->parameters()[0]->getType();
1225 if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1226 (!arrayRef && !T->isObjCObjectPointerType())) {
1227 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1228 arrayRef ? diag::err_objc_subscript_index_type
1229 : diag::err_objc_subscript_key_type) << T;
1230 S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1231 diag::note_parameter_type) << T;
1232 return false;
1233 }
1234 QualType R = AtIndexGetter->getReturnType();
1235 if (!R->isObjCObjectPointerType()) {
1236 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1237 diag::err_objc_indexing_method_result_type) << R << arrayRef;
1238 S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1239 AtIndexGetter->getDeclName();
1240 }
1241 }
1242 return true;
1243}
1244
1245bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1246 if (AtIndexSetter)
1247 return true;
1248
1249 Expr *BaseExpr = RefExpr->getBaseExpr();
1250 QualType BaseT = BaseExpr->getType();
1251
1252 QualType ResultType;
1253 if (const ObjCObjectPointerType *PTy =
1254 BaseT->getAs<ObjCObjectPointerType>()) {
1255 ResultType = PTy->getPointeeType();
1256 }
1257
1258 Sema::ObjCSubscriptKind Res =
1259 S.CheckSubscriptingKind(FromE: RefExpr->getKeyExpr());
1260 if (Res == Sema::OS_Error) {
1261 if (S.getLangOpts().ObjCAutoRefCount)
1262 CheckKeyForObjCARCConversion(S, ContainerT: ResultType,
1263 Key: RefExpr->getKeyExpr());
1264 return false;
1265 }
1266 bool arrayRef = (Res == Sema::OS_Array);
1267
1268 if (ResultType.isNull()) {
1269 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1270 << BaseExpr->getType() << arrayRef;
1271 return false;
1272 }
1273
1274 if (!arrayRef) {
1275 // dictionary subscripting.
1276 // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1277 IdentifierInfo *KeyIdents[] = {
1278 &S.Context.Idents.get(Name: "setObject"),
1279 &S.Context.Idents.get(Name: "forKeyedSubscript")
1280 };
1281 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1282 }
1283 else {
1284 // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1285 IdentifierInfo *KeyIdents[] = {
1286 &S.Context.Idents.get(Name: "setObject"),
1287 &S.Context.Idents.get(Name: "atIndexedSubscript")
1288 };
1289 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1290 }
1291 AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1292 true /*instance*/);
1293
1294 if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1295 TypeSourceInfo *ReturnTInfo = nullptr;
1296 QualType ReturnType = S.Context.VoidTy;
1297 AtIndexSetter = ObjCMethodDecl::Create(
1298 S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1299 ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1300 true /*Instance*/, false /*isVariadic*/,
1301 /*isPropertyAccessor=*/false,
1302 /*isSynthesizedAccessorStub=*/false,
1303 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1304 ObjCImplementationControl::Required, false);
1305 SmallVector<ParmVarDecl *, 2> Params;
1306 ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1307 SourceLocation(), SourceLocation(),
1308 &S.Context.Idents.get(Name: "object"),
1309 S.Context.getObjCIdType(),
1310 /*TInfo=*/nullptr,
1311 SC_None,
1312 nullptr);
1313 Params.push_back(Elt: object);
1314 ParmVarDecl *key = ParmVarDecl::Create(C&: S.Context, DC: AtIndexSetter,
1315 StartLoc: SourceLocation(), IdLoc: SourceLocation(),
1316 Id: arrayRef ? &S.Context.Idents.get(Name: "index")
1317 : &S.Context.Idents.get(Name: "key"),
1318 T: arrayRef ? S.Context.UnsignedLongTy
1319 : S.Context.getObjCIdType(),
1320 /*TInfo=*/nullptr,
1321 S: SC_None,
1322 DefArg: nullptr);
1323 Params.push_back(Elt: key);
1324 AtIndexSetter->setMethodParams(C&: S.Context, Params, SelLocs: std::nullopt);
1325 }
1326
1327 if (!AtIndexSetter) {
1328 if (!BaseT->isObjCIdType()) {
1329 S.Diag(BaseExpr->getExprLoc(),
1330 diag::err_objc_subscript_method_not_found)
1331 << BaseExpr->getType() << 1 << arrayRef;
1332 return false;
1333 }
1334 AtIndexSetter =
1335 S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1336 RefExpr->getSourceRange(),
1337 true);
1338 }
1339
1340 bool err = false;
1341 if (AtIndexSetter && arrayRef) {
1342 QualType T = AtIndexSetter->parameters()[1]->getType();
1343 if (!T->isIntegralOrEnumerationType()) {
1344 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1345 diag::err_objc_subscript_index_type) << T;
1346 S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1347 diag::note_parameter_type) << T;
1348 err = true;
1349 }
1350 T = AtIndexSetter->parameters()[0]->getType();
1351 if (!T->isObjCObjectPointerType()) {
1352 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1353 diag::err_objc_subscript_object_type) << T << arrayRef;
1354 S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1355 diag::note_parameter_type) << T;
1356 err = true;
1357 }
1358 }
1359 else if (AtIndexSetter && !arrayRef)
1360 for (unsigned i=0; i <2; i++) {
1361 QualType T = AtIndexSetter->parameters()[i]->getType();
1362 if (!T->isObjCObjectPointerType()) {
1363 if (i == 1)
1364 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1365 diag::err_objc_subscript_key_type) << T;
1366 else
1367 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1368 diag::err_objc_subscript_dic_object_type) << T;
1369 S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1370 diag::note_parameter_type) << T;
1371 err = true;
1372 }
1373 }
1374
1375 return !err;
1376}
1377
1378// Get the object at "Index" position in the container.
1379// [BaseExpr objectAtIndexedSubscript : IndexExpr];
1380ExprResult ObjCSubscriptOpBuilder::buildGet() {
1381 if (!findAtIndexGetter())
1382 return ExprError();
1383
1384 QualType receiverType = InstanceBase->getType();
1385
1386 // Build a message-send.
1387 ExprResult msg;
1388 Expr *Index = InstanceKey;
1389
1390 // Arguments.
1391 Expr *args[] = { Index };
1392 assert(InstanceBase);
1393 if (AtIndexGetter)
1394 S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1395 msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1396 GenericLoc,
1397 AtIndexGetterSelector, AtIndexGetter,
1398 MultiExprArg(args, 1));
1399 return msg;
1400}
1401
1402/// Store into the container the "op" object at "Index"'ed location
1403/// by building this messaging expression:
1404/// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1405/// \param captureSetValueAsResult If true, capture the actual
1406/// value being set as the value of the property operation.
1407ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1408 bool captureSetValueAsResult) {
1409 if (!findAtIndexSetter())
1410 return ExprError();
1411 if (AtIndexSetter)
1412 S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1413 QualType receiverType = InstanceBase->getType();
1414 Expr *Index = InstanceKey;
1415
1416 // Arguments.
1417 Expr *args[] = { op, Index };
1418
1419 // Build a message-send.
1420 ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1421 GenericLoc,
1422 AtIndexSetterSelector,
1423 AtIndexSetter,
1424 MultiExprArg(args, 2));
1425
1426 if (!msg.isInvalid() && captureSetValueAsResult) {
1427 ObjCMessageExpr *msgExpr =
1428 cast<ObjCMessageExpr>(Val: msg.get()->IgnoreImplicit());
1429 Expr *arg = msgExpr->getArg(Arg: 0);
1430 if (CanCaptureValue(exp: arg))
1431 msgExpr->setArg(Arg: 0, ArgExpr: captureValueAsResult(arg));
1432 }
1433
1434 return msg;
1435}
1436
1437//===----------------------------------------------------------------------===//
1438// MSVC __declspec(property) references
1439//===----------------------------------------------------------------------===//
1440
1441MSPropertyRefExpr *
1442MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1443 CallArgs.insert(I: CallArgs.begin(), Elt: E->getIdx());
1444 Expr *Base = E->getBase()->IgnoreParens();
1445 while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Val: Base)) {
1446 CallArgs.insert(I: CallArgs.begin(), Elt: MSPropSubscript->getIdx());
1447 Base = MSPropSubscript->getBase()->IgnoreParens();
1448 }
1449 return cast<MSPropertyRefExpr>(Val: Base);
1450}
1451
1452Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1453 InstanceBase = capture(e: RefExpr->getBaseExpr());
1454 for (Expr *&Arg : CallArgs)
1455 Arg = capture(e: Arg);
1456 syntacticBase = Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1457 switch (Idx) {
1458 case 0:
1459 return InstanceBase;
1460 default:
1461 assert(Idx <= CallArgs.size());
1462 return CallArgs[Idx - 1];
1463 }
1464 }).rebuild(e: syntacticBase);
1465
1466 return syntacticBase;
1467}
1468
1469ExprResult MSPropertyOpBuilder::buildGet() {
1470 if (!RefExpr->getPropertyDecl()->hasGetter()) {
1471 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1472 << 0 /* getter */ << RefExpr->getPropertyDecl();
1473 return ExprError();
1474 }
1475
1476 UnqualifiedId GetterName;
1477 IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1478 GetterName.setIdentifier(Id: II, IdLoc: RefExpr->getMemberLoc());
1479 CXXScopeSpec SS;
1480 SS.Adopt(Other: RefExpr->getQualifierLoc());
1481 ExprResult GetterExpr =
1482 S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1483 RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1484 SourceLocation(), GetterName, nullptr);
1485 if (GetterExpr.isInvalid()) {
1486 S.Diag(RefExpr->getMemberLoc(),
1487 diag::err_cannot_find_suitable_accessor) << 0 /* getter */
1488 << RefExpr->getPropertyDecl();
1489 return ExprError();
1490 }
1491
1492 return S.BuildCallExpr(S: S.getCurScope(), Fn: GetterExpr.get(),
1493 LParenLoc: RefExpr->getSourceRange().getBegin(), ArgExprs: CallArgs,
1494 RParenLoc: RefExpr->getSourceRange().getEnd());
1495}
1496
1497ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1498 bool captureSetValueAsResult) {
1499 if (!RefExpr->getPropertyDecl()->hasSetter()) {
1500 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1501 << 1 /* setter */ << RefExpr->getPropertyDecl();
1502 return ExprError();
1503 }
1504
1505 UnqualifiedId SetterName;
1506 IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1507 SetterName.setIdentifier(Id: II, IdLoc: RefExpr->getMemberLoc());
1508 CXXScopeSpec SS;
1509 SS.Adopt(Other: RefExpr->getQualifierLoc());
1510 ExprResult SetterExpr =
1511 S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1512 RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1513 SourceLocation(), SetterName, nullptr);
1514 if (SetterExpr.isInvalid()) {
1515 S.Diag(RefExpr->getMemberLoc(),
1516 diag::err_cannot_find_suitable_accessor) << 1 /* setter */
1517 << RefExpr->getPropertyDecl();
1518 return ExprError();
1519 }
1520
1521 SmallVector<Expr*, 4> ArgExprs;
1522 ArgExprs.append(in_start: CallArgs.begin(), in_end: CallArgs.end());
1523 ArgExprs.push_back(Elt: op);
1524 return S.BuildCallExpr(S: S.getCurScope(), Fn: SetterExpr.get(),
1525 LParenLoc: RefExpr->getSourceRange().getBegin(), ArgExprs,
1526 RParenLoc: op->getSourceRange().getEnd());
1527}
1528
1529//===----------------------------------------------------------------------===//
1530// General Sema routines.
1531//===----------------------------------------------------------------------===//
1532
1533ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1534 Expr *opaqueRef = E->IgnoreParens();
1535 if (ObjCPropertyRefExpr *refExpr
1536 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1537 ObjCPropertyOpBuilder builder(*this, refExpr, true);
1538 return builder.buildRValueOperation(op: E);
1539 }
1540 else if (ObjCSubscriptRefExpr *refExpr
1541 = dyn_cast<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1542 ObjCSubscriptOpBuilder builder(*this, refExpr, true);
1543 return builder.buildRValueOperation(op: E);
1544 } else if (MSPropertyRefExpr *refExpr
1545 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1546 MSPropertyOpBuilder builder(*this, refExpr, true);
1547 return builder.buildRValueOperation(op: E);
1548 } else if (MSPropertySubscriptExpr *RefExpr =
1549 dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1550 MSPropertyOpBuilder Builder(*this, RefExpr, true);
1551 return Builder.buildRValueOperation(op: E);
1552 } else {
1553 llvm_unreachable("unknown pseudo-object kind!");
1554 }
1555}
1556
1557/// Check an increment or decrement of a pseudo-object expression.
1558ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1559 UnaryOperatorKind opcode, Expr *op) {
1560 // Do nothing if the operand is dependent.
1561 if (op->isTypeDependent())
1562 return UnaryOperator::Create(C: Context, input: op, opc: opcode, type: Context.DependentTy,
1563 VK: VK_PRValue, OK: OK_Ordinary, l: opcLoc, CanOverflow: false,
1564 FPFeatures: CurFPFeatureOverrides());
1565
1566 assert(UnaryOperator::isIncrementDecrementOp(opcode));
1567 Expr *opaqueRef = op->IgnoreParens();
1568 if (ObjCPropertyRefExpr *refExpr
1569 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1570 ObjCPropertyOpBuilder builder(*this, refExpr, false);
1571 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1572 } else if (isa<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1573 Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1574 return ExprError();
1575 } else if (MSPropertyRefExpr *refExpr
1576 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1577 MSPropertyOpBuilder builder(*this, refExpr, false);
1578 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1579 } else if (MSPropertySubscriptExpr *RefExpr
1580 = dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1581 MSPropertyOpBuilder Builder(*this, RefExpr, false);
1582 return Builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1583 } else {
1584 llvm_unreachable("unknown pseudo-object kind!");
1585 }
1586}
1587
1588ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1589 BinaryOperatorKind opcode,
1590 Expr *LHS, Expr *RHS) {
1591 // Do nothing if either argument is dependent.
1592 if (LHS->isTypeDependent() || RHS->isTypeDependent())
1593 return BinaryOperator::Create(C: Context, lhs: LHS, rhs: RHS, opc: opcode,
1594 ResTy: Context.DependentTy, VK: VK_PRValue, OK: OK_Ordinary,
1595 opLoc: opcLoc, FPFeatures: CurFPFeatureOverrides());
1596
1597 // Filter out non-overload placeholder types in the RHS.
1598 if (RHS->getType()->isNonOverloadPlaceholderType()) {
1599 ExprResult result = CheckPlaceholderExpr(E: RHS);
1600 if (result.isInvalid()) return ExprError();
1601 RHS = result.get();
1602 }
1603
1604 bool IsSimpleAssign = opcode == BO_Assign;
1605 Expr *opaqueRef = LHS->IgnoreParens();
1606 if (ObjCPropertyRefExpr *refExpr
1607 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1608 ObjCPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1609 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1610 } else if (ObjCSubscriptRefExpr *refExpr
1611 = dyn_cast<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1612 ObjCSubscriptOpBuilder builder(*this, refExpr, IsSimpleAssign);
1613 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1614 } else if (MSPropertyRefExpr *refExpr
1615 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1616 MSPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1617 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1618 } else if (MSPropertySubscriptExpr *RefExpr
1619 = dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1620 MSPropertyOpBuilder Builder(*this, RefExpr, IsSimpleAssign);
1621 return Builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1622 } else {
1623 llvm_unreachable("unknown pseudo-object kind!");
1624 }
1625}
1626
1627/// Given a pseudo-object reference, rebuild it without the opaque
1628/// values. Basically, undo the behavior of rebuildAndCaptureObject.
1629/// This should never operate in-place.
1630static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1631 return Rebuilder(S,
1632 [=](Expr *E, unsigned) -> Expr * {
1633 return cast<OpaqueValueExpr>(Val: E)->getSourceExpr();
1634 })
1635 .rebuild(e: E);
1636}
1637
1638/// Given a pseudo-object expression, recreate what it looks like
1639/// syntactically without the attendant OpaqueValueExprs.
1640///
1641/// This is a hack which should be removed when TreeTransform is
1642/// capable of rebuilding a tree without stripping implicit
1643/// operations.
1644Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1645 Expr *syntax = E->getSyntacticForm();
1646 if (UnaryOperator *uop = dyn_cast<UnaryOperator>(Val: syntax)) {
1647 Expr *op = stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: uop->getSubExpr());
1648 return UnaryOperator::Create(C: Context, input: op, opc: uop->getOpcode(), type: uop->getType(),
1649 VK: uop->getValueKind(), OK: uop->getObjectKind(),
1650 l: uop->getOperatorLoc(), CanOverflow: uop->canOverflow(),
1651 FPFeatures: CurFPFeatureOverrides());
1652 } else if (CompoundAssignOperator *cop
1653 = dyn_cast<CompoundAssignOperator>(Val: syntax)) {
1654 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1655 Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1656 return CompoundAssignOperator::Create(
1657 C: Context, lhs, rhs, opc: cop->getOpcode(), ResTy: cop->getType(),
1658 VK: cop->getValueKind(), OK: cop->getObjectKind(), opLoc: cop->getOperatorLoc(),
1659 FPFeatures: CurFPFeatureOverrides(), CompLHSType: cop->getComputationLHSType(),
1660 CompResultType: cop->getComputationResultType());
1661
1662 } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(Val: syntax)) {
1663 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: bop->getLHS());
1664 Expr *rhs = cast<OpaqueValueExpr>(Val: bop->getRHS())->getSourceExpr();
1665 return BinaryOperator::Create(C: Context, lhs, rhs, opc: bop->getOpcode(),
1666 ResTy: bop->getType(), VK: bop->getValueKind(),
1667 OK: bop->getObjectKind(), opLoc: bop->getOperatorLoc(),
1668 FPFeatures: CurFPFeatureOverrides());
1669
1670 } else if (isa<CallExpr>(Val: syntax)) {
1671 return syntax;
1672 } else {
1673 assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1674 return stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: syntax);
1675 }
1676}
1677

source code of clang/lib/Sema/SemaPseudoObject.cpp