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 const IdentifierInfo *setterName =
617 setter->getSelector().getIdentifierInfoForSlot(argIndex: 0);
618 const 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 const IdentifierInfo *getterName = RefExpr->getImplicitPropertyGetter()
644 ->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 const IdentifierInfo *AltMember =
671 &S.PP.getIdentifierTable().get(Name: PropertyName);
672 if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(
673 AltMember, prop->getQueryKind()))
674 if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
675 S.Diag(RefExpr->getExprLoc(), diag::err_property_setter_ambiguous_use)
676 << prop << prop1 << setter->getSelector();
677 S.Diag(prop->getLocation(), diag::note_property_declare);
678 S.Diag(prop1->getLocation(), diag::note_property_declare);
679 }
680 }
681 Setter = setter;
682 return true;
683 }
684
685 // That can fail in the somewhat crazy situation that we're
686 // type-checking a message send within the @interface declaration
687 // that declared the @property. But it's not clear that that's
688 // valuable to support.
689
690 return false;
691}
692
693void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
694 if (S.getCurLexicalContext()->isObjCContainer() &&
695 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
696 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
697 if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
698 S.Diag(RefExpr->getLocation(),
699 diag::err_property_function_in_objc_container);
700 S.Diag(prop->getLocation(), diag::note_property_declare);
701 }
702 }
703}
704
705/// Capture the base object of an Objective-C property expression.
706Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
707 assert(InstanceReceiver == nullptr);
708
709 // If we have a base, capture it in an OVE and rebuild the syntactic
710 // form to use the OVE as its base.
711 if (RefExpr->isObjectReceiver()) {
712 InstanceReceiver = capture(RefExpr->getBase());
713 syntacticBase = Rebuilder(S, [=](Expr *, unsigned) -> Expr * {
714 return InstanceReceiver;
715 }).rebuild(e: syntacticBase);
716 }
717
718 if (ObjCPropertyRefExpr *
719 refE = dyn_cast<ObjCPropertyRefExpr>(Val: syntacticBase->IgnoreParens()))
720 SyntacticRefExpr = refE;
721
722 return syntacticBase;
723}
724
725/// Load from an Objective-C property reference.
726ExprResult ObjCPropertyOpBuilder::buildGet() {
727 findGetter();
728 if (!Getter) {
729 DiagnoseUnsupportedPropertyUse();
730 return ExprError();
731 }
732
733 if (SyntacticRefExpr)
734 SyntacticRefExpr->setIsMessagingGetter();
735
736 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
737 if (!Getter->isImplicit())
738 S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
739 // Build a message-send.
740 ExprResult msg;
741 if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
742 RefExpr->isObjectReceiver()) {
743 assert(InstanceReceiver || RefExpr->isSuperReceiver());
744 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
745 GenericLoc, Getter->getSelector(),
746 Getter, std::nullopt);
747 } else {
748 msg = S.BuildClassMessageImplicit(ReceiverType: receiverType, isSuperReceiver: RefExpr->isSuperReceiver(),
749 Loc: GenericLoc, Sel: Getter->getSelector(), Method: Getter,
750 Args: std::nullopt);
751 }
752 return msg;
753}
754
755/// Store to an Objective-C property reference.
756///
757/// \param captureSetValueAsResult If true, capture the actual
758/// value being set as the value of the property operation.
759ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
760 bool captureSetValueAsResult) {
761 if (!findSetter(warn: false)) {
762 DiagnoseUnsupportedPropertyUse();
763 return ExprError();
764 }
765
766 if (SyntacticRefExpr)
767 SyntacticRefExpr->setIsMessagingSetter();
768
769 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
770
771 // Use assignment constraints when possible; they give us better
772 // diagnostics. "When possible" basically means anything except a
773 // C++ class type.
774 if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
775 QualType paramType = (*Setter->param_begin())->getType()
776 .substObjCMemberType(
777 receiverType,
778 Setter->getDeclContext(),
779 ObjCSubstitutionContext::Parameter);
780 if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
781 ExprResult opResult = op;
782 Sema::AssignConvertType assignResult
783 = S.CheckSingleAssignmentConstraints(LHSType: paramType, RHS&: opResult);
784 if (opResult.isInvalid() ||
785 S.DiagnoseAssignmentResult(ConvTy: assignResult, Loc: opcLoc, DstType: paramType,
786 SrcType: op->getType(), SrcExpr: opResult.get(),
787 Action: Sema::AA_Assigning))
788 return ExprError();
789
790 op = opResult.get();
791 assert(op && "successful assignment left argument invalid?");
792 }
793 }
794
795 // Arguments.
796 Expr *args[] = { op };
797
798 // Build a message-send.
799 ExprResult msg;
800 if (!Setter->isImplicit())
801 S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
802 if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
803 RefExpr->isObjectReceiver()) {
804 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
805 GenericLoc, SetterSelector, Setter,
806 MultiExprArg(args, 1));
807 } else {
808 msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
809 GenericLoc,
810 SetterSelector, Setter,
811 MultiExprArg(args, 1));
812 }
813
814 if (!msg.isInvalid() && captureSetValueAsResult) {
815 ObjCMessageExpr *msgExpr =
816 cast<ObjCMessageExpr>(Val: msg.get()->IgnoreImplicit());
817 Expr *arg = msgExpr->getArg(Arg: 0);
818 if (CanCaptureValue(exp: arg))
819 msgExpr->setArg(Arg: 0, ArgExpr: captureValueAsResult(arg));
820 }
821
822 return msg;
823}
824
825/// @property-specific behavior for doing lvalue-to-rvalue conversion.
826ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
827 // Explicit properties always have getters, but implicit ones don't.
828 // Check that before proceeding.
829 if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
830 S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
831 << RefExpr->getSourceRange();
832 return ExprError();
833 }
834
835 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
836 if (result.isInvalid()) return ExprError();
837
838 if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
839 S.DiagnosePropertyAccessorMismatch(PD: RefExpr->getExplicitProperty(),
840 Getter, Loc: RefExpr->getLocation());
841
842 // As a special case, if the method returns 'id', try to get
843 // a better type from the property.
844 if (RefExpr->isExplicitProperty() && result.get()->isPRValue()) {
845 QualType receiverType = RefExpr->getReceiverType(ctx: S.Context);
846 QualType propType = RefExpr->getExplicitProperty()
847 ->getUsageType(objectType: receiverType);
848 if (result.get()->getType()->isObjCIdType()) {
849 if (const ObjCObjectPointerType *ptr
850 = propType->getAs<ObjCObjectPointerType>()) {
851 if (!ptr->isObjCIdType())
852 result = S.ImpCastExprToType(E: result.get(), Type: propType, CK: CK_BitCast);
853 }
854 }
855 if (propType.getObjCLifetime() == Qualifiers::OCL_Weak &&
856 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
857 RefExpr->getLocation()))
858 S.getCurFunction()->markSafeWeakUse(RefExpr);
859 }
860
861 return result;
862}
863
864/// Try to build this as a call to a getter that returns a reference.
865///
866/// \return true if it was possible, whether or not it actually
867/// succeeded
868bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
869 ExprResult &result) {
870 if (!S.getLangOpts().CPlusPlus) return false;
871
872 findGetter();
873 if (!Getter) {
874 // The property has no setter and no getter! This can happen if the type is
875 // invalid. Error have already been reported.
876 result = ExprError();
877 return true;
878 }
879
880 // Only do this if the getter returns an l-value reference type.
881 QualType resultType = Getter->getReturnType();
882 if (!resultType->isLValueReferenceType()) return false;
883
884 result = buildRValueOperation(op);
885 return true;
886}
887
888/// @property-specific behavior for doing assignments.
889ExprResult
890ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
891 SourceLocation opcLoc,
892 BinaryOperatorKind opcode,
893 Expr *LHS, Expr *RHS) {
894 assert(BinaryOperator::isAssignmentOp(opcode));
895
896 // If there's no setter, we have no choice but to try to assign to
897 // the result of the getter.
898 if (!findSetter()) {
899 ExprResult result;
900 if (tryBuildGetOfReference(op: LHS, result)) {
901 if (result.isInvalid()) return ExprError();
902 return S.BuildBinOp(S: Sc, OpLoc: opcLoc, Opc: opcode, LHSExpr: result.get(), RHSExpr: RHS);
903 }
904
905 // Otherwise, it's an error.
906 S.Diag(opcLoc, diag::err_nosetter_property_assignment)
907 << unsigned(RefExpr->isImplicitProperty())
908 << SetterSelector
909 << LHS->getSourceRange() << RHS->getSourceRange();
910 return ExprError();
911 }
912
913 // If there is a setter, we definitely want to use it.
914
915 // Verify that we can do a compound assignment.
916 if (opcode != BO_Assign && !findGetter()) {
917 S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
918 << LHS->getSourceRange() << RHS->getSourceRange();
919 return ExprError();
920 }
921
922 ExprResult result =
923 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
924 if (result.isInvalid()) return ExprError();
925
926 // Various warnings about property assignments in ARC.
927 if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
928 S.checkRetainCycles(receiver: InstanceReceiver->getSourceExpr(), argument: RHS);
929 S.checkUnsafeExprAssigns(Loc: opcLoc, LHS, RHS);
930 }
931
932 return result;
933}
934
935/// @property-specific behavior for doing increments and decrements.
936ExprResult
937ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
938 UnaryOperatorKind opcode,
939 Expr *op) {
940 // If there's no setter, we have no choice but to try to assign to
941 // the result of the getter.
942 if (!findSetter()) {
943 ExprResult result;
944 if (tryBuildGetOfReference(op, result)) {
945 if (result.isInvalid()) return ExprError();
946 return S.BuildUnaryOp(S: Sc, OpLoc: opcLoc, Opc: opcode, Input: result.get());
947 }
948
949 // Otherwise, it's an error.
950 S.Diag(opcLoc, diag::err_nosetter_property_incdec)
951 << unsigned(RefExpr->isImplicitProperty())
952 << unsigned(UnaryOperator::isDecrementOp(opcode))
953 << SetterSelector
954 << op->getSourceRange();
955 return ExprError();
956 }
957
958 // If there is a setter, we definitely want to use it.
959
960 // We also need a getter.
961 if (!findGetter()) {
962 assert(RefExpr->isImplicitProperty());
963 S.Diag(opcLoc, diag::err_nogetter_property_incdec)
964 << unsigned(UnaryOperator::isDecrementOp(opcode))
965 << GetterSelector
966 << op->getSourceRange();
967 return ExprError();
968 }
969
970 return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
971}
972
973ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
974 if (isWeakProperty() && !S.isUnevaluatedContext() &&
975 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
976 SyntacticForm->getBeginLoc()))
977 S.getCurFunction()->recordUseOfWeak(E: SyntacticRefExpr,
978 IsRead: SyntacticRefExpr->isMessagingGetter());
979
980 return PseudoOpBuilder::complete(SyntacticForm);
981}
982
983// ObjCSubscript build stuff.
984//
985
986/// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
987/// conversion.
988/// FIXME. Remove this routine if it is proven that no additional
989/// specifity is needed.
990ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
991 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
992 if (result.isInvalid()) return ExprError();
993 return result;
994}
995
996/// objective-c subscripting-specific behavior for doing assignments.
997ExprResult
998ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
999 SourceLocation opcLoc,
1000 BinaryOperatorKind opcode,
1001 Expr *LHS, Expr *RHS) {
1002 assert(BinaryOperator::isAssignmentOp(opcode));
1003 // There must be a method to do the Index'ed assignment.
1004 if (!findAtIndexSetter())
1005 return ExprError();
1006
1007 // Verify that we can do a compound assignment.
1008 if (opcode != BO_Assign && !findAtIndexGetter())
1009 return ExprError();
1010
1011 ExprResult result =
1012 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
1013 if (result.isInvalid()) return ExprError();
1014
1015 // Various warnings about objc Index'ed assignments in ARC.
1016 if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
1017 S.checkRetainCycles(receiver: InstanceBase->getSourceExpr(), argument: RHS);
1018 S.checkUnsafeExprAssigns(Loc: opcLoc, LHS, RHS);
1019 }
1020
1021 return result;
1022}
1023
1024/// Capture the base object of an Objective-C Index'ed expression.
1025Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1026 assert(InstanceBase == nullptr);
1027
1028 // Capture base expression in an OVE and rebuild the syntactic
1029 // form to use the OVE as its base expression.
1030 InstanceBase = capture(RefExpr->getBaseExpr());
1031 InstanceKey = capture(RefExpr->getKeyExpr());
1032
1033 syntacticBase =
1034 Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1035 switch (Idx) {
1036 case 0:
1037 return InstanceBase;
1038 case 1:
1039 return InstanceKey;
1040 default:
1041 llvm_unreachable("Unexpected index for ObjCSubscriptExpr");
1042 }
1043 }).rebuild(e: syntacticBase);
1044
1045 return syntacticBase;
1046}
1047
1048/// CheckSubscriptingKind - This routine decide what type
1049/// of indexing represented by "FromE" is being done.
1050Sema::ObjCSubscriptKind
1051 Sema::CheckSubscriptingKind(Expr *FromE) {
1052 // If the expression already has integral or enumeration type, we're golden.
1053 QualType T = FromE->getType();
1054 if (T->isIntegralOrEnumerationType())
1055 return OS_Array;
1056
1057 // If we don't have a class type in C++, there's no way we can get an
1058 // expression of integral or enumeration type.
1059 const RecordType *RecordTy = T->getAs<RecordType>();
1060 if (!RecordTy &&
1061 (T->isObjCObjectPointerType() || T->isVoidPointerType()))
1062 // All other scalar cases are assumed to be dictionary indexing which
1063 // caller handles, with diagnostics if needed.
1064 return OS_Dictionary;
1065 if (!getLangOpts().CPlusPlus ||
1066 !RecordTy || RecordTy->isIncompleteType()) {
1067 // No indexing can be done. Issue diagnostics and quit.
1068 const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1069 if (isa<StringLiteral>(IndexExpr))
1070 Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1071 << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1072 else
1073 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1074 << T;
1075 return OS_Error;
1076 }
1077
1078 // We must have a complete class type.
1079 if (RequireCompleteType(FromE->getExprLoc(), T,
1080 diag::err_objc_index_incomplete_class_type, FromE))
1081 return OS_Error;
1082
1083 // Look for a conversion to an integral, enumeration type, or
1084 // objective-C pointer type.
1085 int NoIntegrals=0, NoObjCIdPointers=0;
1086 SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1087
1088 for (NamedDecl *D : cast<CXXRecordDecl>(Val: RecordTy->getDecl())
1089 ->getVisibleConversionFunctions()) {
1090 if (CXXConversionDecl *Conversion =
1091 dyn_cast<CXXConversionDecl>(Val: D->getUnderlyingDecl())) {
1092 QualType CT = Conversion->getConversionType().getNonReferenceType();
1093 if (CT->isIntegralOrEnumerationType()) {
1094 ++NoIntegrals;
1095 ConversionDecls.push_back(Elt: Conversion);
1096 }
1097 else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1098 ++NoObjCIdPointers;
1099 ConversionDecls.push_back(Elt: Conversion);
1100 }
1101 }
1102 }
1103 if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1104 return OS_Array;
1105 if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1106 return OS_Dictionary;
1107 if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1108 // No conversion function was found. Issue diagnostic and return.
1109 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1110 << FromE->getType();
1111 return OS_Error;
1112 }
1113 Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1114 << FromE->getType();
1115 for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1116 Diag(ConversionDecls[i]->getLocation(),
1117 diag::note_conv_function_declared_at);
1118
1119 return OS_Error;
1120}
1121
1122/// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1123/// objects used as dictionary subscript key objects.
1124static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1125 Expr *Key) {
1126 if (ContainerT.isNull())
1127 return;
1128 // dictionary subscripting.
1129 // - (id)objectForKeyedSubscript:(id)key;
1130 const IdentifierInfo *KeyIdents[] = {
1131 &S.Context.Idents.get(Name: "objectForKeyedSubscript")};
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: CheckedConversionKind::Implicit);
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 const IdentifierInfo *KeyIdents[] = {
1173 &S.Context.Idents.get(Name: "objectForKeyedSubscript")};
1174 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1175 }
1176 else {
1177 // - (id)objectAtIndexedSubscript:(size_t)index;
1178 const IdentifierInfo *KeyIdents[] = {
1179 &S.Context.Idents.get(Name: "objectAtIndexedSubscript")};
1180
1181 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1182 }
1183
1184 AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1185 true /*instance*/);
1186
1187 if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1188 AtIndexGetter = ObjCMethodDecl::Create(
1189 S.Context, SourceLocation(), SourceLocation(), AtIndexGetterSelector,
1190 S.Context.getObjCIdType() /*ReturnType*/, nullptr /*TypeSourceInfo */,
1191 S.Context.getTranslationUnitDecl(), true /*Instance*/,
1192 false /*isVariadic*/,
1193 /*isPropertyAccessor=*/false,
1194 /*isSynthesizedAccessorStub=*/false,
1195 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1196 ObjCImplementationControl::Required, false);
1197 ParmVarDecl *Argument = ParmVarDecl::Create(C&: S.Context, DC: AtIndexGetter,
1198 StartLoc: SourceLocation(), IdLoc: SourceLocation(),
1199 Id: arrayRef ? &S.Context.Idents.get(Name: "index")
1200 : &S.Context.Idents.get(Name: "key"),
1201 T: arrayRef ? S.Context.UnsignedLongTy
1202 : S.Context.getObjCIdType(),
1203 /*TInfo=*/nullptr,
1204 S: SC_None,
1205 DefArg: nullptr);
1206 AtIndexGetter->setMethodParams(C&: S.Context, Params: Argument, SelLocs: std::nullopt);
1207 }
1208
1209 if (!AtIndexGetter) {
1210 if (!BaseT->isObjCIdType()) {
1211 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1212 << BaseExpr->getType() << 0 << arrayRef;
1213 return false;
1214 }
1215 AtIndexGetter =
1216 S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1217 RefExpr->getSourceRange(),
1218 true);
1219 }
1220
1221 if (AtIndexGetter) {
1222 QualType T = AtIndexGetter->parameters()[0]->getType();
1223 if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1224 (!arrayRef && !T->isObjCObjectPointerType())) {
1225 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1226 arrayRef ? diag::err_objc_subscript_index_type
1227 : diag::err_objc_subscript_key_type) << T;
1228 S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1229 diag::note_parameter_type) << T;
1230 return false;
1231 }
1232 QualType R = AtIndexGetter->getReturnType();
1233 if (!R->isObjCObjectPointerType()) {
1234 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1235 diag::err_objc_indexing_method_result_type) << R << arrayRef;
1236 S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1237 AtIndexGetter->getDeclName();
1238 }
1239 }
1240 return true;
1241}
1242
1243bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1244 if (AtIndexSetter)
1245 return true;
1246
1247 Expr *BaseExpr = RefExpr->getBaseExpr();
1248 QualType BaseT = BaseExpr->getType();
1249
1250 QualType ResultType;
1251 if (const ObjCObjectPointerType *PTy =
1252 BaseT->getAs<ObjCObjectPointerType>()) {
1253 ResultType = PTy->getPointeeType();
1254 }
1255
1256 Sema::ObjCSubscriptKind Res =
1257 S.CheckSubscriptingKind(FromE: RefExpr->getKeyExpr());
1258 if (Res == Sema::OS_Error) {
1259 if (S.getLangOpts().ObjCAutoRefCount)
1260 CheckKeyForObjCARCConversion(S, ContainerT: ResultType,
1261 Key: RefExpr->getKeyExpr());
1262 return false;
1263 }
1264 bool arrayRef = (Res == Sema::OS_Array);
1265
1266 if (ResultType.isNull()) {
1267 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1268 << BaseExpr->getType() << arrayRef;
1269 return false;
1270 }
1271
1272 if (!arrayRef) {
1273 // dictionary subscripting.
1274 // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1275 const IdentifierInfo *KeyIdents[] = {
1276 &S.Context.Idents.get(Name: "setObject"),
1277 &S.Context.Idents.get(Name: "forKeyedSubscript")};
1278 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1279 }
1280 else {
1281 // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1282 const IdentifierInfo *KeyIdents[] = {
1283 &S.Context.Idents.get(Name: "setObject"),
1284 &S.Context.Idents.get(Name: "atIndexedSubscript")};
1285 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1286 }
1287 AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1288 true /*instance*/);
1289
1290 if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1291 TypeSourceInfo *ReturnTInfo = nullptr;
1292 QualType ReturnType = S.Context.VoidTy;
1293 AtIndexSetter = ObjCMethodDecl::Create(
1294 S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1295 ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1296 true /*Instance*/, false /*isVariadic*/,
1297 /*isPropertyAccessor=*/false,
1298 /*isSynthesizedAccessorStub=*/false,
1299 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1300 ObjCImplementationControl::Required, false);
1301 SmallVector<ParmVarDecl *, 2> Params;
1302 ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1303 SourceLocation(), SourceLocation(),
1304 &S.Context.Idents.get(Name: "object"),
1305 S.Context.getObjCIdType(),
1306 /*TInfo=*/nullptr,
1307 SC_None,
1308 nullptr);
1309 Params.push_back(Elt: object);
1310 ParmVarDecl *key = ParmVarDecl::Create(C&: S.Context, DC: AtIndexSetter,
1311 StartLoc: SourceLocation(), IdLoc: SourceLocation(),
1312 Id: arrayRef ? &S.Context.Idents.get(Name: "index")
1313 : &S.Context.Idents.get(Name: "key"),
1314 T: arrayRef ? S.Context.UnsignedLongTy
1315 : S.Context.getObjCIdType(),
1316 /*TInfo=*/nullptr,
1317 S: SC_None,
1318 DefArg: nullptr);
1319 Params.push_back(Elt: key);
1320 AtIndexSetter->setMethodParams(C&: S.Context, Params, SelLocs: std::nullopt);
1321 }
1322
1323 if (!AtIndexSetter) {
1324 if (!BaseT->isObjCIdType()) {
1325 S.Diag(BaseExpr->getExprLoc(),
1326 diag::err_objc_subscript_method_not_found)
1327 << BaseExpr->getType() << 1 << arrayRef;
1328 return false;
1329 }
1330 AtIndexSetter =
1331 S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1332 RefExpr->getSourceRange(),
1333 true);
1334 }
1335
1336 bool err = false;
1337 if (AtIndexSetter && arrayRef) {
1338 QualType T = AtIndexSetter->parameters()[1]->getType();
1339 if (!T->isIntegralOrEnumerationType()) {
1340 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1341 diag::err_objc_subscript_index_type) << T;
1342 S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1343 diag::note_parameter_type) << T;
1344 err = true;
1345 }
1346 T = AtIndexSetter->parameters()[0]->getType();
1347 if (!T->isObjCObjectPointerType()) {
1348 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1349 diag::err_objc_subscript_object_type) << T << arrayRef;
1350 S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1351 diag::note_parameter_type) << T;
1352 err = true;
1353 }
1354 }
1355 else if (AtIndexSetter && !arrayRef)
1356 for (unsigned i=0; i <2; i++) {
1357 QualType T = AtIndexSetter->parameters()[i]->getType();
1358 if (!T->isObjCObjectPointerType()) {
1359 if (i == 1)
1360 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1361 diag::err_objc_subscript_key_type) << T;
1362 else
1363 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1364 diag::err_objc_subscript_dic_object_type) << T;
1365 S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1366 diag::note_parameter_type) << T;
1367 err = true;
1368 }
1369 }
1370
1371 return !err;
1372}
1373
1374// Get the object at "Index" position in the container.
1375// [BaseExpr objectAtIndexedSubscript : IndexExpr];
1376ExprResult ObjCSubscriptOpBuilder::buildGet() {
1377 if (!findAtIndexGetter())
1378 return ExprError();
1379
1380 QualType receiverType = InstanceBase->getType();
1381
1382 // Build a message-send.
1383 ExprResult msg;
1384 Expr *Index = InstanceKey;
1385
1386 // Arguments.
1387 Expr *args[] = { Index };
1388 assert(InstanceBase);
1389 if (AtIndexGetter)
1390 S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1391 msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1392 GenericLoc,
1393 AtIndexGetterSelector, AtIndexGetter,
1394 MultiExprArg(args, 1));
1395 return msg;
1396}
1397
1398/// Store into the container the "op" object at "Index"'ed location
1399/// by building this messaging expression:
1400/// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1401/// \param captureSetValueAsResult If true, capture the actual
1402/// value being set as the value of the property operation.
1403ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1404 bool captureSetValueAsResult) {
1405 if (!findAtIndexSetter())
1406 return ExprError();
1407 if (AtIndexSetter)
1408 S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1409 QualType receiverType = InstanceBase->getType();
1410 Expr *Index = InstanceKey;
1411
1412 // Arguments.
1413 Expr *args[] = { op, Index };
1414
1415 // Build a message-send.
1416 ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1417 GenericLoc,
1418 AtIndexSetterSelector,
1419 AtIndexSetter,
1420 MultiExprArg(args, 2));
1421
1422 if (!msg.isInvalid() && captureSetValueAsResult) {
1423 ObjCMessageExpr *msgExpr =
1424 cast<ObjCMessageExpr>(Val: msg.get()->IgnoreImplicit());
1425 Expr *arg = msgExpr->getArg(Arg: 0);
1426 if (CanCaptureValue(exp: arg))
1427 msgExpr->setArg(Arg: 0, ArgExpr: captureValueAsResult(arg));
1428 }
1429
1430 return msg;
1431}
1432
1433//===----------------------------------------------------------------------===//
1434// MSVC __declspec(property) references
1435//===----------------------------------------------------------------------===//
1436
1437MSPropertyRefExpr *
1438MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1439 CallArgs.insert(I: CallArgs.begin(), Elt: E->getIdx());
1440 Expr *Base = E->getBase()->IgnoreParens();
1441 while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Val: Base)) {
1442 CallArgs.insert(I: CallArgs.begin(), Elt: MSPropSubscript->getIdx());
1443 Base = MSPropSubscript->getBase()->IgnoreParens();
1444 }
1445 return cast<MSPropertyRefExpr>(Val: Base);
1446}
1447
1448Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1449 InstanceBase = capture(e: RefExpr->getBaseExpr());
1450 for (Expr *&Arg : CallArgs)
1451 Arg = capture(e: Arg);
1452 syntacticBase = Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1453 switch (Idx) {
1454 case 0:
1455 return InstanceBase;
1456 default:
1457 assert(Idx <= CallArgs.size());
1458 return CallArgs[Idx - 1];
1459 }
1460 }).rebuild(e: syntacticBase);
1461
1462 return syntacticBase;
1463}
1464
1465ExprResult MSPropertyOpBuilder::buildGet() {
1466 if (!RefExpr->getPropertyDecl()->hasGetter()) {
1467 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1468 << 0 /* getter */ << RefExpr->getPropertyDecl();
1469 return ExprError();
1470 }
1471
1472 UnqualifiedId GetterName;
1473 const IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1474 GetterName.setIdentifier(Id: II, IdLoc: RefExpr->getMemberLoc());
1475 CXXScopeSpec SS;
1476 SS.Adopt(Other: RefExpr->getQualifierLoc());
1477 ExprResult GetterExpr =
1478 S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1479 RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1480 SourceLocation(), GetterName, nullptr);
1481 if (GetterExpr.isInvalid()) {
1482 S.Diag(RefExpr->getMemberLoc(),
1483 diag::err_cannot_find_suitable_accessor) << 0 /* getter */
1484 << RefExpr->getPropertyDecl();
1485 return ExprError();
1486 }
1487
1488 return S.BuildCallExpr(S: S.getCurScope(), Fn: GetterExpr.get(),
1489 LParenLoc: RefExpr->getSourceRange().getBegin(), ArgExprs: CallArgs,
1490 RParenLoc: RefExpr->getSourceRange().getEnd());
1491}
1492
1493ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1494 bool captureSetValueAsResult) {
1495 if (!RefExpr->getPropertyDecl()->hasSetter()) {
1496 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1497 << 1 /* setter */ << RefExpr->getPropertyDecl();
1498 return ExprError();
1499 }
1500
1501 UnqualifiedId SetterName;
1502 const IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1503 SetterName.setIdentifier(Id: II, IdLoc: RefExpr->getMemberLoc());
1504 CXXScopeSpec SS;
1505 SS.Adopt(Other: RefExpr->getQualifierLoc());
1506 ExprResult SetterExpr =
1507 S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1508 RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1509 SourceLocation(), SetterName, nullptr);
1510 if (SetterExpr.isInvalid()) {
1511 S.Diag(RefExpr->getMemberLoc(),
1512 diag::err_cannot_find_suitable_accessor) << 1 /* setter */
1513 << RefExpr->getPropertyDecl();
1514 return ExprError();
1515 }
1516
1517 SmallVector<Expr*, 4> ArgExprs;
1518 ArgExprs.append(in_start: CallArgs.begin(), in_end: CallArgs.end());
1519 ArgExprs.push_back(Elt: op);
1520 return S.BuildCallExpr(S: S.getCurScope(), Fn: SetterExpr.get(),
1521 LParenLoc: RefExpr->getSourceRange().getBegin(), ArgExprs,
1522 RParenLoc: op->getSourceRange().getEnd());
1523}
1524
1525//===----------------------------------------------------------------------===//
1526// General Sema routines.
1527//===----------------------------------------------------------------------===//
1528
1529ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1530 Expr *opaqueRef = E->IgnoreParens();
1531 if (ObjCPropertyRefExpr *refExpr
1532 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1533 ObjCPropertyOpBuilder builder(*this, refExpr, true);
1534 return builder.buildRValueOperation(op: E);
1535 }
1536 else if (ObjCSubscriptRefExpr *refExpr
1537 = dyn_cast<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1538 ObjCSubscriptOpBuilder builder(*this, refExpr, true);
1539 return builder.buildRValueOperation(op: E);
1540 } else if (MSPropertyRefExpr *refExpr
1541 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1542 MSPropertyOpBuilder builder(*this, refExpr, true);
1543 return builder.buildRValueOperation(op: E);
1544 } else if (MSPropertySubscriptExpr *RefExpr =
1545 dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1546 MSPropertyOpBuilder Builder(*this, RefExpr, true);
1547 return Builder.buildRValueOperation(op: E);
1548 } else {
1549 llvm_unreachable("unknown pseudo-object kind!");
1550 }
1551}
1552
1553/// Check an increment or decrement of a pseudo-object expression.
1554ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1555 UnaryOperatorKind opcode, Expr *op) {
1556 // Do nothing if the operand is dependent.
1557 if (op->isTypeDependent())
1558 return UnaryOperator::Create(C: Context, input: op, opc: opcode, type: Context.DependentTy,
1559 VK: VK_PRValue, OK: OK_Ordinary, l: opcLoc, CanOverflow: false,
1560 FPFeatures: CurFPFeatureOverrides());
1561
1562 assert(UnaryOperator::isIncrementDecrementOp(opcode));
1563 Expr *opaqueRef = op->IgnoreParens();
1564 if (ObjCPropertyRefExpr *refExpr
1565 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1566 ObjCPropertyOpBuilder builder(*this, refExpr, false);
1567 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1568 } else if (isa<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1569 Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1570 return ExprError();
1571 } else if (MSPropertyRefExpr *refExpr
1572 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1573 MSPropertyOpBuilder builder(*this, refExpr, false);
1574 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1575 } else if (MSPropertySubscriptExpr *RefExpr
1576 = dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1577 MSPropertyOpBuilder Builder(*this, RefExpr, false);
1578 return Builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1579 } else {
1580 llvm_unreachable("unknown pseudo-object kind!");
1581 }
1582}
1583
1584ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1585 BinaryOperatorKind opcode,
1586 Expr *LHS, Expr *RHS) {
1587 // Do nothing if either argument is dependent.
1588 if (LHS->isTypeDependent() || RHS->isTypeDependent())
1589 return BinaryOperator::Create(C: Context, lhs: LHS, rhs: RHS, opc: opcode,
1590 ResTy: Context.DependentTy, VK: VK_PRValue, OK: OK_Ordinary,
1591 opLoc: opcLoc, FPFeatures: CurFPFeatureOverrides());
1592
1593 // Filter out non-overload placeholder types in the RHS.
1594 if (RHS->getType()->isNonOverloadPlaceholderType()) {
1595 ExprResult result = CheckPlaceholderExpr(E: RHS);
1596 if (result.isInvalid()) return ExprError();
1597 RHS = result.get();
1598 }
1599
1600 bool IsSimpleAssign = opcode == BO_Assign;
1601 Expr *opaqueRef = LHS->IgnoreParens();
1602 if (ObjCPropertyRefExpr *refExpr
1603 = dyn_cast<ObjCPropertyRefExpr>(Val: opaqueRef)) {
1604 ObjCPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1605 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1606 } else if (ObjCSubscriptRefExpr *refExpr
1607 = dyn_cast<ObjCSubscriptRefExpr>(Val: opaqueRef)) {
1608 ObjCSubscriptOpBuilder builder(*this, refExpr, IsSimpleAssign);
1609 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1610 } else if (MSPropertyRefExpr *refExpr
1611 = dyn_cast<MSPropertyRefExpr>(Val: opaqueRef)) {
1612 MSPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1613 return builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1614 } else if (MSPropertySubscriptExpr *RefExpr
1615 = dyn_cast<MSPropertySubscriptExpr>(Val: opaqueRef)) {
1616 MSPropertyOpBuilder Builder(*this, RefExpr, IsSimpleAssign);
1617 return Builder.buildAssignmentOperation(Sc: S, opcLoc, opcode, LHS, RHS);
1618 } else {
1619 llvm_unreachable("unknown pseudo-object kind!");
1620 }
1621}
1622
1623/// Given a pseudo-object reference, rebuild it without the opaque
1624/// values. Basically, undo the behavior of rebuildAndCaptureObject.
1625/// This should never operate in-place.
1626static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1627 return Rebuilder(S,
1628 [=](Expr *E, unsigned) -> Expr * {
1629 return cast<OpaqueValueExpr>(Val: E)->getSourceExpr();
1630 })
1631 .rebuild(e: E);
1632}
1633
1634/// Given a pseudo-object expression, recreate what it looks like
1635/// syntactically without the attendant OpaqueValueExprs.
1636///
1637/// This is a hack which should be removed when TreeTransform is
1638/// capable of rebuilding a tree without stripping implicit
1639/// operations.
1640Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1641 Expr *syntax = E->getSyntacticForm();
1642 if (UnaryOperator *uop = dyn_cast<UnaryOperator>(Val: syntax)) {
1643 Expr *op = stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: uop->getSubExpr());
1644 return UnaryOperator::Create(C: Context, input: op, opc: uop->getOpcode(), type: uop->getType(),
1645 VK: uop->getValueKind(), OK: uop->getObjectKind(),
1646 l: uop->getOperatorLoc(), CanOverflow: uop->canOverflow(),
1647 FPFeatures: CurFPFeatureOverrides());
1648 } else if (CompoundAssignOperator *cop
1649 = dyn_cast<CompoundAssignOperator>(Val: syntax)) {
1650 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1651 Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1652 return CompoundAssignOperator::Create(
1653 C: Context, lhs, rhs, opc: cop->getOpcode(), ResTy: cop->getType(),
1654 VK: cop->getValueKind(), OK: cop->getObjectKind(), opLoc: cop->getOperatorLoc(),
1655 FPFeatures: CurFPFeatureOverrides(), CompLHSType: cop->getComputationLHSType(),
1656 CompResultType: cop->getComputationResultType());
1657
1658 } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(Val: syntax)) {
1659 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: bop->getLHS());
1660 Expr *rhs = cast<OpaqueValueExpr>(Val: bop->getRHS())->getSourceExpr();
1661 return BinaryOperator::Create(C: Context, lhs, rhs, opc: bop->getOpcode(),
1662 ResTy: bop->getType(), VK: bop->getValueKind(),
1663 OK: bop->getObjectKind(), opLoc: bop->getOperatorLoc(),
1664 FPFeatures: CurFPFeatureOverrides());
1665
1666 } else if (isa<CallExpr>(Val: syntax)) {
1667 return syntax;
1668 } else {
1669 assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1670 return stripOpaqueValuesFromPseudoObjectRef(S&: *this, E: syntax);
1671 }
1672}
1673

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