clang/lib/Sema/SemaPseudoObject.cpp

   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
  41 using namespace clang;
  42 using namespace sema;
  43
  44 namespace {
  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(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>(e))
 109         return rebuildObjCPropertyRefExpr(PRE);
 110       if (auto *SRE = dyn_cast<ObjCSubscriptRefExpr>(e))
 111         return rebuildObjCSubscriptRefExpr(SRE);
 112       if (auto *MSPRE = dyn_cast<MSPropertyRefExpr>(e))
 113         return rebuildMSPropertyRefExpr(MSPRE);
 114       if (auto *MSPSE = dyn_cast<MSPropertySubscriptExpr>(e))
 115         return rebuildMSPropertySubscriptExpr(MSPSE);
 116
 117       // Otherwise, we should look through and rebuild anything that
 118       // IgnoreParens would.
 119
 120       if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
 121         e = rebuild(parens->getSubExpr());
 122         return new (S.Context) ParenExpr(parens->getLParen(),
 123                                          parens->getRParen(),
 124                                          e);
 125       }
 126
 127       if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
 128         assert(uop->getOpcode() == UO_Extension);
 129         e = rebuild(uop->getSubExpr());
 130         return UnaryOperator::Create(
 131             S.Context, e, uop->getOpcode(), uop->getType(), uop->getValueKind(),
 132             uop->getObjectKind(), uop->getOperatorLoc(), uop->canOverflow(),
 133             S.CurFPFeatureOverrides());
 134       }
 135
 136       if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(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(numAssocs);
 144         assocTypes.reserve(numAssocs);
 145
 146         for (const GenericSelectionExpr::Association assoc :
 147              gse->associations()) {
 148           Expr *assocExpr = assoc.getAssociationExpr();
 149           if (assoc.isSelected())
 150             assocExpr = rebuild(assocExpr);
 151           assocExprs.push_back(assocExpr);
 152           assocTypes.push_back(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>(e)) {
 167         assert(!ce->isConditionDependent());
 168
 169         Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
 170         Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
 171         rebuiltExpr = rebuild(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(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(resultExpr);
 208       // An OVE is not unique if it is used as the result expression.
 209       if (auto *OVE = dyn_cast<OpaqueValueExpr>(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>(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(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.
 364 OpaqueValueExpr *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
 384 OpaqueValueExpr *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>(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>(e)->setIsUnique(false);
 406   return cast<OpaqueValueExpr>(e);
 407 }
 408
 409 /// The routine which creates the final PseudoObjectExpr.
 410 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
 411   return PseudoObjectExpr::Create(S.Context, syntactic,
 412                                   Semantics, ResultIndex);
 413 }
 414
 415 /// The main skeleton for building an r-value operation.
 416 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
 417   Expr *syntacticBase = rebuildAndCaptureObject(op);
 418
 419   ExprResult getExpr = buildGet();
 420   if (getExpr.isInvalid()) return ExprError();
 421   addResultSemanticExpr(getExpr.get());
 422
 423   return complete(syntacticBase);
 424 }
 425
 426 /// The basic skeleton for building a simple or compound
 427 /// assignment operation.
 428 ExprResult
 429 PseudoOpBuilder::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(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>(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(S.Context, syntacticLHS, capturedRHS,
 455                                        opcode, capturedRHS->getType(),
 456                                        capturedRHS->getValueKind(), OK_Ordinary,
 457                                        opcLoc, 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(opcode);
 466     result = S.BuildBinOp(Sc, opcLoc, nonCompound, opLHS.get(), 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());
 479   if (result.isInvalid()) return ExprError();
 480   addSemanticExpr(result.get());
 481   if (!captureSetValueAsResult() && !result.get()->getType()->isVoidType() &&
 482       (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
 483     setResultToLastSemantic();
 484
 485   return complete(syntactic);
 486 }
 487
 488 /// The basic skeleton for building an increment or decrement
 489 /// operation.
 490 ExprResult
 491 PseudoOpBuilder::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(opcode) &&
 506       (result.get()->isTypeDependent() || CanCaptureValue(result.get()))) {
 507     result = capture(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(opcode)) {
 517     result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one);
 518   } else {
 519     result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), 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, UnaryOperator::isPrefix(opcode) &&
 526                                               captureSetValueAsResult());
 527   if (result.isInvalid()) return ExprError();
 528   addSemanticExpr(result.get());
 529   if (UnaryOperator::isPrefix(opcode) && !captureSetValueAsResult() &&
 530       !result.get()->getType()->isVoidType() &&
 531       (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
 532     setResultToLastSemantic();
 533
 534   UnaryOperator *syntactic =
 535       UnaryOperator::Create(S.Context, syntacticOp, opcode, resultType,
 536                             VK_LValue, OK_Ordinary, opcLoc,
 537                             !resultType->isDependentType()
 538                                 ? S.Context.getTypeSize(resultType) >=
 539                                       S.Context.getTypeSize(S.Context.IntTy)
 540                                 : false,
 541                             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.
 552 static 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(const_cast<Expr*>(PRE->getBase()))) {
 561       // This cast is safe because isSelfExpr is only true within
 562       // methods.
 563       ObjCMethodDecl *method =
 564         cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
 565       return S.LookupMethodInObjectType(sel,
 566                  S.Context.getObjCInterfaceType(method->getClassInterface()),
 567                                         /*instance*/ false);
 568     }
 569
 570     return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
 571   }
 572
 573   if (PRE->isSuperReceiver()) {
 574     if (const ObjCObjectPointerType *PT =
 575         PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
 576       return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
 577
 578     return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
 579   }
 580
 581   assert(PRE->isClassReceiver() && "Invalid expression");
 582   QualType IT = S.Context.getObjCInterfaceType(PRE->getClassReceiver());
 583   return S.LookupMethodInObjectType(sel, IT, false);
 584 }
 585
 586 bool 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
 603 bool 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(0);
 618       IdentifierInfo *getterName =
 619           &S.Context.Idents.get(setterName->getName().substr(3));
 620       GetterSelector =
 621         S.PP.getSelectorTable().getNullarySelector(getterName);
 622       return false;
 623     }
 624   }
 625
 626   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
 627   Getter = LookupMethodInReceiverType(S, prop->getGetterName(), 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
 635 bool 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(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(front) ? toUppercase(front) : toLowercase(front);
 668         SmallString<100> PropertyName = thisPropertyName;
 669         PropertyName[0] = front;
 670         IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(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
 692 void 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.
 705 Expr *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(syntacticBase);
 715   }
 716
 717   if (ObjCPropertyRefExpr *
 718         refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
 719     SyntacticRefExpr = refE;
 720
 721   return syntacticBase;
 722 }
 723
 724 /// Load from an Objective-C property reference.
 725 ExprResult 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(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, RefExpr->isSuperReceiver(),
 748                                       GenericLoc, Getter->getSelector(), Getter,
 749                                       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.
 758 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
 759                                            bool captureSetValueAsResult) {
 760   if (!findSetter(false)) {
 761     DiagnoseUnsupportedPropertyUse();
 762     return ExprError();
 763   }
 764
 765   if (SyntacticRefExpr)
 766     SyntacticRefExpr->setIsMessagingSetter();
 767
 768   QualType receiverType = RefExpr->getReceiverType(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(paramType, opResult);
 783       if (opResult.isInvalid() ||
 784           S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
 785                                      op->getType(), opResult.get(),
 786                                      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>(msg.get()->IgnoreImplicit());
 816     Expr *arg = msgExpr->getArg(0);
 817     if (CanCaptureValue(arg))
 818       msgExpr->setArg(0, captureValueAsResult(arg));
 819   }
 820
 821   return msg;
 822 }
 823
 824 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
 825 ExprResult 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(RefExpr->getExplicitProperty(),
 839                                        Getter, 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(S.Context);
 845     QualType propType = RefExpr->getExplicitProperty()
 846                           ->getUsageType(receiverType);
 847     if (result.get()->getType()->isObjCIdType()) {
 848       if (const ObjCObjectPointerType *ptr
 849             = propType->getAs<ObjCObjectPointerType>()) {
 850         if (!ptr->isObjCIdType())
 851           result = S.ImpCastExprToType(result.get(), propType, 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
 867 bool 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.
 888 ExprResult
 889 ObjCPropertyOpBuilder::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(LHS, result)) {
 900       if (result.isInvalid()) return ExprError();
 901       return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), 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(InstanceReceiver->getSourceExpr(), RHS);
 928     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
 929   }
 930
 931   return result;
 932 }
 933
 934 /// @property-specific behavior for doing increments and decrements.
 935 ExprResult
 936 ObjCPropertyOpBuilder::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(Sc, opcLoc, opcode, 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
 972 ExprResult 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(SyntacticRefExpr,
 977                                         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.
 989 ExprResult 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.
 996 ExprResult
 997 ObjCSubscriptOpBuilder::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(InstanceBase->getSourceExpr(), RHS);
1017     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
1018   }
1019
1020   return result;
1021 }
1022
1023 /// Capture the base object of an Objective-C Index'ed expression.
1024 Expr *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(syntacticBase);
1043
1044   return syntacticBase;
1045 }
1046
1047 /// CheckSubscriptingKind - This routine decide what type
1048 /// of indexing represented by "FromE" is being done.
1049 Sema::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>(RecordTy->getDecl())
1088                           ->getVisibleConversionFunctions()) {
1089     if (CXXConversionDecl *Conversion =
1090             dyn_cast<CXXConversionDecl>(D->getUnderlyingDecl())) {
1091       QualType CT = Conversion->getConversionType().getNonReferenceType();
1092       if (CT->isIntegralOrEnumerationType()) {
1093         ++NoIntegrals;
1094         ConversionDecls.push_back(Conversion);
1095       }
1096       else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1097         ++NoObjCIdPointers;
1098         ConversionDecls.push_back(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.
1123 static 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("objectForKeyedSubscript")
1131   };
1132   Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1133   ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1134                                                       true /*instance*/);
1135   if (!Getter)
1136     return;
1137   QualType T = Getter->parameters()[0]->getType();
1138   S.CheckObjCConversion(Key->getSourceRange(), T, Key,
1139                         Sema::CCK_ImplicitConversion);
1140 }
1141
1142 bool 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(RefExpr->getKeyExpr());
1156   if (Res == Sema::OS_Error) {
1157     if (S.getLangOpts().ObjCAutoRefCount)
1158       CheckKeyForObjCARCConversion(S, ResultType,
1159                                    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("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("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(S.Context, AtIndexGetter,
1200                                                 SourceLocation(), SourceLocation(),
1201                                                 arrayRef ? &S.Context.Idents.get("index")
1202                                                          : &S.Context.Idents.get("key"),
1203                                                 arrayRef ? S.Context.UnsignedLongTy
1204                                                          : S.Context.getObjCIdType(),
1205                                                 /*TInfo=*/nullptr,
1206                                                 SC_None,
1207                                                 nullptr);
1208     AtIndexGetter->setMethodParams(S.Context, Argument, 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
1245 bool 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(RefExpr->getKeyExpr());
1260   if (Res == Sema::OS_Error) {
1261     if (S.getLangOpts().ObjCAutoRefCount)
1262       CheckKeyForObjCARCConversion(S, ResultType,
1263                                    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("setObject"),
1279       &S.Context.Idents.get("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("setObject"),
1287       &S.Context.Idents.get("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("object"),
1309                                                 S.Context.getObjCIdType(),
1310                                                 /*TInfo=*/nullptr,
1311                                                 SC_None,
1312                                                 nullptr);
1313     Params.push_back(object);
1314     ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1315                                                 SourceLocation(), SourceLocation(),
1316                                                 arrayRef ?  &S.Context.Idents.get("index")
1317                                                          :  &S.Context.Idents.get("key"),
1318                                                 arrayRef ? S.Context.UnsignedLongTy
1319                                                          : S.Context.getObjCIdType(),
1320                                                 /*TInfo=*/nullptr,
1321                                                 SC_None,
1322                                                 nullptr);
1323     Params.push_back(key);
1324     AtIndexSetter->setMethodParams(S.Context, Params, 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];
1380 ExprResult 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.
1407 ExprResult 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>(msg.get()->IgnoreImplicit());
1429     Expr *arg = msgExpr->getArg(0);
1430     if (CanCaptureValue(arg))
1431       msgExpr->setArg(0, captureValueAsResult(arg));
1432   }
1433
1434   return msg;
1435 }
1436
1437 //===----------------------------------------------------------------------===//
1438 //  MSVC __declspec(property) references
1439 //===----------------------------------------------------------------------===//
1440
1441 MSPropertyRefExpr *
1442 MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1443   CallArgs.insert(CallArgs.begin(), E->getIdx());
1444   Expr *Base = E->getBase()->IgnoreParens();
1445   while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Base)) {
1446     CallArgs.insert(CallArgs.begin(), MSPropSubscript->getIdx());
1447     Base = MSPropSubscript->getBase()->IgnoreParens();
1448   }
1449   return cast<MSPropertyRefExpr>(Base);
1450 }
1451
1452 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1453   InstanceBase = capture(RefExpr->getBaseExpr());
1454   for (Expr *&Arg : CallArgs)
1455     Arg = capture(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(syntacticBase);
1465
1466   return syntacticBase;
1467 }
1468
1469 ExprResult 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(II, RefExpr->getMemberLoc());
1479   CXXScopeSpec SS;
1480   SS.Adopt(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.getCurScope(), GetterExpr.get(),
1493                          RefExpr->getSourceRange().getBegin(), CallArgs,
1494                          RefExpr->getSourceRange().getEnd());
1495 }
1496
1497 ExprResult 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(II, RefExpr->getMemberLoc());
1508   CXXScopeSpec SS;
1509   SS.Adopt(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(CallArgs.begin(), CallArgs.end());
1523   ArgExprs.push_back(op);
1524   return S.BuildCallExpr(S.getCurScope(), SetterExpr.get(),
1525                          RefExpr->getSourceRange().getBegin(), ArgExprs,
1526                          op->getSourceRange().getEnd());
1527 }
1528
1529 //===----------------------------------------------------------------------===//
1530 //  General Sema routines.
1531 //===----------------------------------------------------------------------===//
1532
1533 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1534   Expr *opaqueRef = E->IgnoreParens();
1535   if (ObjCPropertyRefExpr *refExpr
1536         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1537     ObjCPropertyOpBuilder builder(*this, refExpr, true);
1538     return builder.buildRValueOperation(E);
1539   }
1540   else if (ObjCSubscriptRefExpr *refExpr
1541            = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1542     ObjCSubscriptOpBuilder builder(*this, refExpr, true);
1543     return builder.buildRValueOperation(E);
1544   } else if (MSPropertyRefExpr *refExpr
1545              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1546     MSPropertyOpBuilder builder(*this, refExpr, true);
1547     return builder.buildRValueOperation(E);
1548   } else if (MSPropertySubscriptExpr *RefExpr =
1549                  dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1550     MSPropertyOpBuilder Builder(*this, RefExpr, true);
1551     return Builder.buildRValueOperation(E);
1552   } else {
1553     llvm_unreachable("unknown pseudo-object kind!");
1554   }
1555 }
1556
1557 /// Check an increment or decrement of a pseudo-object expression.
1558 ExprResult 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(Context, op, opcode, Context.DependentTy,
1563                                  VK_PRValue, OK_Ordinary, opcLoc, false,
1564                                  CurFPFeatureOverrides());
1565
1566   assert(UnaryOperator::isIncrementDecrementOp(opcode));
1567   Expr *opaqueRef = op->IgnoreParens();
1568   if (ObjCPropertyRefExpr *refExpr
1569         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1570     ObjCPropertyOpBuilder builder(*this, refExpr, false);
1571     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1572   } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1573     Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1574     return ExprError();
1575   } else if (MSPropertyRefExpr *refExpr
1576              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1577     MSPropertyOpBuilder builder(*this, refExpr, false);
1578     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1579   } else if (MSPropertySubscriptExpr *RefExpr
1580              = dyn_cast<MSPropertySubscriptExpr>(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
1588 ExprResult 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(Context, LHS, RHS, opcode,
1594                                   Context.DependentTy, VK_PRValue, OK_Ordinary,
1595                                   opcLoc, CurFPFeatureOverrides());
1596
1597   // Filter out non-overload placeholder types in the RHS.
1598   if (RHS->getType()->isNonOverloadPlaceholderType()) {
1599     ExprResult result = CheckPlaceholderExpr(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>(opaqueRef)) {
1608     ObjCPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1609     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1610   } else if (ObjCSubscriptRefExpr *refExpr
1611              = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1612     ObjCSubscriptOpBuilder builder(*this, refExpr, IsSimpleAssign);
1613     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1614   } else if (MSPropertyRefExpr *refExpr
1615              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1616       MSPropertyOpBuilder builder(*this, refExpr, IsSimpleAssign);
1617       return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1618   } else if (MSPropertySubscriptExpr *RefExpr
1619              = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1620       MSPropertyOpBuilder Builder(*this, RefExpr, IsSimpleAssign);
1621       return Builder.buildAssignmentOperation(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.
1630 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1631   return Rebuilder(S,
1632                    [=](Expr *E, unsigned) -> Expr * {
1633                      return cast<OpaqueValueExpr>(E)->getSourceExpr();
1634                    })
1635       .rebuild(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.
1644 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1645   Expr *syntax = E->getSyntacticForm();
1646   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1647     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1648     return UnaryOperator::Create(Context, op, uop->getOpcode(), uop->getType(),
1649                                  uop->getValueKind(), uop->getObjectKind(),
1650                                  uop->getOperatorLoc(), uop->canOverflow(),
1651                                  CurFPFeatureOverrides());
1652   } else if (CompoundAssignOperator *cop
1653                = dyn_cast<CompoundAssignOperator>(syntax)) {
1654     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1655     Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1656     return CompoundAssignOperator::Create(
1657         Context, lhs, rhs, cop->getOpcode(), cop->getType(),
1658         cop->getValueKind(), cop->getObjectKind(), cop->getOperatorLoc(),
1659         CurFPFeatureOverrides(), cop->getComputationLHSType(),
1660         cop->getComputationResultType());
1661
1662   } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1663     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1664     Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1665     return BinaryOperator::Create(Context, lhs, rhs, bop->getOpcode(),
1666                                   bop->getType(), bop->getValueKind(),
1667                                   bop->getObjectKind(), bop->getOperatorLoc(),
1668                                   CurFPFeatureOverrides());
1669
1670   } else if (isa<CallExpr>(syntax)) {
1671     return syntax;
1672   } else {
1673     assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1674     return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1675   }
1676 }