AssignmentText = " = std::move(*";
TrailingText = ")";
NeedsUtilityInclude = true;
- } else if (!Right->isRValue()) {
+ } else if (!Right->isPRValue()) {
AssignmentText = " = std::move(";
TrailingText = ")";
NeedsUtilityInclude = true;
/// by reference.
static bool usagesReturnRValues(const UsageResult &Usages) {
for (const auto &U : Usages) {
- if (U.Expression && !U.Expression->isRValue())
+ if (U.Expression && !U.Expression->isPRValue())
return false;
}
return true;
/// C++11 divides the concept of "r-value" into pure r-values
/// ("pr-values") and so-called expiring values ("x-values"), which
/// identify specific objects that can be safely cannibalized for
- /// their resources. This is an unfortunate abuse of terminology on
- /// the part of the C++ committee. In Clang, when we say "r-value",
- /// we generally mean a pr-value.
+ /// their resources.
bool isLValue() const { return getValueKind() == VK_LValue; }
- bool isRValue() const { return getValueKind() == VK_RValue; }
+ bool isPRValue() const { return getValueKind() == VK_PRValue; }
bool isXValue() const { return getValueKind() == VK_XValue; }
- bool isGLValue() const { return getValueKind() != VK_RValue; }
+ bool isGLValue() const { return getValueKind() != VK_PRValue; }
enum LValueClassification {
LV_Valid,
? VK_LValue
: (RT->getPointeeType()->isFunctionType()
? VK_LValue : VK_XValue));
- return VK_RValue;
+ return VK_PRValue;
}
/// getValueKind - The value kind that this expression produces.
// type should be IntTy
CharacterLiteral(unsigned value, CharacterKind kind, QualType type,
SourceLocation l)
- : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary), Value(value),
- Loc(l) {
+ : Expr(CharacterLiteralClass, type, VK_PRValue, OK_Ordinary),
+ Value(value), Loc(l) {
CharacterLiteralBits.Kind = kind;
setDependence(ExprDependence::None);
}
Stmt *Val;
public:
ImaginaryLiteral(Expr *val, QualType Ty)
- : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary), Val(val) {
+ : Expr(ImaginaryLiteralClass, Ty, VK_PRValue, OK_Ordinary), Val(val) {
setDependence(ExprDependence::None);
}
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo,
QualType resultType, SourceLocation op,
SourceLocation rp)
- : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary),
+ : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue,
+ OK_Ordinary),
OpLoc(op), RParenLoc(rp) {
assert(ExprKind <= UETT_Last && "invalid enum value!");
UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
public:
AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L,
QualType t)
- : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary), AmpAmpLoc(AALoc),
+ : Expr(AddrLabelExprClass, t, VK_PRValue, OK_Ordinary), AmpAmpLoc(AALoc),
LabelLoc(LLoc), Label(L) {
setDependence(ExprDependence::None);
}
public:
StmtExpr(CompoundStmt *SubStmt, QualType T, SourceLocation LParenLoc,
SourceLocation RParenLoc, unsigned TemplateDepth)
- : Expr(StmtExprClass, T, VK_RValue, OK_Ordinary), SubStmt(SubStmt),
+ : Expr(StmtExprClass, T, VK_PRValue, OK_Ordinary), SubStmt(SubStmt),
LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
setDependence(computeDependence(this, TemplateDepth));
// FIXME: A templated statement expression should have an associated
public:
GNUNullExpr(QualType Ty, SourceLocation Loc)
- : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary), TokenLoc(Loc) {
+ : Expr(GNUNullExprClass, Ty, VK_PRValue, OK_Ordinary), TokenLoc(Loc) {
setDependence(ExprDependence::None);
}
public:
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
SourceLocation RPLoc, QualType t, bool IsMS)
- : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary), Val(e),
+ : Expr(VAArgExprClass, t, VK_PRValue, OK_Ordinary), Val(e),
TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {
setDependence(computeDependence(this));
}
class NoInitExpr : public Expr {
public:
explicit NoInitExpr(QualType ty)
- : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary) {
+ : Expr(NoInitExprClass, ty, VK_PRValue, OK_Ordinary) {
setDependence(computeDependence(this));
}
public:
explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
- : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary),
+ : Expr(ArrayInitLoopExprClass, T, VK_PRValue, OK_Ordinary),
SubExprs{CommonInit, ElementInit} {
setDependence(computeDependence(this));
}
public:
explicit ArrayInitIndexExpr(QualType T)
- : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary) {
+ : Expr(ArrayInitIndexExprClass, T, VK_PRValue, OK_Ordinary) {
setDependence(ExprDependence::None);
}
class ImplicitValueInitExpr : public Expr {
public:
explicit ImplicitValueInitExpr(QualType ty)
- : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary) {
+ : Expr(ImplicitValueInitExprClass, ty, VK_PRValue, OK_Ordinary) {
setDependence(computeDependence(this));
}
ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
IdentifierInfo &accessor, SourceLocation loc)
: Expr(ExtVectorElementExprClass, ty, VK,
- (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent)),
+ (VK == VK_PRValue ? OK_Ordinary : OK_VectorComponent)),
Base(base), Accessor(&accessor), AccessorLoc(loc) {
setDependence(computeDependence(this));
}
BlockDecl *TheBlock;
public:
BlockExpr(BlockDecl *BD, QualType ty)
- : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary), TheBlock(BD) {
+ : Expr(BlockExprClass, ty, VK_PRValue, OK_Ordinary), TheBlock(BD) {
setDependence(computeDependence(this));
}
class CXXBoolLiteralExpr : public Expr {
public:
CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)
- : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary) {
+ : Expr(CXXBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
CXXBoolLiteralExprBits.Value = Val;
CXXBoolLiteralExprBits.Loc = Loc;
setDependence(ExprDependence::None);
class CXXNullPtrLiteralExpr : public Expr {
public:
CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
- : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary) {
+ : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
CXXNullPtrLiteralExprBits.Loc = Loc;
setDependence(ExprDependence::None);
}
friend class ASTStmtReader;
CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
- : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(CXXStdInitializerListExprClass, Ty, VK_PRValue, OK_Ordinary),
SubExpr(SubExpr) {
setDependence(computeDependence(this));
}
class CXXThisExpr : public Expr {
public:
CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit)
- : Expr(CXXThisExprClass, Ty, VK_RValue, OK_Ordinary) {
+ : Expr(CXXThisExprClass, Ty, VK_PRValue, OK_Ordinary) {
CXXThisExprBits.IsImplicit = IsImplicit;
CXXThisExprBits.Loc = L;
setDependence(computeDependence(this));
// null if not present.
CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc,
bool IsThrownVariableInScope)
- : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary), Operand(Operand) {
+ : Expr(CXXThrowExprClass, Ty, VK_PRValue, OK_Ordinary), Operand(Operand) {
CXXThrowExprBits.ThrowLoc = Loc;
CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope;
setDependence(computeDependence(this));
Stmt *SubExpr = nullptr;
CXXBindTemporaryExpr(CXXTemporary *temp, Expr *SubExpr)
- : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_RValue,
+ : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_PRValue,
OK_Ordinary),
Temp(temp), SubExpr(SubExpr) {
setDependence(computeDependence(this));
CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T,
CXXConstructorDecl *Ctor, bool ConstructsVirtualBase,
bool InheritedFromVirtualBase)
- : Expr(CXXInheritedCtorInitExprClass, T, VK_RValue, OK_Ordinary),
+ : Expr(CXXInheritedCtorInitExprClass, T, VK_PRValue, OK_Ordinary),
Constructor(Ctor), Loc(Loc),
ConstructsVirtualBase(ConstructsVirtualBase),
InheritedFromVirtualBase(InheritedFromVirtualBase) {
/// expression.
CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
SourceLocation RParenLoc)
- : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary),
+ : Expr(CXXScalarValueInitExprClass, Type, VK_PRValue, OK_Ordinary),
TypeInfo(TypeInfo) {
CXXScalarValueInitExprBits.RParenLoc = RParenLoc;
setDependence(computeDependence(this));
CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm,
bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize,
FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)
- : Expr(CXXDeleteExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(CXXDeleteExprClass, Ty, VK_PRValue, OK_Ordinary),
OperatorDelete(OperatorDelete), Argument(Arg) {
CXXDeleteExprBits.GlobalDelete = GlobalDelete;
CXXDeleteExprBits.ArrayForm = ArrayForm;
ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
TypeSourceInfo *queried, uint64_t value, Expr *dimension,
SourceLocation rparen, QualType ty)
- : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary), ATT(att),
+ : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att),
Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
QueriedType(queried) {
assert(att <= ATT_Last && "invalid enum value!");
ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried,
bool value, SourceLocation rparen, QualType resultType)
- : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary),
+ : Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
ET(et), Value(value), Loc(loc), RParen(rparen),
QueriedExpression(queried) {
assert(et <= ET_Last && "invalid enum value!");
public:
CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
SourceLocation Keyword, SourceLocation RParen)
- : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(CXXNoexceptExprClass, Ty, VK_PRValue, OK_Ordinary),
Operand(Operand), Range(Keyword, RParen) {
CXXNoexceptExprBits.Value = Val == CT_Cannot;
setDependence(computeDependence(this, Val));
SourceLocation PackLoc, SourceLocation RParenLoc,
Optional<unsigned> Length,
ArrayRef<TemplateArgument> PartialArgs)
- : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary),
+ : Expr(SizeOfPackExprClass, SizeType, VK_PRValue, OK_Ordinary),
OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
assert((!Length || PartialArgs.empty()) &&
SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode,
SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc,
Optional<unsigned> NumExpansions)
- : Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary), LParenLoc(LParenLoc),
- EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
+ : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary),
+ LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
SubExprs[SubExpr::Callee] = Callee;
SubExprs[SubExpr::LHS] = LHS;
CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty,
Expr *Common)
- : Expr(SC, Ty, VK_RValue, OK_Ordinary), KeywordLoc(KeywordLoc) {
+ : Expr(SC, Ty, VK_PRValue, OK_Ordinary), KeywordLoc(KeywordLoc) {
assert(Common->isTypeDependent() && Ty->isDependentType() &&
"wrong constructor for non-dependent co_await/co_yield expression");
SubExprs[SubExpr::Common] = Common;
public:
DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op,
UnresolvedLookupExpr *OpCoawait)
- : Expr(DependentCoawaitExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(DependentCoawaitExprClass, Ty, VK_PRValue, OK_Ordinary),
KeywordLoc(KeywordLoc) {
// NOTE: A co_await expression is dependent on the coroutines promise
// type and may be dependent even when the `Op` expression is not.
public:
ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
- : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary), String(SL),
+ : Expr(ObjCStringLiteralClass, T, VK_PRValue, OK_Ordinary), String(SL),
AtLoc(L) {
setDependence(ExprDependence::None);
}
public:
ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
- : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary), Value(val),
+ : Expr(ObjCBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary), Value(val),
Loc(l) {
setDependence(ExprDependence::None);
}
friend class ASTStmtReader;
ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R)
- : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary), SubExpr(E),
+ : Expr(ObjCBoxedExprClass, T, VK_PRValue, OK_Ordinary), SubExpr(E),
BoxingMethod(method), Range(R) {
setDependence(computeDependence(this));
}
public:
ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at,
SourceLocation rp)
- : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary),
+ : Expr(ObjCSelectorExprClass, T, VK_PRValue, OK_Ordinary),
SelName(selInfo), AtLoc(at), RParenLoc(rp) {
setDependence(ExprDependence::None);
}
ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at,
SourceLocation protoLoc, SourceLocation rp)
- : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary),
+ : Expr(ObjCProtocolExprClass, T, VK_PRValue, OK_Ordinary),
TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {
setDependence(ExprDependence::None);
}
ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind,
CastKind CK, SourceLocation BridgeKeywordLoc,
TypeSourceInfo *TSInfo, Expr *Operand)
- : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(), VK_RValue,
- CK, Operand, 0, false, TSInfo),
+ : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(),
+ VK_PRValue, CK, Operand, 0, false, TSInfo),
LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc), Kind(Kind) {}
/// Construct an empty Objective-C bridged cast.
public:
ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc,
SourceLocation RParen, QualType Ty)
- : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_PRValue, OK_Ordinary),
VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {
setDependence(ExprDependence::None);
}
/// The categorization of expression values, currently following the
/// C++11 scheme.
enum ExprValueKind {
- /// An r-value expression (a pr-value in the C++11 taxonomy)
+ /// A pr-value expression (in the C++11 taxonomy)
/// produces a temporary value.
- VK_RValue,
+ VK_PRValue,
/// An l-value expression is a reference to an object with
/// independent storage.
/// function or via a constructor.
SK_UserConversion,
- /// Perform a qualification conversion, producing an rvalue.
- SK_QualificationConversionRValue,
+ /// Perform a qualification conversion, producing a prvalue.
+ SK_QualificationConversionPRValue,
/// Perform a qualification conversion, producing an xvalue.
SK_QualificationConversionXValue,
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
/// cast. If there is already an implicit cast, merge into the existing one.
/// If isLvalue, the result of the cast is an lvalue.
- ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
- ExprValueKind VK = VK_RValue,
- const CXXCastPath *BasePath = nullptr,
- CheckedConversionKind CCK
- = CCK_ImplicitConversion);
+ ExprResult
+ ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
+ ExprValueKind VK = VK_PRValue,
+ const CXXCastPath *BasePath = nullptr,
+ CheckedConversionKind CCK = CCK_ImplicitConversion);
/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
/// to the conversion from scalar type ScalarTy to the Boolean type.
CheckedConversionKind CCK);
ExprResult PerformQualificationConversion(
- Expr *E, QualType Ty, ExprValueKind VK = VK_RValue,
+ Expr *E, QualType Ty, ExprValueKind VK = VK_PRValue,
CheckedConversionKind CCK = CCK_ImplicitConversion);
/// the following "Check" methods will return a valid/converted QualType
// If the base expression (after skipping derived-to-base conversions) is a
// class prvalue, then we can devirtualize.
Base = Base->getBestDynamicClassTypeExpr();
- if (Base->isRValue() && Base->getType()->isRecordType())
+ if (Base->isPRValue() && Base->getType()->isRecordType())
return this;
// If we don't even know what we would call, we can't devirtualize.
}
} else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
if (BO->getOpcode() == BO_PtrMemD) {
- assert(BO->getRHS()->isRValue());
+ assert(BO->getRHS()->isPRValue());
E = BO->getLHS();
const MemberPointerType *MPT =
BO->getRHS()->getType()->getAs<MemberPointerType>();
SourceLocation RParen,
QualType ResultTy,
TypeSourceInfo *TSI)
- : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_RValue, OK_Ordinary),
+ : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_PRValue, OK_Ordinary),
OpLoc(OpLoc), LParen(LParen), RParen(RParen) {
setTypeSourceInfo(TSI);
setDependence(computeDependence(this));
SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,
QualType ResultTy)
- : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_RValue, OK_Ordinary) {}
+ : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_PRValue, OK_Ordinary) {}
SYCLUniqueStableNameExpr *
SYCLUniqueStableNameExpr::Create(const ASTContext &Ctx, SourceLocation OpLoc,
IntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V,
QualType type, SourceLocation l)
- : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary), Loc(l) {
+ : Expr(IntegerLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l) {
assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
assert(V.getBitWidth() == C.getIntWidth(type) &&
"Integer type is not the correct size for constant.");
FixedPointLiteral::FixedPointLiteral(const ASTContext &C, const llvm::APInt &V,
QualType type, SourceLocation l,
unsigned Scale)
- : Expr(FixedPointLiteralClass, type, VK_RValue, OK_Ordinary), Loc(l),
+ : Expr(FixedPointLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l),
Scale(Scale) {
assert(type->isFixedPointType() && "Illegal type in FixedPointLiteral");
assert(V.getBitWidth() == C.getTypeInfo(type).Width &&
FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
bool isexact, QualType Type, SourceLocation L)
- : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary), Loc(L) {
+ : Expr(FloatingLiteralClass, Type, VK_PRValue, OK_Ordinary), Loc(L) {
setSemantics(V.getSemantics());
FloatingLiteralBits.IsExact = isexact;
setValue(C, V);
SourceLocation OperatorLoc, TypeSourceInfo *tsi,
ArrayRef<OffsetOfNode> comps, ArrayRef<Expr *> exprs,
SourceLocation RParenLoc)
- : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary),
+ : Expr(OffsetOfExprClass, type, VK_PRValue, OK_Ordinary),
OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
NumComps(comps.size()), NumExprs(exprs.size()) {
for (unsigned i = 0; i != comps.size(); ++i)
UnaryExprOrTypeTraitExpr::UnaryExprOrTypeTraitExpr(
UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType,
SourceLocation op, SourceLocation rp)
- : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary),
+ : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
OpLoc(op), RParenLoc(rp) {
assert(ExprKind <= UETT_Last && "invalid enum value!");
UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
auto Ty = getType();
auto SETy = getSubExpr()->getType();
assert(getValueKindForType(Ty) == Expr::getValueKindForType(SETy));
- if (isRValue() && !Ty->isDependentType() && !SETy->isDependentType()) {
+ if (isPRValue() && !Ty->isDependentType() && !SETy->isDependentType()) {
Ty = Ty->getPointeeType();
SETy = SETy->getPointeeType();
}
SourceLocation BLoc, SourceLocation RParenLoc,
DeclContext *ParentContext)
: Expr(SourceLocExprClass, getDecayedSourceLocExprType(Ctx, Kind),
- VK_RValue, OK_Ordinary),
+ VK_PRValue, OK_Ordinary),
BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
SourceLocExprBits.Kind = Kind;
setDependence(ExprDependence::None);
InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
ArrayRef<Expr *> initExprs, SourceLocation rbraceloc)
- : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary),
+ : Expr(InitListExprClass, QualType(), VK_PRValue, OK_Ordinary),
InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc),
RBraceLoc(rbraceloc), AltForm(nullptr, true) {
sawArrayRangeDesignator(false);
// Don't confuse aggregate initialization of a struct X { X &x; }; with a
// transparent struct copy.
- if (!getInit(0)->isRValue() && getType()->isRecordType())
+ if (!getInit(0)->isPRValue() && getType()->isRecordType())
return false;
return getType().getCanonicalType() ==
while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
if (ICE->getCastKind() == CK_LValueToRValue ||
- (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
+ (ICE->getValueKind() != VK_PRValue && ICE->getCastKind() == CK_NoOp))
E = ICE->getSubExpr()->IgnoreParens();
else
break;
const Expr *E = this->IgnoreParens();
while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
- if (ICE->getValueKind() != VK_RValue &&
- ICE->getCastKind() == CK_NoOp)
+ if (ICE->getValueKind() != VK_PRValue && ICE->getCastKind() == CK_NoOp)
E = ICE->getSubExpr()->IgnoreParens();
else
break;
// template parameters.
const auto *DRE1 = cast<DeclRefExpr>(E1);
const auto *DRE2 = cast<DeclRefExpr>(E2);
- return DRE1->isRValue() && DRE2->isRValue() &&
+ return DRE1->isPRValue() && DRE2->isPRValue() &&
DRE1->getDecl() == DRE2->getDecl();
}
case ImplicitCastExprClass: {
ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr *> args,
QualType Type, SourceLocation BLoc,
SourceLocation RP)
- : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary),
+ : Expr(ShuffleVectorExprClass, Type, VK_PRValue, OK_Ordinary),
BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
SubExprs = new (C) Stmt*[args.size()];
for (unsigned i = 0; i != args.size(); i++)
ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack)
- : Expr(GenericSelectionExprClass, Context.DependentTy, VK_RValue,
+ : Expr(GenericSelectionExprClass, Context.DependentTy, VK_PRValue,
OK_Ordinary),
NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
SourceLocation lBraceLoc,
Expr *baseExpr,
SourceLocation rBraceLoc)
- : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_RValue,
+ : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_PRValue,
OK_Ordinary) {
BaseAndUpdaterExprs[0] = baseExpr;
ParenListExpr::ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
SourceLocation RParenLoc)
- : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary),
+ : Expr(ParenListExprClass, QualType(), VK_PRValue, OK_Ordinary),
LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
ParenListExprBits.NumExprs = Exprs.size();
ExprValueKind VK;
if (resultIndex == NoResult) {
type = C.VoidTy;
- VK = VK_RValue;
+ VK = VK_PRValue;
} else {
assert(resultIndex < semantics.size());
type = semantics[resultIndex]->getType();
AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr *> args, QualType t,
AtomicOp op, SourceLocation RP)
- : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary),
+ : Expr(AtomicExprClass, t, VK_PRValue, OK_Ordinary),
NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
for (unsigned i = 0; i != args.size(); i++)
Expr *Initializer, QualType Ty,
TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
SourceRange DirectInitRange)
- : Expr(CXXNewExprClass, Ty, VK_RValue, OK_Ordinary),
+ : Expr(CXXNewExprClass, Ty, VK_PRValue, OK_Ordinary),
OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),
AllocatedTypeInfo(AllocatedTypeInfo), Range(Range),
DirectInitRange(DirectInitRange) {
SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,
SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
- : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_RValue,
+ : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_PRValue,
OK_Ordinary),
Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
SourceLocation Loc, FieldDecl *Field,
QualType Ty, DeclContext *UsedContext)
: Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
- Ty->isLValueReferenceType()
- ? VK_LValue
- : Ty->isRValueReferenceType() ? VK_XValue : VK_RValue,
+ Ty->isLValueReferenceType() ? VK_LValue
+ : Ty->isRValueReferenceType() ? VK_XValue
+ : VK_PRValue,
/*FIXME*/ OK_Ordinary),
Field(Field), UsedContext(UsedContext) {
CXXDefaultInitExprBits.Loc = Loc;
bool ListInitialization, bool StdInitListInitialization,
bool ZeroInitialization, ConstructionKind ConstructKind,
SourceRange ParenOrBraceRange)
- : Expr(SC, Ty, VK_RValue, OK_Ordinary), Constructor(Ctor),
+ : Expr(SC, Ty, VK_PRValue, OK_Ordinary), Constructor(Ctor),
ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
CXXConstructExprBits.Elidable = Elidable;
CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates;
bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
SourceLocation ClosingBrace,
bool ContainsUnexpandedParameterPack)
- : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary),
+ : Expr(LambdaExprClass, T, VK_PRValue, OK_Ordinary),
IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
ClosingBrace(ClosingBrace) {
LambdaExprBits.NumCaptures = CaptureInits.size();
ArrayRef<Expr *> Args,
SourceLocation RParenLoc)
: Expr(CXXUnresolvedConstructExprClass, T,
- (TSI->getType()->isLValueReferenceType()
- ? VK_LValue
- : TSI->getType()->isRValueReferenceType() ? VK_XValue
- : VK_RValue),
+ (TSI->getType()->isLValueReferenceType() ? VK_LValue
+ : TSI->getType()->isRValueReferenceType() ? VK_XValue
+ : VK_PRValue),
OK_Ordinary),
TSI(TSI), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
CXXUnresolvedConstructExprBits.NumArgs = Args.size();
TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
ArrayRef<TypeSourceInfo *> Args,
SourceLocation RParenLoc, bool Value)
- : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary), Loc(Loc),
+ : Expr(TypeTraitExprClass, T, VK_PRValue, OK_Ordinary), Loc(Loc),
RParenLoc(RParenLoc) {
assert(Kind <= TT_Last && "invalid enum value!");
TypeTraitExprBits.Kind = Kind;
case Cl::CL_ClassTemporary:
case Cl::CL_ArrayTemporary:
case Cl::CL_ObjCMessageRValue:
- case Cl::CL_PRValue: assert(getValueKind() == VK_RValue); break;
+ case Cl::CL_PRValue:
+ assert(getValueKind() == VK_PRValue);
+ break;
}
Cl::ModifiableType modifiable = Cl::CM_Untested;
const Expr *E,
ExprValueKind Kind) {
switch (Kind) {
- case VK_RValue:
+ case VK_PRValue:
return Lang.CPlusPlus ? ClassifyTemporary(E->getType()) : Cl::CL_PRValue;
case VK_LValue:
return Cl::CL_LValue;
// contains only one element. In that case, we look at that element
// for an exact classification. Init list creation takes care of the
// value kind for us, so we only need to fine-tune.
- if (E->isRValue())
+ if (E->isPRValue())
return ClassifyExprValueKind(Lang, E, E->getValueKind());
assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
"Only 1-element init lists can be glvalues.");
const ASTTemplateArgumentListInfo *ArgsAsWritten,
ArrayRef<TemplateArgument> ConvertedArgs,
const ConstraintSatisfaction *Satisfaction)
- : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary),
+ : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl,
NamedConcept, ArgsAsWritten),
NumTemplateArgs(ConvertedArgs.size()),
ArrayRef<TemplateArgument> ConvertedArgs,
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack)
- : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary),
+ : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
ConceptReference(NestedNameSpecifierLoc(), SourceLocation(),
DeclarationNameInfo(), NamedConcept, NamedConcept,
nullptr),
ArrayRef<ParmVarDecl *> LocalParameters,
ArrayRef<concepts::Requirement *> Requirements,
SourceLocation RBraceLoc)
- : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary),
+ : Expr(RequiresExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
NumLocalParameters(LocalParameters.size()),
NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) {
RequiresExprBits.IsSatisfied = false;
/// Given an expression, determine the type used to store the result of
/// evaluating that expression.
static QualType getStorageType(const ASTContext &Ctx, const Expr *E) {
- if (E->isRValue())
+ if (E->isPRValue())
return E->getType();
return Ctx.getLValueReferenceType(E->getType());
}
/// produce an appropriate diagnostic.
static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
const LValue *This = nullptr) {
- if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
+ if (!E->isPRValue() || E->getType()->isLiteralType(Info.Ctx))
return true;
// C++1y: A constant initializer for an object o [...] may also invoke
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
+ assert(E->isPRValue() && "missing lvalue-to-rvalue conv in bool condition");
APValue Val;
if (!Evaluate(Val, Info, E))
return false;
/// Build an lvalue for the object argument of a member function call.
static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
LValue &This) {
- if (Object->getType()->isPointerType() && Object->isRValue())
+ if (Object->getType()->isPointerType() && Object->isPRValue())
return EvaluatePointer(Object, This, Info);
if (Object->isGLValue())
// Invent an expression for location purposes.
// FIXME: We shouldn't need to do this.
- OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_RValue);
+ OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_PRValue);
// For arrays, destroy elements right-to-left.
if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(T)) {
if (E->isArrow()) {
EvalOK = evaluatePointer(E->getBase(), Result);
BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
- } else if (E->getBase()->isRValue()) {
+ } else if (E->getBase()->isPRValue()) {
assert(E->getBase()->getType()->isRecordType());
EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
BaseTy = E->getBase()->getType();
static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
bool InvalidBaseOK) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->hasPointerRepresentation());
+ assert(E->isPRValue() && E->getType()->hasPointerRepresentation());
return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
}
static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isMemberPointerType());
+ assert(E->isPRValue() && E->getType()->isMemberPointerType());
return MemberPointerExprEvaluator(Info, Result).Visit(E);
}
static bool EvaluateRecord(const Expr *E, const LValue &This,
APValue &Result, EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isRecordType() &&
+ assert(E->isPRValue() && E->getType()->isRecordType() &&
"can't evaluate expression as a record rvalue");
return RecordExprEvaluator(Info, This, Result).Visit(E);
}
/// Evaluate an expression of record type as a temporary.
static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isRecordType());
+ assert(E->isPRValue() && E->getType()->isRecordType());
return TemporaryExprEvaluator(Info, Result).Visit(E);
}
} // end anonymous namespace
static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
- assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue");
+ assert(E->isPRValue() && E->getType()->isVectorType() &&
+ "not a vector prvalue");
return VectorExprEvaluator(Info, Result).Visit(E);
}
static bool EvaluateArray(const Expr *E, const LValue &This,
APValue &Result, EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
+ assert(E->isPRValue() && E->getType()->isArrayType() &&
+ "not an array prvalue");
return ArrayExprEvaluator(Info, This, Result).Visit(E);
}
APValue &Result, const InitListExpr *ILE,
QualType AllocType) {
assert(!ILE->isValueDependent());
- assert(ILE->isRValue() && ILE->getType()->isArrayType() &&
- "not an array rvalue");
+ assert(ILE->isPRValue() && ILE->getType()->isArrayType() &&
+ "not an array prvalue");
return ArrayExprEvaluator(Info, This, Result)
.VisitInitListExpr(ILE, AllocType);
}
const CXXConstructExpr *CCE,
QualType AllocType) {
assert(!CCE->isValueDependent());
- assert(CCE->isRValue() && CCE->getType()->isArrayType() &&
- "not an array rvalue");
+ assert(CCE->isPRValue() && CCE->getType()->isArrayType() &&
+ "not an array prvalue");
return ArrayExprEvaluator(Info, This, Result)
.VisitCXXConstructExpr(CCE, This, &Result, AllocType);
}
static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
+ assert(E->isPRValue() && E->getType()->isIntegralOrEnumerationType());
return IntExprEvaluator(Info, Result).Visit(E);
}
///
/// Always returns an RValue with a pointer representation.
static const Expr *ignorePointerCastsAndParens(const Expr *E) {
- assert(E->isRValue() && E->getType()->hasPointerRepresentation());
+ assert(E->isPRValue() && E->getType()->hasPointerRepresentation());
auto *NoParens = E->IgnoreParens();
auto *Cast = dyn_cast<CastExpr>(NoParens);
return NoParens;
auto *SubExpr = Cast->getSubExpr();
- if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
+ if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isPRValue())
return NoParens;
return ignorePointerCastsAndParens(SubExpr);
}
/// with integral or enumeration type.
static bool shouldEnqueue(const BinaryOperator *E) {
return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
- (E->isRValue() && E->getType()->isIntegralOrEnumerationType() &&
+ (E->isPRValue() && E->getType()->isIntegralOrEnumerationType() &&
E->getLHS()->getType()->isIntegralOrEnumerationType() &&
E->getRHS()->getType()->isIntegralOrEnumerationType());
}
static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isRealFloatingType());
+ assert(E->isPRValue() && E->getType()->isRealFloatingType());
return FloatExprEvaluator(Info, Result).Visit(E);
}
static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isAnyComplexType());
+ assert(E->isPRValue() && E->getType()->isAnyComplexType());
return ComplexExprEvaluator(Info, Result).Visit(E);
}
static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isAtomicType());
+ assert(E->isPRValue() && E->getType()->isAtomicType());
return AtomicExprEvaluator(Info, This, Result).Visit(E);
}
static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
assert(!E->isValueDependent());
- assert(E->isRValue() && E->getType()->isVoidType());
+ assert(E->isPRValue() && E->getType()->isVoidType());
return VoidExprEvaluator(Info).Visit(E);
}
if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
return false;
- if (E->isRValue()) {
+ if (E->isPRValue()) {
// Evaluate arrays and record types in-place, so that later initializers can
// refer to earlier-initialized members of the object.
QualType T = E->getType();
// FIXME: Evaluating values of large array and record types can cause
// performance problems. Only do so in C++11 for now.
- if (Exp->isRValue() && (Exp->getType()->isArrayType() ||
- Exp->getType()->isRecordType()) &&
+ if (Exp->isPRValue() &&
+ (Exp->getType()->isArrayType() || Exp->getType()->isRecordType()) &&
!Ctx.getLangOpts().CPlusPlus11) {
IsConst = false;
return true;
// FIXME: Evaluating initializers for large array and record types can cause
// performance problems. Only do so in C++11 for now.
- if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
+ if (isPRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
!Ctx.getLangOpts().CPlusPlus11)
return false;
// form "T x = { a };" is equivalent to "T x = a;".
// Unless we're initializing a reference, T is a scalar as it is known to be
// of integral or enumeration type.
- if (E->isRValue())
+ if (E->isPRValue())
if (cast<InitListExpr>(E)->getNumInits() == 1)
return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
return ICEDiag(IK_NotICE, E->getBeginLoc());
ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, QualType T,
ObjCMethodDecl *Method, SourceRange SR)
- : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary),
+ : Expr(ObjCArrayLiteralClass, T, VK_PRValue, OK_Ordinary),
NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) {
Expr **SaveElements = getElements();
for (unsigned I = 0, N = Elements.size(); I != N; ++I)
bool HasPackExpansions, QualType T,
ObjCMethodDecl *method,
SourceRange SR)
- : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary),
+ : Expr(ObjCDictionaryLiteralClass, T, VK_PRValue, OK_Ordinary),
NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
DictWithObjectsMethod(method) {
KeyValuePair *KeyValues = getTrailingObjects<KeyValuePair>();
return Ctx.getLValueReferenceType(QT);
case VK_XValue:
return Ctx.getRValueReferenceType(QT);
- case VK_RValue:
+ case VK_PRValue:
return QT;
}
llvm_unreachable("Unsupported ExprValueKind");
switch (E->getValueKind()) {
case VK_LValue: Category = "lvalue"; break;
case VK_XValue: Category = "xvalue"; break;
- case VK_RValue: Category = "rvalue"; break;
+ case VK_PRValue:
+ Category = "prvalue";
+ break;
}
JOS.attribute("valueCategory", Category);
}
{
ColorScope Color(OS, ShowColors, ValueKindColor);
switch (E->getValueKind()) {
- case VK_RValue:
+ case VK_PRValue:
break;
case VK_LValue:
OS << " lvalue";
QualType Ty) {
return BinaryOperator::Create(
C, const_cast<Expr *>(LHS), const_cast<Expr *>(RHS), BO_Assign, Ty,
- VK_RValue, OK_Ordinary, SourceLocation(), FPOptionsOverride());
+ VK_PRValue, OK_Ordinary, SourceLocation(), FPOptionsOverride());
}
BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
BinaryOperator::isComparisonOp(Op));
return BinaryOperator::Create(
C, const_cast<Expr *>(LHS), const_cast<Expr *>(RHS), Op,
- C.getLogicalOperationType(), VK_RValue, OK_Ordinary, SourceLocation(),
+ C.getLogicalOperationType(), VK_PRValue, OK_Ordinary, SourceLocation(),
FPOptionsOverride());
}
/* CastKind=*/CK,
/* Expr=*/const_cast<Expr *>(Arg),
/* CXXCastPath=*/nullptr,
- /* ExprValueKind=*/VK_RValue,
+ /* ExprValueKind=*/VK_PRValue,
/* FPFeatures */ FPOptionsOverride());
}
llvm_unreachable("Unexpected state");
}
- return CallExpr::Create(C, SubExpr, CallArgs, C.VoidTy, VK_RValue,
+ return CallExpr::Create(C, SubExpr, CallArgs, C.VoidTy, VK_PRValue,
SourceLocation(), FPOptionsOverride());
}
/*AstContext=*/C, OO_Call, callOperatorDeclRef,
/*Args=*/CallArgs,
/*QualType=*/C.VoidTy,
- /*ExprValueType=*/VK_RValue,
+ /*ExprValueType=*/VK_PRValue,
/*SourceLocation=*/SourceLocation(),
/*FPFeatures=*/FPOptionsOverride());
}
CK_IntegralToBoolean),
/* opc=*/UO_LNot,
/* QualType=*/C.IntTy,
- /* ExprValueKind=*/VK_RValue,
+ /* ExprValueKind=*/VK_PRValue,
/* ExprObjectKind=*/OK_Ordinary, SourceLocation(),
/* CanOverflow*/ false, FPOptionsOverride());
/*StmtClass=*/M.makeLvalueToRvalue(/*Expr=*/Block),
/*Args=*/None,
/*QualType=*/C.VoidTy,
- /*ExprValueType=*/VK_RValue,
+ /*ExprValueType=*/VK_PRValue,
/*SourceLocation=*/SourceLocation(), FPOptionsOverride());
// (2) Create the assignment to the predicate.
Expr *DoneValue =
UnaryOperator::Create(C, M.makeIntegerLiteral(0, C.LongTy), UO_Not,
- C.LongTy, VK_RValue, OK_Ordinary, SourceLocation(),
+ C.LongTy, VK_PRValue, OK_Ordinary, SourceLocation(),
/*CanOverflow*/ false, FPOptionsOverride());
BinaryOperator *B =
ASTMaker M(C);
DeclRefExpr *DR = M.makeDeclRefExpr(PV);
ImplicitCastExpr *ICE = M.makeLvalueToRvalue(DR, Ty);
- CallExpr *CE = CallExpr::Create(C, ICE, None, C.VoidTy, VK_RValue,
+ CallExpr *CE = CallExpr::Create(C, ICE, None, C.VoidTy, VK_PRValue,
SourceLocation(), FPOptionsOverride());
return CE;
}
if (!CtorD || !CtorD->hasAttrs())
continue;
handleCall(E, CtorD, VD);
- } else if (isa<CallExpr>(E) && E->isRValue()) {
+ } else if (isa<CallExpr>(E) && E->isPRValue()) {
// If the object is initialized by a function call that returns a
// scoped lockable by value, use the attributes on the copy or move
// constructor to figure out what effect that should have on the
type, VK_LValue, SourceLocation());
ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue,
- &declRef, VK_RValue, FPOptionsOverride());
+ &declRef, VK_PRValue, FPOptionsOverride());
// FIXME: Pass a specific location for the expr init so that the store is
// attributed to a reasonable location - otherwise it may be attributed to
// locations of subexpressions in the initialization.
/// EmitIgnoredExpr - Emit code to compute the specified expression,
/// ignoring the result.
void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
- if (E->isRValue())
+ if (E->isPRValue())
return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
// Just emit it as an l-value and drop the result.
// directly into the slot.
typedef CodeGenFunction::OpaqueValueMappingData OVMA;
OVMA opaqueData;
- if (ov == resultExpr && ov->isRValue() && !forLValue &&
+ if (ov == resultExpr && ov->isPRValue() && !forLValue &&
CodeGenFunction::hasAggregateEvaluationKind(ov->getType())) {
CGF.EmitAggExpr(ov->getSourceExpr(), slot);
LValue LV = CGF.MakeAddrLValue(slot.getAddress(), ov->getType(),
if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
// And that glvalue casts are never null.
- if (ICE->getValueKind() != VK_RValue)
+ if (ICE->getValueKind() != VK_PRValue)
return false;
}
Expr *BaseExpr = E->getBase();
Address Addr = Address::invalid();
- if (BaseExpr->isRValue()) {
+ if (BaseExpr->isPRValue()) {
Addr = Address(EmitScalarExpr(BaseExpr), getPointerAlign());
} else {
Addr = EmitLValue(BaseExpr).getAddress(*this);
DeclRefExpr self(getContext(), selfDecl, false, selfDecl->getType(),
VK_LValue, SourceLocation());
ImplicitCastExpr selfLoad(ImplicitCastExpr::OnStack, selfDecl->getType(),
- CK_LValueToRValue, &self, VK_RValue,
+ CK_LValueToRValue, &self, VK_PRValue,
FPOptionsOverride());
ObjCIvarRefExpr ivarRef(ivar, ivar->getType().getNonReferenceType(),
SourceLocation(), SourceLocation(),
SourceLocation());
ImplicitCastExpr argLoad(ImplicitCastExpr::OnStack,
argType.getUnqualifiedType(), CK_LValueToRValue,
- &arg, VK_RValue, FPOptionsOverride());
+ &arg, VK_PRValue, FPOptionsOverride());
// The property type can differ from the ivar type in some situations with
// Objective-C pointer types, we can always bit cast the RHS in these cases.
argCK = CK_BitCast;
}
ImplicitCastExpr argCast(ImplicitCastExpr::OnStack, ivarRef.getType(), argCK,
- &argLoad, VK_RValue, FPOptionsOverride());
+ &argLoad, VK_PRValue, FPOptionsOverride());
Expr *finalArg = &argLoad;
if (!getContext().hasSameUnqualifiedType(ivarRef.getType(),
argLoad.getType()))
finalArg = &argCast;
BinaryOperator *assign = BinaryOperator::Create(
- getContext(), &ivarRef, finalArg, BO_Assign, ivarRef.getType(), VK_RValue,
- OK_Ordinary, SourceLocation(), FPOptionsOverride());
+ getContext(), &ivarRef, finalArg, BO_Assign, ivarRef.getType(),
+ VK_PRValue, OK_Ordinary, SourceLocation(), FPOptionsOverride());
EmitStmt(assign);
}
StartFunction(FD, ReturnTy, Fn, FI, args);
- DeclRefExpr DstExpr(C, &DstDecl, false, DestTy, VK_RValue, SourceLocation());
+ DeclRefExpr DstExpr(C, &DstDecl, false, DestTy, VK_PRValue, SourceLocation());
UnaryOperator *DST = UnaryOperator::Create(
C, &DstExpr, UO_Deref, DestTy->getPointeeType(), VK_LValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
- DeclRefExpr SrcExpr(C, &SrcDecl, false, SrcTy, VK_RValue, SourceLocation());
+ DeclRefExpr SrcExpr(C, &SrcDecl, false, SrcTy, VK_PRValue, SourceLocation());
UnaryOperator *SRC = UnaryOperator::Create(
C, &SrcExpr, UO_Deref, SrcTy->getPointeeType(), VK_LValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
StartFunction(FD, ReturnTy, Fn, FI, args);
- DeclRefExpr SrcExpr(getContext(), &SrcDecl, false, SrcTy, VK_RValue,
+ DeclRefExpr SrcExpr(getContext(), &SrcDecl, false, SrcTy, VK_PRValue,
SourceLocation());
UnaryOperator *SRC = UnaryOperator::Create(
CXXConstExpr->getConstructionKind(),
SourceRange());
- DeclRefExpr DstExpr(getContext(), &DstDecl, false, DestTy, VK_RValue,
+ DeclRefExpr DstExpr(getContext(), &DstDecl, false, DestTy, VK_PRValue,
SourceLocation());
RValue DV = EmitAnyExpr(&DstExpr);
return;
}
}
- OpaqueValueExpr OVE(DRD->getLocation(), Ty, VK_RValue);
+ OpaqueValueExpr OVE(DRD->getLocation(), Ty, VK_PRValue);
CodeGenFunction::OpaqueValueMapping OpaqueMap(CGF, &OVE, InitRVal);
CGF.EmitAnyExprToMem(&OVE, Private, Ty.getQualifiers(),
/*IsInitializer=*/false);
OpaqueValueExpr OVE(
Loc,
C.getIntTypeForBitwidth(C.getTypeSize(C.getSizeType()), /*Signed=*/0),
- VK_RValue);
+ VK_PRValue);
CodeGenFunction::OpaqueValueMapping OpaqueMap(CGF, &OVE,
RValue::get(NumOfElements));
KmpTaskAffinityInfoArrayTy =
}
OpaqueValueExpr OVE(Loc,
C.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0),
- VK_RValue);
+ VK_PRValue);
CodeGenFunction::OpaqueValueMapping OpaqueMap(CGF, &OVE,
RValue::get(NumOfElements));
KmpDependInfoArrayTy =
CodeGenFunction::OpaqueValueMapping OpaqueUB(CGF, &UBRefExpr, UB);
// Generate condition for loop.
BinaryOperator *Cond = BinaryOperator::Create(
- C, &IVRefExpr, &UBRefExpr, BO_LE, C.BoolTy, VK_RValue, OK_Ordinary,
+ C, &IVRefExpr, &UBRefExpr, BO_LE, C.BoolTy, VK_PRValue, OK_Ordinary,
S.getBeginLoc(), FPOptionsOverride());
// Increment for loop counter.
UnaryOperator *Inc = UnaryOperator::Create(
- C, &IVRefExpr, UO_PreInc, KmpInt32Ty, VK_RValue, OK_Ordinary,
+ C, &IVRefExpr, UO_PreInc, KmpInt32Ty, VK_PRValue, OK_Ordinary,
S.getBeginLoc(), true, FPOptionsOverride());
auto &&BodyGen = [CapturedStmt, CS, &S, &IV](CodeGenFunction &CGF) {
// Iterate through all sections and emit a switch construct:
PrivateVD->setInitStyle(VarDecl::CInit);
PrivateVD->setInit(ImplicitCastExpr::Create(C, ElemType, CK_LValueToRValue,
InitRef, /*BasePath=*/nullptr,
- VK_RValue, FPOptionsOverride()));
+ VK_PRValue, FPOptionsOverride()));
Data.FirstprivateVars.emplace_back(OrigRef);
Data.FirstprivateCopies.emplace_back(PrivateRef);
Data.FirstprivateInits.emplace_back(InitRef);
CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,
CastKind Kind, Expr *E) {
TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());
- return CStyleCastExpr::Create(*Ctx, Ty, VK_RValue, Kind, E, nullptr,
+ return CStyleCastExpr::Create(*Ctx, Ty, VK_PRValue, Kind, E, nullptr,
FPOptionsOverride(), TInfo,
SourceLocation(), SourceLocation());
}
QualType pToFunc = Context->getPointerType(msgSendType);
ImplicitCastExpr *ICE =
ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
- DRE, nullptr, VK_RValue, FPOptionsOverride());
+ DRE, nullptr, VK_PRValue, FPOptionsOverride());
const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *Exp =
CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
return Exp;
}
DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
Expr *Unop = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
- Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
// cast to NSConstantString *
CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
ReplaceStmt(Exp, CE);
return CE;
}
std::string NSArrayFName("__NSContainer_literal");
FunctionDecl *NSArrayFD = SynthBlockInitFunctionDecl(NSArrayFName);
DeclRefExpr *NSArrayDRE = new (Context) DeclRefExpr(
- *Context, NSArrayFD, false, NSArrayFType, VK_RValue, SourceLocation());
+ *Context, NSArrayFD, false, NSArrayFType, VK_PRValue, SourceLocation());
SmallVector<Expr*, 16> InitExprs;
unsigned NumElements = Exp->getNumElements();
const FunctionType *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
ReplaceStmt(Exp, CE);
return CE;
}
std::string NSDictFName("__NSContainer_literal");
FunctionDecl *NSDictFD = SynthBlockInitFunctionDecl(NSDictFName);
DeclRefExpr *NSDictDRE = new (Context) DeclRefExpr(
- *Context, NSDictFD, false, NSDictFType, VK_RValue, SourceLocation());
+ *Context, NSDictFD, false, NSDictFType, VK_PRValue, SourceLocation());
SmallVector<Expr*, 16> KeyExprs;
SmallVector<Expr*, 16> ValueExprs;
const FunctionType *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
ReplaceStmt(Exp, CE);
return CE;
}
FunctionDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
ID, FuncType, nullptr, SC_Extern, false, false);
DeclRefExpr *DRE = new (Context)
- DeclRefExpr(*Context, FD, false, castType, VK_RValue, SourceLocation());
+ DeclRefExpr(*Context, FD, false, castType, VK_PRValue, SourceLocation());
CallExpr *STCE =
CallExpr::Create(*Context, DRE, MsgExprs, castType, VK_LValue,
SourceLocation(), FPOptionsOverride());
SmallVector<Expr*, 4> InitExprs;
// set the receiver to self, the first argument to all methods.
- InitExprs.push_back(
- NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
- CK_BitCast,
- new (Context) DeclRefExpr(*Context,
- CurMethodDef->getSelfDecl(),
- false,
- Context->getObjCIdType(),
- VK_RValue,
- SourceLocation()))
- ); // set the 'receiver'.
+ InitExprs.push_back(NoTypeInfoCStyleCastExpr(
+ Context, Context->getObjCIdType(), CK_BitCast,
+ new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
+ Context->getObjCIdType(), VK_PRValue,
+ SourceLocation()))); // set the 'receiver'.
// (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
SmallVector<Expr*, 8> ClsExprs;
//
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
SuperRep = NoTypeInfoCStyleCastExpr(Context,
Context->getPointerType(superType),
// struct __rw_objc_super *
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
}
MsgExprs.push_back(SuperRep);
ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
SmallVector<Expr*, 4> InitExprs;
- InitExprs.push_back(
- NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
- CK_BitCast,
- new (Context) DeclRefExpr(*Context,
- CurMethodDef->getSelfDecl(),
- false,
- Context->getObjCIdType(),
- VK_RValue, SourceLocation()))
- ); // set the 'receiver'.
+ InitExprs.push_back(NoTypeInfoCStyleCastExpr(
+ Context, Context->getObjCIdType(), CK_BitCast,
+ new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
+ Context->getObjCIdType(), VK_PRValue,
+ SourceLocation()))); // set the 'receiver'.
// (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
SmallVector<Expr*, 8> ClsExprs;
//
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
SuperRep = NoTypeInfoCStyleCastExpr(Context,
Context->getPointerType(superType),
SourceLocation());
TypeSourceInfo *superTInfo
= Context->getTrivialTypeSourceInfo(superType);
- SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
- superType, VK_RValue, ILE,
- false);
+ SuperRep = new (Context) CompoundLiteralExpr(
+ SourceLocation(), superTInfo, superType, VK_PRValue, ILE, false);
}
MsgExprs.push_back(SuperRep);
break;
const FunctionType *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
Stmt *ReplacingStmt = CE;
if (MsgSendStretFlavor) {
// We have the method which returns a struct/union. Must also generate
Expr *RHSExp = CEXPR->getRHS();
Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
Expr *CONDExp = CEXPR->getCond();
- ConditionalOperator *CondExpr =
- new (Context) ConditionalOperator(CONDExp,
- SourceLocation(), cast<Expr>(LHSStmt),
- SourceLocation(), cast<Expr>(RHSStmt),
- Exp->getType(), VK_RValue, OK_Ordinary);
+ ConditionalOperator *CondExpr = new (Context) ConditionalOperator(
+ CONDExp, SourceLocation(), cast<Expr>(LHSStmt), SourceLocation(),
+ cast<Expr>(RHSStmt), Exp->getType(), VK_PRValue, OK_Ordinary);
return CondExpr;
} else if (const ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(BlockExp)) {
CPT = IRE->getType()->getAs<BlockPointerType>();
BlkExprs.push_back(*I);
}
CallExpr *CE =
- CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_RValue,
+ CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_PRValue,
SourceLocation(), FPOptionsOverride());
return CE;
}
FD = SynthBlockInitFunctionDecl(Tag);
DeclRefExpr *DRE = new (Context)
- DeclRefExpr(*Context, FD, false, FType, VK_RValue, SourceLocation());
+ DeclRefExpr(*Context, FD, false, FType, VK_PRValue, SourceLocation());
SmallVector<Expr*, 4> InitExprs;
const_cast<ASTContext &>(*Context),
new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy,
VK_LValue, SourceLocation()),
- UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_RValue,
+ UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_PRValue,
OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
InitExprs.push_back(DescRefExpr);
if (HasLocalVariableExternalStorage(*I)) {
QualType QT = (*I)->getType();
QT = Context->getPointerType(QT);
- Exp = UnaryOperator::Create(
- const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, QT, VK_RValue,
- OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
+ Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp,
+ UO_AddrOf, QT, VK_PRValue, OK_Ordinary,
+ SourceLocation(), false,
+ FPOptionsOverride());
}
} else if (isTopLevelBlockPointerType((*I)->getType())) {
FD = SynthBlockInitFunctionDecl((*I)->getName());
if (HasLocalVariableExternalStorage(*I)) {
QualType QT = (*I)->getType();
QT = Context->getPointerType(QT);
- Exp = UnaryOperator::Create(
- const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, QT, VK_RValue,
- OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
+ Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp,
+ UO_AddrOf, QT, VK_PRValue, OK_Ordinary,
+ SourceLocation(), false,
+ FPOptionsOverride());
}
}
if (!isNestedCapturedVar)
Exp = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), Exp, UO_AddrOf,
- Context->getPointerType(Exp->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(Exp->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp);
InitExprs.push_back(Exp);
NewRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), NewRep, UO_AddrOf,
- Context->getPointerType(NewRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(NewRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
NewRep);
VK_LValue, SourceLocation());
BinaryOperator *addExpr = BinaryOperator::Create(
*Context, castExpr, DRE, BO_Add,
- Context->getPointerType(Context->CharTy), VK_RValue, OK_Ordinary,
+ Context->getPointerType(Context->CharTy), VK_PRValue, OK_Ordinary,
SourceLocation(), FPOptionsOverride());
// Don't forget the parens to enforce the proper binding.
ParenExpr *PE = new (Context) ParenExpr(SourceLocation(),
CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,
CastKind Kind, Expr *E) {
TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());
- return CStyleCastExpr::Create(*Ctx, Ty, VK_RValue, Kind, E, nullptr,
+ return CStyleCastExpr::Create(*Ctx, Ty, VK_PRValue, Kind, E, nullptr,
FPOptionsOverride(), TInfo,
SourceLocation(), SourceLocation());
}
QualType pToFunc = Context->getPointerType(msgSendType);
ImplicitCastExpr *ICE =
ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
- DRE, nullptr, VK_RValue, FPOptionsOverride());
+ DRE, nullptr, VK_PRValue, FPOptionsOverride());
const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *Exp =
CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
return Exp;
}
DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
Expr *Unop = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
- Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
// cast to NSConstantString *
CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *STCE =
- CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue,
+ CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), VK_PRValue,
SourceLocation(), FPOptionsOverride());
return STCE;
}
SmallVector<Expr*, 4> InitExprs;
// set the receiver to self, the first argument to all methods.
- InitExprs.push_back(
- NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
- CK_BitCast,
- new (Context) DeclRefExpr(*Context,
- CurMethodDef->getSelfDecl(),
- false,
- Context->getObjCIdType(),
- VK_RValue,
- SourceLocation()))
- ); // set the 'receiver'.
+ InitExprs.push_back(NoTypeInfoCStyleCastExpr(
+ Context, Context->getObjCIdType(), CK_BitCast,
+ new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
+ Context->getObjCIdType(), VK_PRValue,
+ SourceLocation()))); // set the 'receiver'.
// (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
SmallVector<Expr*, 8> ClsExprs;
//
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
SuperRep = NoTypeInfoCStyleCastExpr(Context,
Context->getPointerType(superType),
// struct objc_super *
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
}
MsgExprs.push_back(SuperRep);
ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
SmallVector<Expr*, 4> InitExprs;
- InitExprs.push_back(
- NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
- CK_BitCast,
- new (Context) DeclRefExpr(*Context,
- CurMethodDef->getSelfDecl(),
- false,
- Context->getObjCIdType(),
- VK_RValue, SourceLocation()))
- ); // set the 'receiver'.
+ InitExprs.push_back(NoTypeInfoCStyleCastExpr(
+ Context, Context->getObjCIdType(), CK_BitCast,
+ new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
+ Context->getObjCIdType(), VK_PRValue,
+ SourceLocation()))); // set the 'receiver'.
// (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
SmallVector<Expr*, 8> ClsExprs;
//
SuperRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
- Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
SuperRep = NoTypeInfoCStyleCastExpr(Context,
Context->getPointerType(superType),
SourceLocation());
TypeSourceInfo *superTInfo
= Context->getTrivialTypeSourceInfo(superType);
- SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
- superType, VK_RValue, ILE,
- false);
+ SuperRep = new (Context) CompoundLiteralExpr(
+ SourceLocation(), superTInfo, superType, VK_PRValue, ILE, false);
}
MsgExprs.push_back(SuperRep);
break;
const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
- VK_RValue, EndLoc, FPOptionsOverride());
+ VK_PRValue, EndLoc, FPOptionsOverride());
Stmt *ReplacingStmt = CE;
if (MsgSendStretFlavor) {
// We have the method which returns a struct/union. Must also generate
Context->IntTy,
SourceLocation());
BinaryOperator *lessThanExpr = BinaryOperator::Create(
- *Context, sizeofExpr, limit, BO_LE, Context->IntTy, VK_RValue,
+ *Context, sizeofExpr, limit, BO_LE, Context->IntTy, VK_PRValue,
OK_Ordinary, SourceLocation(), FPOptionsOverride());
// (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
- ConditionalOperator *CondExpr =
- new (Context) ConditionalOperator(lessThanExpr,
- SourceLocation(), CE,
- SourceLocation(), STCE,
- returnType, VK_RValue, OK_Ordinary);
+ ConditionalOperator *CondExpr = new (Context) ConditionalOperator(
+ lessThanExpr, SourceLocation(), CE, SourceLocation(), STCE, returnType,
+ VK_PRValue, OK_Ordinary);
ReplacingStmt = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
CondExpr);
}
*Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
Expr *DerefExpr = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
- Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, DerefExpr->getType(),
CK_BitCast,
Expr *RHSExp = CEXPR->getRHS();
Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
Expr *CONDExp = CEXPR->getCond();
- ConditionalOperator *CondExpr =
- new (Context) ConditionalOperator(CONDExp,
- SourceLocation(), cast<Expr>(LHSStmt),
- SourceLocation(), cast<Expr>(RHSStmt),
- Exp->getType(), VK_RValue, OK_Ordinary);
+ ConditionalOperator *CondExpr = new (Context) ConditionalOperator(
+ CONDExp, SourceLocation(), cast<Expr>(LHSStmt), SourceLocation(),
+ cast<Expr>(RHSStmt), Exp->getType(), VK_PRValue, OK_Ordinary);
return CondExpr;
} else if (const ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(BlockExp)) {
CPT = IRE->getType()->getAs<BlockPointerType>();
BlkExprs.push_back(*I);
}
CallExpr *CE =
- CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_RValue,
+ CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_PRValue,
SourceLocation(), FPOptionsOverride());
return CE;
}
// Simulate a constructor call...
FD = SynthBlockInitFunctionDecl(Tag);
DeclRefExpr *DRE = new (Context)
- DeclRefExpr(*Context, FD, false, FType, VK_RValue, SourceLocation());
+ DeclRefExpr(*Context, FD, false, FType, VK_PRValue, SourceLocation());
SmallVector<Expr*, 4> InitExprs;
const_cast<ASTContext &>(*Context),
new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy,
VK_LValue, SourceLocation()),
- UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_RValue,
+ UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_PRValue,
OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
InitExprs.push_back(DescRefExpr);
if (HasLocalVariableExternalStorage(*I)) {
QualType QT = (*I)->getType();
QT = Context->getPointerType(QT);
- Exp = UnaryOperator::Create(
- const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, QT, VK_RValue,
- OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
+ Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp,
+ UO_AddrOf, QT, VK_PRValue, OK_Ordinary,
+ SourceLocation(), false,
+ FPOptionsOverride());
}
} else if (isTopLevelBlockPointerType((*I)->getType())) {
FD = SynthBlockInitFunctionDecl((*I)->getName());
if (HasLocalVariableExternalStorage(*I)) {
QualType QT = (*I)->getType();
QT = Context->getPointerType(QT);
- Exp = UnaryOperator::Create(
- const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, QT, VK_RValue,
- OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
+ Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp,
+ UO_AddrOf, QT, VK_PRValue, OK_Ordinary,
+ SourceLocation(), false,
+ FPOptionsOverride());
}
}
InitExprs.push_back(Exp);
if (!isNestedCapturedVar)
Exp = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), Exp, UO_AddrOf,
- Context->getPointerType(Exp->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(Exp->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp);
InitExprs.push_back(Exp);
SourceLocation(), FPOptionsOverride());
NewRep = UnaryOperator::Create(
const_cast<ASTContext &>(*Context), NewRep, UO_AddrOf,
- Context->getPointerType(NewRep->getType()), VK_RValue, OK_Ordinary,
+ Context->getPointerType(NewRep->getType()), VK_PRValue, OK_Ordinary,
SourceLocation(), false, FPOptionsOverride());
NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
NewRep);
const CXXCastPath *BasePath,
CheckedConversionKind CCK) {
#ifndef NDEBUG
- if (VK == VK_RValue && !E->isRValue()) {
+ if (VK == VK_PRValue && !E->isPRValue()) {
switch (Kind) {
default:
- llvm_unreachable(("can't implicitly cast lvalue to rvalue with this cast "
- "kind: " +
- std::string(CastExpr::getCastKindName(Kind)))
- .c_str());
+ llvm_unreachable(
+ ("can't implicitly cast glvalue to prvalue with this cast "
+ "kind: " +
+ std::string(CastExpr::getCastKindName(Kind)))
+ .c_str());
case CK_Dependent:
case CK_LValueToRValue:
case CK_ArrayToPointerDecay:
break;
}
}
- assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
- "can't cast rvalue to lvalue");
+ assert((VK == VK_PRValue || Kind == CK_Dependent || !E->isPRValue()) &&
+ "can't cast prvalue to glvalue");
#endif
diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
// C++1z [conv.array]: The temporary materialization conversion is applied.
// We also use this to fuel C++ DR1213, which applies to C++11 onwards.
if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
- E->getValueKind() == VK_RValue) {
+ E->getValueKind() == VK_PRValue) {
// The temporary is an lvalue in C++98 and an xvalue otherwise.
ExprResult Materialized = CreateMaterializeTemporaryExpr(
E->getType(), E, !getLangOpts().CPlusPlus11);
void CastOperation::CheckDynamicCast() {
CheckNoDerefRAII NoderefCheck(*this);
- if (ValueKind == VK_RValue)
+ if (ValueKind == VK_PRValue)
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
else if (isPlaceholder())
SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
} else {
// If we're dynamic_casting from a prvalue to an rvalue reference, we need
// to materialize the prvalue before we bind the reference to it.
- if (SrcExpr.get()->isRValue())
+ if (SrcExpr.get()->isPRValue())
SrcExpr = Self.CreateMaterializeTemporaryExpr(
SrcType, SrcExpr.get(), /*IsLValueReference*/ false);
SrcPointee = SrcType;
void CastOperation::CheckConstCast() {
CheckNoDerefRAII NoderefCheck(*this);
- if (ValueKind == VK_RValue)
+ if (ValueKind == VK_PRValue)
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
else if (isPlaceholder())
SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
/// like this:
/// char *bytes = reinterpret_cast\<char*\>(int_ptr);
void CastOperation::CheckReinterpretCast() {
- if (ValueKind == VK_RValue && !isPlaceholder(BuiltinType::Overload))
+ if (ValueKind == VK_PRValue && !isPlaceholder(BuiltinType::Overload))
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
else
checkNonOverloadPlaceholders();
return;
}
- if (ValueKind == VK_RValue && !DestType->isRecordType() &&
+ if (ValueKind == VK_PRValue && !DestType->isRecordType() &&
!isPlaceholder(BuiltinType::Overload)) {
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
return TC_NotApplicable;
}
- if (isa<RValueReferenceType>(DestTypeTmp) && SrcExpr.get()->isRValue()) {
+ if (isa<RValueReferenceType>(DestTypeTmp) && SrcExpr.get()->isPRValue()) {
if (!SrcType->isRecordType()) {
// Cannot const_cast non-class prvalue to rvalue reference type. But if
// this is C-style, static_cast can do this.
// like it?
if (Self.ResolveAndFixSingleFunctionTemplateSpecialization(
Result,
- Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
+ Expr::getValueKindForType(DestType) ==
+ VK_PRValue // Convert Fun to Ptr
) &&
Result.isUsable())
return true;
return;
}
- if (ValueKind == VK_RValue && !DestType->isRecordType() &&
+ if (ValueKind == VK_PRValue && !DestType->isRecordType() &&
!isPlaceholder(BuiltinType::Overload)) {
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
if (SrcExpr.isInvalid())
return;
}
- if (SrcExpr.get()->isRValue())
+ if (SrcExpr.get()->isPRValue())
SrcExpr = Self.CreateMaterializeTemporaryExpr(SrcType, SrcExpr.get(),
/*IsLValueReference=*/false);
ExprResult Sema::SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
SourceLocation BuiltinLoc,
SourceLocation RParenLoc) {
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType DstTy = TInfo->getType();
QualType SrcTy = E->getType();
// If the expression is a temporary, materialize it as an lvalue so that we
// can use it multiple times.
- if (E->getValueKind() == VK_RValue)
+ if (E->getValueKind() == VK_PRValue)
E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
// The location of the `co_await` token cannot be used when constructing
// If the expression is a temporary, materialize it as an lvalue so that we
// can use it multiple times.
- if (E->getValueKind() == VK_RValue)
+ if (E->getValueKind() == VK_PRValue)
E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
// Build the await_ready, await_suspend, await_resume calls.
!Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
ECD->setInitExpr(ImplicitCastExpr::Create(
Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
- /*base paths*/ nullptr, VK_RValue, FPOptionsOverride()));
+ /*base paths*/ nullptr, VK_PRValue, FPOptionsOverride()));
if (getLangOpts().CPlusPlus)
// C++ [dcl.enum]p4: Following the closing brace of an
// enum-specifier, each enumerator has the type of its
E = ImplicitCastExpr::Create(Context,
Context.getPointerType(E->getType()),
clang::CK_FunctionToPointerDecay, E, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
if (E->isLValue())
E = ImplicitCastExpr::Create(Context, E->getType().getNonReferenceType(),
clang::CK_LValueToRValue, E, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
Expr::EvalResult Eval;
Notes.clear();
auto Fail = [&] {
Param->setInvalidDecl();
Param->setDefaultArg(new (Context) OpaqueValueExpr(
- EqualLoc, Param->getType().getNonReferenceType(), VK_RValue));
+ EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));
};
// Default arguments are only permitted in C++
ParmVarDecl *Param = cast<ParmVarDecl>(param);
Param->setInvalidDecl();
UnparsedDefaultArgLocs.erase(Param);
- Param->setDefaultArg(new(Context)
- OpaqueValueExpr(EqualLoc,
- Param->getType().getNonReferenceType(),
- VK_RValue));
+ Param->setDefaultArg(new (Context) OpaqueValueExpr(
+ EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));
}
/// CheckExtraCXXDefaultArguments - Check for any extra default
assert(!R->isUndeducedType() && "type should have been deduced already");
// Don't bother forming a no-op cast in the common case.
- if (E->isRValue() && S.Context.hasSameType(E->getType(), R))
+ if (E->isPRValue() && S.Context.hasSameType(E->getType(), R))
return E;
return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
S.Context.getTrivialTypeSourceInfo(R, Loc), E,
Expr *From = FromB.build(S, Loc);
From = UnaryOperator::Create(
S.Context, From, UO_AddrOf, S.Context.getPointerType(From->getType()),
- VK_RValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
+ VK_PRValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
Expr *To = ToB.build(S, Loc);
To = UnaryOperator::Create(
S.Context, To, UO_AddrOf, S.Context.getPointerType(To->getType()),
- VK_RValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
+ VK_PRValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
const Type *E = T->getBaseElementTypeUnsafe();
bool NeedsCollectableMemCpy =
return StmtError();
ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
- VK_RValue, Loc, nullptr);
+ VK_PRValue, Loc, nullptr);
assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
Expr *CallArgs[] = {
Expr *Comparison = BinaryOperator::Create(
S.Context, IterationVarRefRVal.build(S, Loc),
IntegerLiteral::Create(S.Context, Upper, SizeType, Loc), BO_NE,
- S.Context.BoolTy, VK_RValue, OK_Ordinary, Loc, S.CurFPFeatureOverrides());
+ S.Context.BoolTy, VK_PRValue, OK_Ordinary, Loc,
+ S.CurFPFeatureOverrides());
// Create the pre-increment of the iteration variable. We can determine
// whether the increment will overflow based on the value of the array
if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
BuildBlock = ImplicitCastExpr::Create(
Context, BuildBlock.get()->getType(), CK_CopyAndAutoreleaseBlockObject,
- BuildBlock.get(), nullptr, VK_RValue, FPOptionsOverride());
+ BuildBlock.get(), nullptr, VK_PRValue, FPOptionsOverride());
if (BuildBlock.isInvalid()) {
Diag(CurrentLocation, diag::note_lambda_to_block_conv);
// C++ [conv.lval]p3:
// If T is cv std::nullptr_t, the result is a null pointer constant.
CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;
- Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_RValue,
+ Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_PRValue,
CurFPFeatureOverrides());
// C11 6.3.2.1p2:
if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
T = Atomic->getValueType().getUnqualifiedType();
Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(),
- nullptr, VK_RValue, FPOptionsOverride());
+ nullptr, VK_PRValue, FPOptionsOverride());
}
return Res;
QualType type = VD->getType();
if (type.isNull())
return ExprError();
- ExprValueKind valueKind = VK_RValue;
+ ExprValueKind valueKind = VK_PRValue;
// In 'T ...V;', the type of the declaration 'V' is 'T...', but the type of
// a reference to 'V' is simply (unexpanded) 'T'. The type, like the value,
case Decl::UnresolvedUsingValue:
case Decl::OMPDeclareReduction:
case Decl::OMPDeclareMapper:
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
// Fields and indirect fields that got here must be for
// For non-references, we need to strip qualifiers just in case
// the template parameter was declared as 'const int' or whatever.
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
type = type.getUnqualifiedType();
break;
}
if (!getLangOpts().CPlusPlus &&
!type.hasQualifiers() &&
type->isVoidType()) {
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
LLVM_FALLTHROUGH;
if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
type = Context.BuiltinFnTy;
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
}
// result type, make the entire expression __unknown_anytype.
if (fty->getReturnType() == Context.UnknownAnyTy) {
type = Context.UnknownAnyTy;
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
fty->getExtInfo());
// Functions are r-values in C.
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
= dyn_cast<FunctionProtoType>(VD->getType()))
if (proto->getReturnType() == Context.UnknownAnyTy) {
type = Context.UnknownAnyTy;
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
case Decl::CXXConversion:
case Decl::CXXDestructor:
case Decl::CXXConstructor:
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
break;
}
BaseExpr = LHSExp; // vectors: V[123]
IndexExpr = RHSExp;
// We apply C++ DR1213 to vector subscripting too.
- if (getLangOpts().CPlusPlus11 && LHSExp->getValueKind() == VK_RValue) {
+ if (getLangOpts().CPlusPlus11 && LHSExp->getValueKind() == VK_PRValue) {
ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
if (Materialized.isInvalid())
return ExprError();
LHSExp = Materialized.get();
}
VK = LHSExp->getValueKind();
- if (VK != VK_RValue)
+ if (VK != VK_PRValue)
OK = OK_VectorComponent;
ResultType = VTy->getElementType();
// C forbids expressions of unqualified void type from being l-values.
// See IsCForbiddenLValueType.
- if (!ResultType.hasQualifiers()) VK = VK_RValue;
+ if (!ResultType.hasQualifiers())
+ VK = VK_PRValue;
} else if (!ResultType->isDependentType() &&
RequireCompleteSizedType(
LLoc, ResultType,
diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
return ExprError();
- assert(VK == VK_RValue || LangOpts.CPlusPlus ||
+ assert(VK == VK_PRValue || LangOpts.CPlusPlus ||
!ResultType.isCForbiddenLValueType());
if (LHSExp->IgnoreParenImpCasts()->getType()->isVariablyModifiedType() &&
}
return CallExpr::Create(Context, Fn, /*Args=*/{}, Context.VoidTy,
- VK_RValue, RParenLoc, CurFPFeatureOverrides());
+ VK_PRValue, RParenLoc, CurFPFeatureOverrides());
}
if (Fn->getType() == Context.PseudoObjectTy) {
ExprResult result = CheckPlaceholderExpr(Fn);
// in which case we won't do any semantic analysis now.
if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
if (ExecConfig) {
- return CUDAKernelCallExpr::Create(
- Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
- Context.DependentTy, VK_RValue, RParenLoc, CurFPFeatureOverrides());
+ return CUDAKernelCallExpr::Create(Context, Fn,
+ cast<CallExpr>(ExecConfig), ArgExprs,
+ Context.DependentTy, VK_PRValue,
+ RParenLoc, CurFPFeatureOverrides());
} else {
tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
Fn->getBeginLoc());
return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
- VK_RValue, RParenLoc, CurFPFeatureOverrides());
+ VK_PRValue, RParenLoc, CurFPFeatureOverrides());
}
}
if (!find.HasFormOfMemberPointer) {
if (Expr::hasAnyTypeDependentArguments(ArgExprs))
return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
- VK_RValue, RParenLoc, CurFPFeatureOverrides());
+ VK_PRValue, RParenLoc, CurFPFeatureOverrides());
OverloadExpr *ovl = find.Expression;
if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(ovl))
return BuildOverloadedCallExpr(
ExprResult Sema::BuildAsTypeExpr(Expr *E, QualType DestTy,
SourceLocation BuiltinLoc,
SourceLocation RParenLoc) {
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType SrcTy = E->getType();
if (!SrcTy->isDependentType() &&
assert(UsesADL == ADLCallKind::NotADL &&
"CUDAKernelCallExpr should not use ADL");
TheCall = CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config),
- Args, ResultTy, VK_RValue, RParenLoc,
+ Args, ResultTy, VK_PRValue, RParenLoc,
CurFPFeatureOverrides(), NumParams);
} else {
TheCall =
- CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue, RParenLoc,
+ CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
CurFPFeatureOverrides(), NumParams, UsesADL);
}
if (CorrectedTypos && Args.size() < NumParams) {
if (Config)
TheCall = CUDAKernelCallExpr::Create(
- Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_RValue,
+ Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_PRValue,
RParenLoc, CurFPFeatureOverrides(), NumParams);
else
TheCall =
- CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue, RParenLoc,
+ CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
CurFPFeatureOverrides(), NumParams, UsesADL);
}
// We can now handle the nulled arguments for the default arguments.
// obviously have a value kind derived from the kind of reference involved.
ExprValueKind VK =
(getLangOpts().CPlusPlus && !(isFileScope && literalType->isArrayType()))
- ? VK_RValue
+ ? VK_PRValue
: VK_LValue;
if (isFileScope)
/// Do an explicit extend of the given block pointer if we're in ARC.
void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->getType()->isBlockPointerType());
- assert(E.get()->isRValue());
+ assert(E.get()->isPRValue());
// Only do this in an r-value context.
if (!getLangOpts().ObjCAutoRefCount) return;
E = ImplicitCastExpr::Create(
Context, E.get()->getType(), CK_ARCExtendBlockObject, E.get(),
- /*base path*/ nullptr, VK_RValue, FPOptionsOverride());
+ /*base path*/ nullptr, VK_PRValue, FPOptionsOverride());
Cleanup.setExprNeedsCleanups(true);
}
if (getLangOpts().CPlusPlus)
return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
- VK = VK_RValue;
+ VK = VK_PRValue;
OK = OK_Ordinary;
if (Context.isDependenceAllowed() &&
// If the common expression is a class or array prvalue, materialize it
// so that we can safely refer to it multiple times.
- if (commonExpr->isRValue() && (commonExpr->getType()->isRecordType() ||
- commonExpr->getType()->isArrayType())) {
+ if (commonExpr->isPRValue() && (commonExpr->getType()->isRecordType() ||
+ commonExpr->getType()->isArrayType())) {
ExprResult MatExpr = TemporaryMaterializationConversion(commonExpr);
if (MatExpr.isInvalid())
return ExprError();
}
QualType LHSTy = LHSExpr->getType(), RHSTy = RHSExpr->getType();
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
QualType result = CheckConditionalOperands(Cond, LHS, RHS,
// cast operations are required, so if CheckAssignmentConstraints
// adds casts to this they'll be wasted, but fortunately that doesn't
// usually happen on valid code.
- OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
+ OpaqueValueExpr RHSExpr(Loc, RHSType, VK_PRValue);
ExprResult RHSPtr = &RHSExpr;
CastKind K;
// union type from this initializer list.
TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
- VK_RValue, Initializer, false);
+ VK_PRValue, Initializer, false);
}
Sema::AssignConvertType
CheckPointerConversion(RHS.get(), LHSType, Kind, Path,
/*IgnoreBaseAccess=*/false, Diagnose);
if (ConvertRHS)
- RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path);
+ RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_PRValue, &Path);
}
return Compatible;
}
OK = Op->getObjectKind();
return ResType;
} else {
- VK = VK_RValue;
+ VK = VK_PRValue;
return ResType.getUnqualifiedType();
}
}
// ...except that certain expressions are never l-values in C.
if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
- VK = VK_RValue;
+ VK = VK_PRValue;
return Result;
}
// The following two variables are used for compound assignment operators
QualType CompLHSTy; // Type of LHS after promotions for computation
QualType CompResultTy; // Type of computation result
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
bool ConvertHalfVec = false;
// assignment, but is not an lvalue.
return CompoundAssignOperator::Create(
Context, LHSExpr, RHSExpr, Opc,
- LHSExpr->getType().getUnqualifiedType(), VK_RValue, OK_Ordinary,
+ LHSExpr->getType().getUnqualifiedType(), VK_PRValue, OK_Ordinary,
OpLoc, CurFPFeatureOverrides());
QualType ResultType;
switch (Opc) {
break;
}
return BinaryOperator::Create(Context, LHSExpr, RHSExpr, Opc, ResultType,
- VK_RValue, OK_Ordinary, OpLoc,
+ VK_PRValue, OK_Ordinary, OpLoc,
CurFPFeatureOverrides());
}
UnaryOperatorKind Opc,
Expr *InputExpr) {
ExprResult Input = InputExpr;
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType resultType;
bool CanOverflow = false;
// complex l-values to ordinary l-values and all other values to r-values.
if (Input.isInvalid()) return ExprError();
if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) {
- if (Input.get()->getValueKind() != VK_RValue &&
+ if (Input.get()->getValueKind() != VK_PRValue &&
Input.get()->getObjectKind() == OK_Ordinary)
VK = Input.get()->getValueKind();
} else if (!getLangOpts().CPlusPlus) {
SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType resType;
bool CondIsTrue = false;
Expr *SubExpr = SubResult.get();
E->setSubExpr(SubExpr);
E->setType(S.Context.getPointerType(SubExpr->getType()));
- assert(E->getValueKind() == VK_RValue);
+ assert(E->getValueKind() == VK_PRValue);
assert(E->getObjectKind() == OK_Ordinary);
return E;
}
E->setType(VD->getType());
- assert(E->getValueKind() == VK_RValue);
+ assert(E->getValueKind() == VK_PRValue);
if (S.getLangOpts().CPlusPlus &&
!(isa<CXXMethodDecl>(VD) &&
cast<CXXMethodDecl>(VD)->isInstance()))
return ExprError();
}
- assert(E->getValueKind() == VK_RValue);
+ assert(E->getValueKind() == VK_PRValue);
assert(E->getObjectKind() == OK_Ordinary);
E->setType(DestType);
ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
// The only case we should ever see here is a function-to-pointer decay.
if (E->getCastKind() == CK_FunctionToPointerDecay) {
- assert(E->getValueKind() == VK_RValue);
+ assert(E->getValueKind() == VK_PRValue);
assert(E->getObjectKind() == OK_Ordinary);
E->setType(DestType);
E->setSubExpr(Result.get());
return E;
} else if (E->getCastKind() == CK_LValueToRValue) {
- assert(E->getValueKind() == VK_RValue);
+ assert(E->getValueKind() == VK_PRValue);
assert(E->getObjectKind() == OK_Ordinary);
assert(isa<BlockPointerType>(E->getType()));
DestType = Ptr->getPointeeType();
ExprResult Result = resolveDecl(E, VD);
if (Result.isInvalid()) return ExprError();
- return S.ImpCastExprToType(Result.get(), Type,
- CK_FunctionToPointerDecay, VK_RValue);
+ return S.ImpCastExprToType(Result.get(), Type, CK_FunctionToPointerDecay,
+ VK_PRValue);
}
if (!Type->isFunctionType()) {
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
if (MD->isInstance()) {
- ValueKind = VK_RValue;
+ ValueKind = VK_PRValue;
Type = S.Context.BoundMemberTy;
}
// Function references aren't l-values in C.
if (!S.getLangOpts().CPlusPlus)
- ValueKind = VK_RValue;
+ ValueKind = VK_PRValue;
// - variables
} else if (isa<VarDecl>(VD)) {
CK_BuiltinFnToFnPtr)
.get();
return CallExpr::Create(Context, E, /*Args=*/{}, Context.IntTy,
- VK_RValue, SourceLocation(),
+ VK_PRValue, SourceLocation(),
FPOptionsOverride());
}
}
SizeTy, SourceLocation());
// Otherwise, if we failed to constant-fold the allocation size, we'll
// just give up and pass-in something opaque, that isn't a null pointer.
- OpaqueValueExpr OpaqueAllocationSize(SourceLocation(), SizeTy, VK_RValue,
+ OpaqueValueExpr OpaqueAllocationSize(SourceLocation(), SizeTy, VK_PRValue,
OK_Ordinary, /*SourceExpr=*/nullptr);
// Let's synthesize the alignment argument in case we will need it.
SizeTy, SourceLocation());
ImplicitCastExpr DesiredAlignment(ImplicitCastExpr::OnStack, AlignValT,
CK_IntegralCast, &AlignmentLiteral,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
// Adjust placement args by prepending conjured size and alignment exprs.
llvm::SmallVector<Expr *, 8> CallArgs;
if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
FromType = FromAtomic->getValueType().getUnqualifiedType();
From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
- From, /*BasePath=*/nullptr, VK_RValue,
+ From, /*BasePath=*/nullptr, VK_PRValue,
FPOptionsOverride());
}
break;
case ICK_Array_To_Pointer:
FromType = Context.getArrayDecayedType(FromType);
- From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_Function_To_Pointer:
FromType = Context.getPointerType(FromType);
From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ VK_PRValue, /*BasePath=*/nullptr, CCK)
+ .get();
break;
default:
assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
SCS.Second == ICK_Integral_Promotion &&
"only enums with fixed underlying type can promote to bool");
- From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
} else {
- From = ImpCastExprToType(From, ToType, CK_IntegralCast,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_IntegralCast, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
}
break;
case ICK_Floating_Promotion:
case ICK_Floating_Conversion:
- From = ImpCastExprToType(From, ToType, CK_FloatingCast,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_FloatingCast, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_Complex_Promotion:
} else {
CK = CK_IntegralComplexCast;
}
- From = ImpCastExprToType(From, ToType, CK,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK, VK_PRValue, /*BasePath=*/nullptr,
+ CCK)
+ .get();
break;
}
case ICK_Floating_Integral:
if (ToType->isRealFloatingType())
- From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_IntegralToFloating, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
else
- From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_Compatible_Conversion:
}
if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
CheckObjCConversion(SourceRange(), NewToType, From, CCK);
- From = ImpCastExprToType(From, NewToType, Kind, VK_RValue, &BasePath, CCK)
- .get();
+ From = ImpCastExprToType(From, NewToType, Kind, VK_PRValue, &BasePath, CCK)
+ .get();
break;
}
(void)isCompleteType(From->getExprLoc(), ToType);
}
- From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
- .get();
+ From =
+ ImpCastExprToType(From, ToType, Kind, VK_PRValue, &BasePath, CCK).get();
break;
}
}
From = ImpCastExprToType(From, Context.BoolTy,
- ScalarTypeToBooleanCastKind(FromType),
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ ScalarTypeToBooleanCastKind(FromType), VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_Derived_To_Base: {
}
case ICK_Vector_Conversion:
- From = ImpCastExprToType(From, ToType, CK_BitCast,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_BitCast, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_SVE_Vector_Conversion:
- From = ImpCastExprToType(From, ToType, CK_BitCast, VK_RValue,
+ From = ImpCastExprToType(From, ToType, CK_BitCast, VK_PRValue,
/*BasePath=*/nullptr, CCK)
.get();
break;
case ICK_Vector_Splat: {
// Vector splat from any arithmetic type to a vector.
Expr *Elem = prepareVectorSplat(ToType, From).get();
- From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_RValue,
- /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
}
// _Complex x -> x
From = ImpCastExprToType(From, ElType,
- isFloatingComplex ? CK_FloatingComplexToReal
- : CK_IntegralComplexToReal,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ isFloatingComplex ? CK_FloatingComplexToReal
+ : CK_IntegralComplexToReal,
+ VK_PRValue, /*BasePath=*/nullptr, CCK)
+ .get();
// x -> y
if (Context.hasSameUnqualifiedType(ElType, ToType)) {
// do nothing
} else if (ToType->isRealFloatingType()) {
From = ImpCastExprToType(From, ToType,
- isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ isFloatingComplex ? CK_FloatingCast
+ : CK_IntegralToFloating,
+ VK_PRValue, /*BasePath=*/nullptr, CCK)
+ .get();
} else {
assert(ToType->isIntegerType());
From = ImpCastExprToType(From, ToType,
- isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ isFloatingComplex ? CK_FloatingToIntegral
+ : CK_IntegralCast,
+ VK_PRValue, /*BasePath=*/nullptr, CCK)
+ .get();
}
}
break;
CastKind Kind =
AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
From = ImpCastExprToType(From, ToType.getUnqualifiedType(), Kind,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ VK_PRValue, /*BasePath=*/nullptr, CCK)
+ .get();
break;
}
if (CheckExceptionSpecCompatibility(From, ToType))
return ExprError();
- From = ImpCastExprToType(From, ToType, CK_NoOp,
- VK_RValue, /*BasePath=*/nullptr, CCK).get();
+ From = ImpCastExprToType(From, ToType, CK_NoOp, VK_PRValue,
+ /*BasePath=*/nullptr, CCK)
+ .get();
break;
case ICK_Qualification: {
assert(Context.hasSameType(
ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()));
From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic,
- VK_RValue, nullptr, CCK).get();
+ VK_PRValue, nullptr, CCK)
+ .get();
}
// Materialize a temporary if we're implicitly converting to a reference
// type. This is not required by the C++ rules but is necessary to maintain
// AST invariants.
- if (ToType->isReferenceType() && From->isRValue()) {
+ if (ToType->isReferenceType() && From->isPRValue()) {
ExprResult Res = TemporaryMaterializationConversion(From);
if (Res.isInvalid())
return ExprError();
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
switch (ET) {
case ET_IsLValueExpr: return E->isLValue();
- case ET_IsRValueExpr: return E->isRValue();
+ case ET_IsRValueExpr:
+ return E->isPRValue();
}
llvm_unreachable("Expression trait not covered by switch");
}
// temporary materialization conversion otherwise.
if (isIndirect)
LHS = DefaultLvalueConversion(LHS.get());
- else if (LHS.get()->isRValue())
+ else if (LHS.get()->isPRValue())
LHS = TemporaryMaterializationConversion(LHS.get());
if (LHS.isInvalid())
return QualType();
QualType UseType = Context.getQualifiedType(Class, LHSType.getQualifiers());
if (isIndirect)
UseType = Context.getPointerType(UseType);
- ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
+ ExprValueKind VK = isIndirect ? VK_PRValue : LHS.get()->getValueKind();
LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK,
&BasePath);
}
// result of an ->* expression is an lvalue if its second operand
// is a pointer to data member and a prvalue otherwise.
if (Result->isFunctionType()) {
- VK = VK_RValue;
+ VK = VK_PRValue;
return Context.BoundMemberTy;
} else if (isIndirect) {
VK = VK_LValue;
// pointers.
// Assume r-value.
- VK = VK_RValue;
+ VK = VK_PRValue;
OK = OK_Ordinary;
bool IsVectorConditional =
isValidVectorForConditionalCondition(Context, Cond.get()->getType());
// that instead?
ExprValueKind LVK = LHS.get()->getValueKind();
ExprValueKind RVK = RHS.get()->getValueKind();
- if (!Context.hasSameType(LTy, RTy) &&
- LVK == RVK && LVK != VK_RValue) {
+ if (!Context.hasSameType(LTy, RTy) && LVK == RVK && LVK != VK_PRValue) {
// DerivedToBase was already handled by the class-specific case above.
// FIXME: Should we allow ObjC conversions here?
const ReferenceConversions AllowedConversions =
// We only extend this to bitfields, not to the crazy other kinds of
// l-values.
bool Same = Context.hasSameType(LTy, RTy);
- if (Same && LVK == RVK && LVK != VK_RValue &&
+ if (Same && LVK == RVK && LVK != VK_PRValue &&
LHS.get()->isOrdinaryOrBitFieldObject() &&
RHS.get()->isOrdinaryOrBitFieldObject()) {
VK = LHS.get()->getValueKind();
assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
// If the result is a glvalue, we shouldn't bind it.
- if (!E->isRValue())
+ if (!E->isPRValue())
return E;
// In ARC, calls that return a retainable type can return retained,
CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
: CK_ARCReclaimReturnedObject);
return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
}
if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
NestedNameSpecifierLoc(), SourceLocation(), Method,
DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()),
HadMultipleCandidates, DeclarationNameInfo(),
- Context.BoundMemberTy, VK_RValue, OK_Ordinary);
+ Context.BoundMemberTy, VK_PRValue, OK_Ordinary);
QualType ResultType = Method->getReturnType();
ExprValueKind VK = Expr::getValueKindForType(ResultType);
// [Except in specific positions,] an lvalue that does not have
// array type is converted to the value stored in the
// designated object (and is no longer an lvalue).
- if (E->isRValue()) {
+ if (E->isPRValue()) {
// In C, function designators (i.e. expressions of function type)
// are r-values, but we still want to do function-to-pointer decay
// on them. This is both technically correct and convenient for
if (CompSize == 1)
return vecType->getElementType();
- if (HasRepeated) VK = VK_RValue;
+ if (HasRepeated)
+ VK = VK_PRValue;
QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
// Now look up the TypeDefDecl from the vector type. Without this,
bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
QualType Ty, ExprValueKind VK, ExprObjectKind OK,
const TemplateArgumentListInfo *TemplateArgs) {
- assert((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue");
+ assert((!IsArrow || Base->isPRValue()) &&
+ "-> base must be a pointer prvalue");
MemberExpr *E =
MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc,
Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty,
// C++1z [expr.ref]p2:
// For the first option (dot) the first expression shall be a glvalue [...]
- if (!IsArrow && BaseExpr && BaseExpr->isRValue()) {
+ if (!IsArrow && BaseExpr && BaseExpr->isPRValue()) {
ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
if (Converted.isInvalid())
return ExprError();
BaseExpr = Converted.get();
}
-
const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
DeclarationName MemberName = MemberNameInfo.getName();
SourceLocation MemberLoc = MemberNameInfo.getLoc();
ExprValueKind valueKind;
QualType type;
if (MemberFn->isInstance()) {
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
type = Context.BoundMemberTy;
} else {
valueKind = VK_LValue;
if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
FoundDecl, /*HadMultipleCandidates=*/false,
- MemberNameInfo, Enum->getType(), VK_RValue,
+ MemberNameInfo, Enum->getType(), VK_PRValue,
OK_Ordinary);
}
if (BaseExpr->getObjectKind() == OK_Ordinary)
VK = BaseExpr->getValueKind();
else
- VK = VK_RValue;
+ VK = VK_PRValue;
}
- if (VK != VK_RValue && Field->isBitField())
+ if (VK != VK_PRValue && Field->isBitField())
OK = OK_BitField;
// Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
} else {
ReturnType = Context.getObjCIdType();
}
- VK = VK_RValue;
+ VK = VK_PRValue;
return false;
}
// If we are type-erasing a block to a block-compatible
// Objective-C pointer type, we may need to extend the lifetime
// of the block object.
- if (typeArgs && Args[i]->isRValue() && paramType->isBlockPointerType() &&
+ if (typeArgs && Args[i]->isPRValue() && paramType->isBlockPointerType() &&
Args[i]->getType()->isBlockPointerType() &&
origParamType->isObjCObjectPointerType()) {
ExprResult arg = Args[i];
Expr **Args = ArgsIn.data();
assert(SuperLoc.isInvalid() && "Message to super with dependent type");
return ObjCMessageExpr::Create(
- Context, ReceiverType, VK_RValue, LBracLoc, ReceiverTypeInfo, Sel,
+ Context, ReceiverType, VK_PRValue, LBracLoc, ReceiverTypeInfo, Sel,
SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc,
isImplicit);
}
// Check the argument types and determine the result type.
QualType ReturnType;
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
unsigned NumArgs = ArgsIn.size();
Expr **Args = ArgsIn.data();
Expr **Args = ArgsIn.data();
assert(SuperLoc.isInvalid() && "Message to super with dependent type");
return ObjCMessageExpr::Create(
- Context, Context.DependentTy, VK_RValue, LBracLoc, Receiver, Sel,
+ Context, Context.DependentTy, VK_PRValue, LBracLoc, Receiver, Sel,
SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs),
RBracLoc, isImplicit);
}
unsigned NumArgs = ArgsIn.size();
Expr **Args = ArgsIn.data();
QualType ReturnType;
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
bool ClassMessage = (ReceiverType->isObjCClassType() ||
ReceiverType->isObjCQualifiedClassType());
if (CheckMessageArgumentTypes(Receiver, ReceiverType,
case ACC_plusOne:
castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
CK_ARCConsumeObject, castExpr, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
Cleanup.setExprNeedsCleanups(true);
return ACR_okay;
}
case OBC_BridgeRetained:
// Produce the object before casting it.
SubExpr = ImplicitCastExpr::Create(Context, FromType, CK_ARCProduceObject,
- SubExpr, nullptr, VK_RValue,
+ SubExpr, nullptr, VK_PRValue,
FPOptionsOverride());
break;
if (MustConsume) {
Cleanup.setExprNeedsCleanups(true);
Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
- nullptr, VK_RValue, FPOptionsOverride());
+ nullptr, VK_PRValue, FPOptionsOverride());
}
return Result;
if (!Expr->isLValue() || Expr->getObjectKind() != OK_Ordinary)
return false;
- CanConvert = CompareTypes(S.Context.getPointerType(FromQTy), ToQTy,
- S, Begin, VK_RValue);
+ CanConvert = CompareTypes(S.Context.getPointerType(FromQTy), ToQTy, S,
+ Begin, VK_PRValue);
if (CanConvert) {
if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Expr)) {
static void updateStringLiteralType(Expr *E, QualType Ty) {
while (true) {
E->setType(Ty);
- E->setValueKind(VK_RValue);
+ E->setValueKind(VK_PRValue);
if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E)) {
break;
} else if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
/// as an rvalue.
static void updateGNUCompoundLiteralRValue(Expr *E) {
while (true) {
- E->setValueKind(VK_RValue);
+ E->setValueKind(VK_PRValue);
if (isa<CompoundLiteralExpr>(E)) {
break;
} else if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
Expr *Init = new (Context) IntegerLiteral(
Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
if (CharTy != PromotedCharTy)
- Init =
- ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, Init,
- nullptr, VK_RValue, FPOptionsOverride());
+ Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
+ Init, nullptr, VK_PRValue,
+ FPOptionsOverride());
StructuredList->updateInit(Context, i, Init);
}
} else {
Expr *Init = new (Context) IntegerLiteral(
Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
if (CharTy != PromotedCharTy)
- Init =
- ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, Init,
- nullptr, VK_RValue, FPOptionsOverride());
+ Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
+ Init, nullptr, VK_PRValue,
+ FPOptionsOverride());
StructuredList->updateInit(Context, i, Init);
}
}
case SK_FinalCopy:
case SK_ExtraneousCopyToTemporary:
case SK_UserConversion:
- case SK_QualificationConversionRValue:
+ case SK_QualificationConversionPRValue:
case SK_QualificationConversionXValue:
case SK_QualificationConversionLValue:
case SK_FunctionReferenceConversion:
ExprValueKind VK) {
Step S;
switch (VK) {
- case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
+ case VK_PRValue:
+ S.Kind = SK_CastDerivedToBaseRValue;
+ break;
case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
}
void InitializationSequence::AddQualificationConversionStep(QualType Ty,
ExprValueKind VK) {
Step S;
- S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
+ S.Kind = SK_QualificationConversionPRValue; // work around a gcc warning
switch (VK) {
- case VK_RValue:
- S.Kind = SK_QualificationConversionRValue;
+ case VK_PRValue:
+ S.Kind = SK_QualificationConversionPRValue;
break;
case VK_XValue:
S.Kind = SK_QualificationConversionXValue;
Entity.getKind() != InitializedEntity::EK_Delegating &&
Entity.getKind() !=
InitializedEntity::EK_LambdaToBlockConversionBlockElement &&
- UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
+ UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
// Convert qualifications if necessary.
- Sequence.AddQualificationConversionStep(DestType, VK_RValue);
+ Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
if (ILE)
Sequence.RewrapReferenceInitList(DestType, ILE);
return;
Sequence.AddUserConversionStep(CD, Best->FoundDecl, ConvType,
HadMultipleCandidates);
if (!S.Context.hasSameType(ConvType, DestType))
- Sequence.AddQualificationConversionStep(DestType, VK_RValue);
+ Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
if (IsListInit)
Sequence.RewrapReferenceInitList(Entity.getType(), ILE);
return;
ImplicitConversionSequence ICS;
ICS.setStandard();
ICS.Standard.setAsIdentityConversion();
- if (!E->isRValue())
+ if (!E->isPRValue())
ICS.Standard.First = ICK_Lvalue_To_Rvalue;
// If E is of a floating-point type, then the conversion is ill-formed
// due to narrowing, but go through the motions in order to produce the
else
cv3T3 = T1;
- ExprValueKind VK = VK_RValue;
+ ExprValueKind VK = VK_PRValue;
if (cv3T3->isLValueReferenceType())
VK = VK_LValue;
else if (const auto *RRef = cv3T3->getAs<RValueReferenceType>())
// Every implicit conversion results in a prvalue, except for a glvalue
// derived-to-base conversion, which we handle below.
cv3T3 = ICS.Standard.getToType(2);
- VK = VK_RValue;
+ VK = VK_PRValue;
}
// If the converted initializer is a prvalue, its type T4 is adjusted to
QualType cv1T4 = S.Context.getQualifiedType(cv3T3, cv1T1.getQualifiers());
if (cv1T4.getQualifiers() != cv3T3.getQualifiers())
Sequence.AddQualificationConversionStep(cv1T4, VK);
- Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
+ Sequence.AddReferenceBindingStep(cv1T4, VK == VK_PRValue);
VK = IsLValueRef ? VK_LValue : VK_XValue;
if (RefConv & Sema::ReferenceConversions::DerivedToBase)
(InitCategory.isPRValue() &&
(S.getLangOpts().CPlusPlus17 || T2->isRecordType() ||
T2->isArrayType())))) {
- ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_RValue;
+ ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_PRValue;
if (InitCategory.isPRValue() && T2->isRecordType()) {
// The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
// compiler the freedom to perform a copy here or bind to the
QualType cv1T4 = S.Context.getQualifiedType(cv2T2, T1QualsIgnoreAS);
if (T1QualsIgnoreAS != T2QualsIgnoreAS)
Sequence.AddQualificationConversionStep(cv1T4, ValueKind);
- Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_RValue);
+ Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_PRValue);
ValueKind = isLValueRef ? VK_LValue : VK_XValue;
// Add addr space conversion if required.
if (T1Quals.getAddressSpace() != T2Quals.getAddressSpace()) {
if (!S.getLangOpts().CPlusPlus17)
Sequence.AddFinalCopy(DestType);
else if (DestType.hasQualifiers())
- Sequence.AddQualificationConversionStep(DestType, VK_RValue);
+ Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
return;
}
!S.Context.hasSameUnqualifiedType(ConvType, DestType))
Sequence.AddFinalCopy(DestType);
else if (!S.Context.hasSameType(ConvType, DestType))
- Sequence.AddQualificationConversionStep(DestType, VK_RValue);
+ Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
return;
}
/// Check whether the given expression is a valid operand for an
/// indirect copy/restore.
static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
- assert(src->isRValue());
+ assert(src->isPRValue());
bool isWeakAccess = false;
InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
// If isWeakAccess to true, there will be an implicit
Entity.getType()) &&
canPerformArrayCopy(Entity)) {
// If source is a prvalue, use it directly.
- if (Initializer->getValueKind() == VK_RValue) {
+ if (Initializer->getValueKind() == VK_PRValue) {
AddArrayInitStep(DestType, /*IsGNUExtension*/false);
return;
}
} else {
DiagID = diag::warn_pessimizing_move_on_initialization;
const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
- if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
+ if (!ArgStripped->isPRValue() || !ArgStripped->getType()->isRecordType())
return;
}
// FIXME: This means that AST consumers need to deal with "prvalues" that
// denote materialized temporaries. Maybe we should add another ValueKind
// for "xvalue pretending to be a prvalue" for C++98 support.
- if (!E->isRValue() || !getLangOpts().CPlusPlus11)
+ if (!E->isPRValue() || !getLangOpts().CPlusPlus11)
return E;
// C++1z [conv.rval]/1: T shall be a complete type.
CastKind CK = CK_NoOp;
- if (VK == VK_RValue) {
+ if (VK == VK_PRValue) {
auto PointeeTy = Ty->getPointeeType();
auto ExprPointeeTy = E->getType()->getPointeeType();
if (!PointeeTy.isNull() &&
case SK_UserConversion:
case SK_QualificationConversionLValue:
case SK_QualificationConversionXValue:
- case SK_QualificationConversionRValue:
+ case SK_QualificationConversionPRValue:
case SK_FunctionReferenceConversion:
case SK_AtomicConversion:
case SK_ConversionSequence:
return ExprError();
ExprValueKind VK =
- Step->Kind == SK_CastDerivedToBaseLValue ?
- VK_LValue :
- (Step->Kind == SK_CastDerivedToBaseXValue ?
- VK_XValue :
- VK_RValue);
+ Step->Kind == SK_CastDerivedToBaseLValue
+ ? VK_LValue
+ : (Step->Kind == SK_CastDerivedToBaseXValue ? VK_XValue
+ : VK_PRValue);
CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
CK_DerivedToBase, CurInit.get(),
&BasePath, VK, FPOptionsOverride());
case SK_BindReferenceToTemporary: {
// Make sure the "temporary" is actually an rvalue.
- assert(CurInit.get()->isRValue() && "not a temporary");
+ assert(CurInit.get()->isPRValue() && "not a temporary");
// Check exception specifications
if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
case SK_QualificationConversionLValue:
case SK_QualificationConversionXValue:
- case SK_QualificationConversionRValue: {
+ case SK_QualificationConversionPRValue: {
// Perform a qualification conversion; these can never go wrong.
ExprValueKind VK =
Step->Kind == SK_QualificationConversionLValue
? VK_LValue
: (Step->Kind == SK_QualificationConversionXValue ? VK_XValue
- : VK_RValue);
+ : VK_PRValue);
CurInit = S.PerformQualificationConversion(CurInit.get(), Step->Type, VK);
break;
}
break;
case SK_AtomicConversion: {
- assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
+ assert(CurInit.get()->isPRValue() && "cannot convert glvalue to atomic");
CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
- CK_NonAtomicToAtomic, VK_RValue);
+ CK_NonAtomicToAtomic, VK_PRValue);
break;
}
case SK_ProduceObjCObject:
CurInit = ImplicitCastExpr::Create(
S.Context, Step->Type, CK_ARCProduceObject, CurInit.get(), nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
break;
case SK_StdInitializerList: {
if (!Var->hasGlobalStorage()) {
CurInit = ImplicitCastExpr::Create(
S.Context, Step->Type, CK_LValueToRValue, Init,
- /*BasePath=*/nullptr, VK_RValue, FPOptionsOverride());
+ /*BasePath=*/nullptr, VK_PRValue, FPOptionsOverride());
break;
}
// Case 1a
OS << "user-defined conversion via " << *S->Function.Function;
break;
- case SK_QualificationConversionRValue:
- OS << "qualification conversion (rvalue)";
+ case SK_QualificationConversionPRValue:
+ OS << "qualification conversion (prvalue)";
break;
case SK_QualificationConversionXValue:
Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast, E,
- /*base path*/ nullptr, VK_RValue,
+ /*base path*/ nullptr, VK_PRValue,
FPOptionsOverride());
if (cleanups) {
cleanups->setSubExpr(E);
ArgType.addVolatile();
// This isn't /really/ specified by the standard, but it's implied
- // we should be working from an RValue in the case of move to ensure
+ // we should be working from a PRValue in the case of move to ensure
// that we prefer to bind to rvalue references, and an LValue in the
// case of copy to ensure we don't bind to rvalue references.
// Possibly an XValue is actually correct in the case of move, but
if (SM == CXXCopyConstructor || SM == CXXCopyAssignment)
VK = VK_LValue;
else
- VK = VK_RValue;
+ VK = VK_PRValue;
}
OpaqueValueExpr FakeArg(LookupLoc, ArgType, VK);
if (VolatileThis)
ThisTy.addVolatile();
Expr::Classification Classification =
- OpaqueValueExpr(LookupLoc, ThisTy,
- RValueThis ? VK_RValue : VK_LValue).Classify(Context);
+ OpaqueValueExpr(LookupLoc, ThisTy, RValueThis ? VK_PRValue : VK_LValue)
+ .Classify(Context);
// Now we perform lookup on the name we computed earlier and do overload
// resolution. Lookup is only performed directly into the class since there
MarkDeclRefReferenced(SelfExpr);
Expr *LoadSelfExpr = ImplicitCastExpr::Create(
Context, SelfDecl->getType(), CK_LValueToRValue, SelfExpr, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
Expr *IvarRefExpr =
new (Context) ObjCIvarRefExpr(Ivar,
Ivar->getUsageType(SelfDecl->getType()),
MarkDeclRefReferenced(SelfExpr);
Expr *LoadSelfExpr = ImplicitCastExpr::Create(
Context, SelfDecl->getType(), CK_LValueToRValue, SelfExpr, nullptr,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
Expr *lhs =
new (Context) ObjCIvarRefExpr(Ivar,
Ivar->getUsageType(SelfDecl->getType()),
auto *VariantFuncRef = DeclRefExpr::Create(
Context, NestedNameSpecifierLoc(), SourceLocation(), FD,
/* RefersToEnclosingVariableOrCapture */ false,
- /* NameLoc */ FD->getLocation(), FD->getType(), ExprValueKind::VK_RValue);
+ /* NameLoc */ FD->getLocation(), FD->getType(),
+ ExprValueKind::VK_PRValue);
OMPDeclareVariantScope &DVScope = OMPDeclareVariantScopes.back();
auto *OMPDeclareVariantA = OMPDeclareVariantAttr::CreateImplicit(
// OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
// OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
auto *OVEX = new (SemaRef.getASTContext())
- OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
+ OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_PRValue);
auto *OVEExpr = new (SemaRef.getASTContext())
- OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
+ OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_PRValue);
ExprResult Update =
SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
IsXLHSInRHSPart ? OVEExpr : OVEX);
// (type of the variable or single array element).
PrivateTy = Context.getVariableArrayType(
Type,
- new (Context) OpaqueValueExpr(ELoc, Context.getSizeType(), VK_RValue),
+ new (Context)
+ OpaqueValueExpr(ELoc, Context.getSizeType(), VK_PRValue),
ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange());
} else if (!ASE && !OASE &&
Context.getAsArrayType(D->getType().getNonReferenceType())) {
QualType Params[] = {PtrRedTy, PtrRedTy};
QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
auto *OVE = new (Context) OpaqueValueExpr(
- ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
+ ELoc, Context.getPointerType(FnTy), VK_PRValue, OK_Ordinary,
S.DefaultLvalueConversion(DeclareReductionRef.get()).get());
Expr *Args[] = {LHS.get(), RHS.get()};
ReductionOp =
- CallExpr::Create(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc,
+ CallExpr::Create(Context, OVE, Args, Context.VoidTy, VK_PRValue, ELoc,
S.CurFPFeatureOverrides());
} else {
BinaryOperatorKind CombBOK = getRelatedCompoundReductionOp(BOK);
} else {
// Build temp array for prefix sum.
auto *Dim = new (S.Context)
- OpaqueValueExpr(ELoc, S.Context.getSizeType(), VK_RValue);
+ OpaqueValueExpr(ELoc, S.Context.getSizeType(), VK_PRValue);
QualType ArrayTy =
S.Context.getVariableArrayType(PrivateTy, Dim, ArrayType::Normal,
/*IndexTypeQuals=*/0, {ELoc, ELoc});
TempArrayElem =
S.DefaultFunctionArrayLvalueConversion(TempArrayRes.get());
auto *Idx = new (S.Context)
- OpaqueValueExpr(ELoc, S.Context.getSizeType(), VK_RValue);
+ OpaqueValueExpr(ELoc, S.Context.getSizeType(), VK_PRValue);
TempArrayElem = S.CreateBuiltinArraySubscriptExpr(TempArrayElem.get(),
ELoc, Idx, ELoc);
}
DestType = ImplicitParamRecordType;
FromClassification = From->Classify(Context);
- // When performing member access on an rvalue, materialize a temporary.
- if (From->isRValue()) {
+ // When performing member access on a prvalue, materialize a temporary.
+ if (From->isPRValue()) {
From = CreateMaterializeTemporaryExpr(FromRecordType, From,
Method->getRefQualifier() !=
RefQualifierKind::RQ_RValue);
ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
Context.getPointerType(Conversion->getType()),
CK_FunctionToPointerDecay, &ConversionRef,
- VK_RValue, FPOptionsOverride());
+ VK_PRValue, FPOptionsOverride());
QualType ConversionType = Conversion->getConversionType();
if (!isCompleteType(From->getBeginLoc(), ConversionType)) {
// lookup to instantiation time to be able to search into type dependent
// base classes.
CallExpr *CE =
- CallExpr::Create(Context, Fn, Args, Context.DependentTy, VK_RValue,
+ CallExpr::Create(Context, Fn, Args, Context.DependentTy, VK_PRValue,
RParenLoc, CurFPFeatureOverrides());
CE->markDependentForPostponedNameLookup();
*Result = CE;
if (Input->isTypeDependent()) {
if (Fns.empty())
return UnaryOperator::Create(Context, Input, Opc, Context.DependentTy,
- VK_RValue, OK_Ordinary, OpLoc, false,
+ VK_PRValue, OK_Ordinary, OpLoc, false,
CurFPFeatureOverrides());
CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
if (Fn.isInvalid())
return ExprError();
return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), ArgsArray,
- Context.DependentTy, VK_RValue, OpLoc,
+ Context.DependentTy, VK_PRValue, OpLoc,
CurFPFeatureOverrides());
}
Context, Args[0], Args[1], Opc, Context.DependentTy, VK_LValue,
OK_Ordinary, OpLoc, CurFPFeatureOverrides(), Context.DependentTy,
Context.DependentTy);
- return BinaryOperator::Create(Context, Args[0], Args[1], Opc,
- Context.DependentTy, VK_RValue, OK_Ordinary,
- OpLoc, CurFPFeatureOverrides());
+ return BinaryOperator::Create(
+ Context, Args[0], Args[1], Opc, Context.DependentTy, VK_PRValue,
+ OK_Ordinary, OpLoc, CurFPFeatureOverrides());
}
// FIXME: save results of ADL from here?
if (Fn.isInvalid())
return ExprError();
return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), Args,
- Context.DependentTy, VK_RValue, OpLoc,
+ Context.DependentTy, VK_PRValue, OpLoc,
CurFPFeatureOverrides());
}
// Can't add any actual overloads yet
return CXXOperatorCallExpr::Create(Context, OO_Subscript, Fn.get(), Args,
- Context.DependentTy, VK_RValue, RLoc,
+ Context.DependentTy, VK_PRValue, RLoc,
CurFPFeatureOverrides());
}
Type);
};
if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
- return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_RValue,
+ return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_PRValue,
RParenLoc, CurFPFeatureOverrides());
UnbridgedCastsSet UnbridgedCasts;
// Record usage of conversion in an implicit cast.
Call = ImplicitCastExpr::Create(
Context, Call.get()->getType(), CK_UserDefinedConversion, Call.get(),
- nullptr, VK_RValue, CurFPFeatureOverrides());
+ nullptr, VK_PRValue, CurFPFeatureOverrides());
return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
}
(void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
return UnaryOperator::Create(
- Context, SubExpr, UO_AddrOf, MemPtrType, VK_RValue, OK_Ordinary,
+ Context, SubExpr, UO_AddrOf, MemPtrType, VK_PRValue, OK_Ordinary,
UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
}
}
if (SubExpr == UnOp->getSubExpr())
return UnOp;
- return UnaryOperator::Create(Context, SubExpr, UO_AddrOf,
- Context.getPointerType(SubExpr->getType()),
- VK_RValue, OK_Ordinary, UnOp->getOperatorLoc(),
- false, CurFPFeatureOverrides());
+ return UnaryOperator::Create(
+ Context, SubExpr, UO_AddrOf, Context.getPointerType(SubExpr->getType()),
+ VK_PRValue, OK_Ordinary, UnOp->getOperatorLoc(), false,
+ CurFPFeatureOverrides());
}
if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
valueKind = VK_LValue;
type = Fn->getType();
} else {
- valueKind = VK_RValue;
+ valueKind = VK_PRValue;
type = Context.BoundMemberTy;
}
// As a special case, if the method returns 'id', try to get
// a better type from the property.
- if (RefExpr->isExplicitProperty() && result.get()->isRValue()) {
+ if (RefExpr->isExplicitProperty() && result.get()->isPRValue()) {
QualType receiverType = RefExpr->getReceiverType(S.Context);
QualType propType = RefExpr->getExplicitProperty()
->getUsageType(receiverType);
// Do nothing if the operand is dependent.
if (op->isTypeDependent())
return UnaryOperator::Create(Context, op, opcode, Context.DependentTy,
- VK_RValue, OK_Ordinary, opcLoc, false,
+ VK_PRValue, OK_Ordinary, opcLoc, false,
CurFPFeatureOverrides());
assert(UnaryOperator::isIncrementDecrementOp(opcode));
// Do nothing if either argument is dependent.
if (LHS->isTypeDependent() || RHS->isTypeDependent())
return BinaryOperator::Create(Context, LHS, RHS, opcode,
- Context.DependentTy, VK_RValue, OK_Ordinary,
+ Context.DependentTy, VK_PRValue, OK_Ordinary,
opcLoc, CurFPFeatureOverrides());
// Filter out non-overload placeholder types in the RHS.
Cond = ConditionResult(
*this, nullptr,
MakeFullExpr(new (Context) OpaqueValueExpr(SourceLocation(),
- Context.BoolTy, VK_RValue),
+ Context.BoolTy, VK_PRValue),
IfLoc),
false);
// If the type contained 'auto', deduce the 'auto' to 'id'.
if (FirstType->getContainedAutoType()) {
OpaqueValueExpr OpaqueId(D->getLocation(), Context.getObjCIdType(),
- VK_RValue);
+ VK_PRValue);
Expr *DeducedInit = &OpaqueId;
if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, FirstType) ==
DAR_Failed)
Expr::EvalResult Eval;
if (T->isFunctionType() || T->isDependentType())
return Info.setLabel(Res);
- if (Res->isRValue()) {
+ if (Res->isPRValue()) {
bool IsEnum = isa<clang::EnumType>(T);
if (DeclRefExpr *DRE = dyn_cast<clang::DeclRefExpr>(Res))
if (DRE->getDecl()->getKind() == Decl::EnumConstant)
}
// FIXME: Concepts: This should be the type of the placeholder, but this is
// unclear in the wording right now.
- DeclRefExpr *Ref = BuildDeclRefExpr(NTTP, NTTP->getType(), VK_RValue,
- NTTP->getLocation());
+ DeclRefExpr *Ref =
+ BuildDeclRefExpr(NTTP, NTTP->getType(), VK_PRValue, NTTP->getLocation());
if (!Ref)
return true;
ExprResult ImmediatelyDeclaredConstraint =
NewDefArg = new (SemaRef.Context)
OpaqueValueExpr(OldParam->getDefaultArg()->getBeginLoc(),
ParamTy.getNonLValueExprType(SemaRef.Context),
- ParamTy->isLValueReferenceType() ? VK_LValue :
- ParamTy->isRValueReferenceType() ? VK_XValue :
- VK_RValue);
+ ParamTy->isLValueReferenceType() ? VK_LValue
+ : ParamTy->isRValueReferenceType() ? VK_XValue
+ : VK_PRValue);
}
ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
Arg = PE->getPattern();
ExprResult E = ImpCastExprToType(
Arg, ParamType.getNonLValueExprType(Context), CK_Dependent,
- ParamType->isLValueReferenceType() ? VK_LValue :
- ParamType->isRValueReferenceType() ? VK_XValue : VK_RValue);
+ ParamType->isLValueReferenceType() ? VK_LValue
+ : ParamType->isRValueReferenceType() ? VK_XValue
+ : VK_PRValue);
if (E.isInvalid())
return ExprError();
if (PE) {
if (OrigT->isEnumeralType()) {
// FIXME: This is a hack. We need a better way to handle substituted
// non-type template parameters.
- E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
+ E = CStyleCastExpr::Create(Context, OrigT, VK_PRValue, CK_IntegralCast, E,
nullptr, CurFPFeatureOverrides(),
Context.getTrivialTypeSourceInfo(OrigT, Loc),
Loc, Loc);
ExprType.addConst();
return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
- ExprType, TargetType->isReferenceType() ? VK_LValue : VK_RValue, NTTP,
- E->getLocation(), Arg);
+ ExprType, TargetType->isReferenceType() ? VK_LValue : VK_PRValue,
+ NTTP, E->getLocation(), Arg);
}
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
SourceLocation(), SubstFD,
/* RefersToEnclosingVariableOrCapture */ false,
/* NameLoc */ SubstFD->getLocation(),
- SubstFD->getType(), ExprValueKind::VK_RValue);
+ SubstFD->getType(), ExprValueKind::VK_PRValue);
}
}
}
}
// Do lvalue-to-rvalue conversions on the array size expression.
- if (ArraySize && !ArraySize->isRValue()) {
+ if (ArraySize && !ArraySize->isPRValue()) {
ExprResult Result = DefaultLvalueConversion(ArraySize);
if (Result.isInvalid())
return QualType();
case VK_LValue:
return Context.getLValueReferenceType(T);
// - otherwise, decltype(e) is the type of e.
- case VK_RValue:
+ case VK_PRValue:
return T;
}
llvm_unreachable("Unknown value kind");
FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
Expr *Callee = new (SemaRef.Context)
DeclRefExpr(SemaRef.Context, Builtin, false,
- SemaRef.Context.BuiltinFnTy, VK_RValue, BuiltinLoc);
+ SemaRef.Context.BuiltinFnTy, VK_PRValue, BuiltinLoc);
QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
CK_BuiltinFnToFnPtr).get();
auto *VD = cast<ValueDecl>(Pack);
ExprResult DRE = getSema().BuildDeclRefExpr(
VD, VD->getType().getNonLValueExprType(getSema().Context),
- VD->getType()->isReferenceType() ? VK_LValue : VK_RValue,
+ VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
E->getPackLoc());
if (DRE.isInvalid())
return ExprError();
const MemRegion *BaseRegion = ArgRegion->getBaseRegion();
// Skip temp objects because of their short lifetime.
if (BaseRegion->getAs<CXXTempObjectRegion>() ||
- AFC->getArgExpr(0)->isRValue())
+ AFC->getArgExpr(0)->isPRValue())
return;
// If it has already been reported do not need to modify the state.
PathSensitiveBugReport &report,
bugreporter::TrackingKind TKind,
bool EnableNullFPSuppression) {
- assert(E->isRValue() && "The expression is not an rvalue!");
+ assert(E->isPRValue() && "The expression is not a prvalue!");
const ExplodedNode *RVNode = findNodeForExpression(InputNode, E);
if (!RVNode)
return;
}
}
- if (Inner->isRValue())
+ if (Inner->isPRValue())
trackRValueExpression(LVNode, Inner, report, TKind,
EnableNullFPSuppression);
case VK_XValue:
ResultTy = Ctx.getRValueReferenceType(ResultTy);
break;
- case VK_RValue:
+ case VK_PRValue:
// No adjustment is necessary.
break;
}
// CHECK-NEXT: }
// CHECK-NEXT: }
-
// CHECK: "kind": "EnumConstantDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 835,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "RecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 875,
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1003,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1113,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "enum Enum",
// CHECK-NEXT: "qualType": "enum Enum"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1168,
// CHECK-NEXT: }
// CHECK-NEXT: }
-
// CHECK: "kind": "FieldDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1351,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1383,
// CHECK-NEXT: "tls": "static"
// CHECK-NEXT: }
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1458,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1505,
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ObjCMethodDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 490,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ObjCProtocolDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 562,
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1184,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(int, ...)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "cleanupsHaveSideEffects": true,
// CHECK-NEXT: "cleanups": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(int, ...)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1296,
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -Wno-unused-value -std=gnu11 -ast-dump=json %s | FileCheck %s\r
-\r
-void Comma(void) {\r
- 1, 2, 3;\r
-}\r
-\r
-void Assignment(int a) {\r
- a = 12;\r
- a += a;\r
-}\r
-\r
-void Conditionals(int a) {\r
- a ? 0 : 1;\r
- a ?: 0;\r
-}\r
-\r
-void BinaryOperators(int a, int b) {\r
- // Logical operators\r
- a || b;\r
- a && b;\r
-\r
- // Bitwise operators\r
- a | b;\r
- a ^ b;\r
- a & b;\r
-\r
- // Equality operators\r
- a == b;\r
- a != b;\r
-\r
- // Relational operators\r
- a < b;\r
- a > b;\r
- a <= b;\r
- a >= b;\r
-\r
- // Bit shifting operators\r
- a << b;\r
- a >> b;\r
-\r
- // Additive operators\r
- a + b;\r
- a - b;\r
-\r
- // Multiplicative operators\r
- a * b;\r
- a / b;\r
- a % b;\r
-}\r
-\r
-void UnaryOperators(int a, int *b) {\r
- // Cast operators\r
- (float)a;\r
-\r
- // ++, --, and ~ are covered elsewhere.\r
-\r
- -a;\r
- +a;\r
- &a;\r
- *b;\r
- !a;\r
-\r
- sizeof a;\r
- sizeof(int);\r
- _Alignof(int);\r
-}\r
-\r
-struct S {\r
- int a;\r
-};\r
-\r
-void PostfixOperators(int *a, struct S b, struct S *c) {\r
- a[0];\r
- UnaryOperators(*a, a);\r
-\r
- b.a;\r
- c->a;\r
-\r
- // Postfix ++ and -- are covered elsewhere.\r
-\r
- (int [4]){1, 2, 3, 4, };\r
- (struct S){1};\r
-}\r
-\r
-enum E { One };\r
-\r
-void PrimaryExpressions(int a) {\r
- a;\r
- 'a';\r
- L'a';\r
- "a";\r
- L"a";\r
- u8"a";\r
- U"a";\r
- u"a";\r
-\r
- 1;\r
- 1u;\r
- 1ll;\r
- 1.0;\r
- 1.0f;\r
- 0xFp100000000000000000000F;\r
- 1.0l;\r
- One;\r
-\r
- (a);\r
-}\r
-\r
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -Wno-unused-value -std=gnu11 -ast-dump=json %s | FileCheck %s
+
+void Comma(void) {
+ 1, 2, 3;
+}
+
+void Assignment(int a) {
+ a = 12;
+ a += a;
+}
+
+void Conditionals(int a) {
+ a ? 0 : 1;
+ a ?: 0;
+}
+
+void BinaryOperators(int a, int b) {
+ // Logical operators
+ a || b;
+ a && b;
+
+ // Bitwise operators
+ a | b;
+ a ^ b;
+ a & b;
+
+ // Equality operators
+ a == b;
+ a != b;
+
+ // Relational operators
+ a < b;
+ a > b;
+ a <= b;
+ a >= b;
+
+ // Bit shifting operators
+ a << b;
+ a >> b;
+
+ // Additive operators
+ a + b;
+ a - b;
+
+ // Multiplicative operators
+ a * b;
+ a / b;
+ a % b;
+}
+
+void UnaryOperators(int a, int *b) {
+ // Cast operators
+ (float)a;
+
+ // ++, --, and ~ are covered elsewhere.
+
+ -a;
+ +a;
+ &a;
+ *b;
+ !a;
+
+ sizeof a;
+ sizeof(int);
+ _Alignof(int);
+}
+
+struct S {
+ int a;
+};
+
+void PostfixOperators(int *a, struct S b, struct S *c) {
+ a[0];
+ UnaryOperators(*a, a);
+
+ b.a;
+ c->a;
+
+ // Postfix ++ and -- are covered elsewhere.
+
+ (int [4]){1, 2, 3, 4, };
+ (struct S){1};
+}
+
+enum E { One };
+
+void PrimaryExpressions(int a) {
+ a;
+ 'a';
+ L'a';
+ "a";
+ L"a";
+ u8"a";
+ U"a";
+ u"a";
+
+ 1;
+ 1u;
+ 1ll;
+ 1.0;
+ 1.0f;
+ 0xFp100000000000000000000F;
+ 1.0l;
+ One;
+
+ (a);
+}
+
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=FunctionDecl
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 120,
+// CHECK-NEXT: "offset": 118,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 3,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 115,
+// CHECK-NEXT: "offset": 113,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 147,
+// CHECK-NEXT: "offset": 143,
// CHECK-NEXT: "line": 5,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 132,
+// CHECK-NEXT: "offset": 130,
// CHECK-NEXT: "line": 3,
// CHECK-NEXT: "col": 18,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 147,
+// CHECK-NEXT: "offset": 143,
// CHECK-NEXT: "line": 5,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 137,
+// CHECK-NEXT: "offset": 134,
// CHECK-NEXT: "line": 4,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 143,
+// CHECK-NEXT: "offset": 140,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ",",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 137,
+// CHECK-NEXT: "offset": 134,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 140,
+// CHECK-NEXT: "offset": 137,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ",",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 137,
+// CHECK-NEXT: "offset": 134,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 137,
+// CHECK-NEXT: "offset": 134,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 140,
+// CHECK-NEXT: "offset": 137,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 140,
+// CHECK-NEXT: "offset": 137,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 143,
+// CHECK-NEXT: "offset": 140,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 143,
+// CHECK-NEXT: "offset": 140,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "3"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 157,
+// CHECK-NEXT: "offset": 151,
// CHECK-NEXT: "line": 7,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 10
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 152,
+// CHECK-NEXT: "offset": 146,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 200,
+// CHECK-NEXT: "offset": 191,
// CHECK-NEXT: "line": 10,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 172,
+// CHECK-NEXT: "offset": 166,
// CHECK-NEXT: "line": 7,
// CHECK-NEXT: "col": 21,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 168,
+// CHECK-NEXT: "offset": 162,
// CHECK-NEXT: "col": 17,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 172,
+// CHECK-NEXT: "offset": 166,
// CHECK-NEXT: "col": 21,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 175,
+// CHECK-NEXT: "offset": 169,
// CHECK-NEXT: "col": 24,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 200,
+// CHECK-NEXT: "offset": 191,
// CHECK-NEXT: "line": 10,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 180,
+// CHECK-NEXT: "offset": 173,
// CHECK-NEXT: "line": 8,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 184,
+// CHECK-NEXT: "offset": 177,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 180,
+// CHECK-NEXT: "offset": 173,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 180,
+// CHECK-NEXT: "offset": 173,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 184,
+// CHECK-NEXT: "offset": 177,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 184,
+// CHECK-NEXT: "offset": 177,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "kind": "CompoundAssignOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 191,
+// CHECK-NEXT: "offset": 183,
// CHECK-NEXT: "line": 9,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 196,
+// CHECK-NEXT: "offset": 188,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+=",
// CHECK-NEXT: "computeLHSType": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 191,
+// CHECK-NEXT: "offset": 183,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 191,
+// CHECK-NEXT: "offset": 183,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 196,
+// CHECK-NEXT: "offset": 188,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 196,
+// CHECK-NEXT: "offset": 188,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 196,
+// CHECK-NEXT: "offset": 188,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 196,
+// CHECK-NEXT: "offset": 188,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 210,
+// CHECK-NEXT: "offset": 199,
// CHECK-NEXT: "line": 12,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 12
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 205,
+// CHECK-NEXT: "offset": 194,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 258,
+// CHECK-NEXT: "offset": 244,
// CHECK-NEXT: "line": 15,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 227,
+// CHECK-NEXT: "offset": 216,
// CHECK-NEXT: "line": 12,
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 223,
+// CHECK-NEXT: "offset": 212,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 227,
+// CHECK-NEXT: "offset": 216,
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 230,
+// CHECK-NEXT: "offset": 219,
// CHECK-NEXT: "col": 26,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 258,
+// CHECK-NEXT: "offset": 244,
// CHECK-NEXT: "line": 15,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "ConditionalOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 235,
+// CHECK-NEXT: "offset": 223,
// CHECK-NEXT: "line": 13,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 243,
+// CHECK-NEXT: "offset": 231,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 235,
+// CHECK-NEXT: "offset": 223,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 235,
+// CHECK-NEXT: "offset": 223,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 235,
+// CHECK-NEXT: "offset": 223,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 235,
+// CHECK-NEXT: "offset": 223,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 239,
+// CHECK-NEXT: "offset": 227,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 239,
+// CHECK-NEXT: "offset": 227,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 243,
+// CHECK-NEXT: "offset": 231,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 243,
+// CHECK-NEXT: "offset": 231,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "kind": "BinaryConditionalOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "line": 14,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 254,
+// CHECK-NEXT: "offset": 241,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "OpaqueValueExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "OpaqueValueExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 249,
+// CHECK-NEXT: "offset": 236,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 254,
+// CHECK-NEXT: "offset": 241,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 254,
+// CHECK-NEXT: "offset": 241,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 268,
+// CHECK-NEXT: "offset": 252,
// CHECK-NEXT: "line": 17,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 15
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 263,
+// CHECK-NEXT: "offset": 247,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 686,
+// CHECK-NEXT: "offset": 638,
// CHECK-NEXT: "line": 49,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 288,
+// CHECK-NEXT: "offset": 272,
// CHECK-NEXT: "line": 17,
// CHECK-NEXT: "col": 26,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 284,
+// CHECK-NEXT: "offset": 268,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 288,
+// CHECK-NEXT: "offset": 272,
// CHECK-NEXT: "col": 26,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 295,
+// CHECK-NEXT: "offset": 279,
// CHECK-NEXT: "col": 33,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 291,
+// CHECK-NEXT: "offset": 275,
// CHECK-NEXT: "col": 29,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 295,
+// CHECK-NEXT: "offset": 279,
// CHECK-NEXT: "col": 33,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 298,
+// CHECK-NEXT: "offset": 282,
// CHECK-NEXT: "col": 36,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 686,
+// CHECK-NEXT: "offset": 638,
// CHECK-NEXT: "line": 49,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 327,
+// CHECK-NEXT: "offset": 309,
// CHECK-NEXT: "line": 19,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 332,
+// CHECK-NEXT: "offset": 314,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "||",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 327,
+// CHECK-NEXT: "offset": 309,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 327,
+// CHECK-NEXT: "offset": 309,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 327,
+// CHECK-NEXT: "offset": 309,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 327,
+// CHECK-NEXT: "offset": 309,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 332,
+// CHECK-NEXT: "offset": 314,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 332,
+// CHECK-NEXT: "offset": 314,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 332,
+// CHECK-NEXT: "offset": 314,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 332,
+// CHECK-NEXT: "offset": 314,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 338,
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "line": 20,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 343,
+// CHECK-NEXT: "offset": 324,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "&&",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 338,
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 338,
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 338,
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 338,
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 343,
+// CHECK-NEXT: "offset": 324,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 343,
+// CHECK-NEXT: "offset": 324,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 343,
+// CHECK-NEXT: "offset": 324,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 343,
+// CHECK-NEXT: "offset": 324,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 375,
+// CHECK-NEXT: "offset": 353,
// CHECK-NEXT: "line": 23,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 379,
+// CHECK-NEXT: "offset": 357,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "|",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 375,
+// CHECK-NEXT: "offset": 353,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 375,
+// CHECK-NEXT: "offset": 353,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 375,
+// CHECK-NEXT: "offset": 353,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 375,
+// CHECK-NEXT: "offset": 353,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 379,
+// CHECK-NEXT: "offset": 357,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 379,
+// CHECK-NEXT: "offset": 357,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 379,
+// CHECK-NEXT: "offset": 357,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 379,
+// CHECK-NEXT: "offset": 357,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 385,
+// CHECK-NEXT: "offset": 362,
// CHECK-NEXT: "line": 24,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 389,
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "^",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 385,
+// CHECK-NEXT: "offset": 362,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 385,
+// CHECK-NEXT: "offset": 362,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 385,
+// CHECK-NEXT: "offset": 362,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 385,
+// CHECK-NEXT: "offset": 362,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 389,
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 389,
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 389,
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 389,
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 395,
+// CHECK-NEXT: "offset": 371,
// CHECK-NEXT: "line": 25,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 399,
+// CHECK-NEXT: "offset": 375,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "&",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 395,
+// CHECK-NEXT: "offset": 371,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 395,
+// CHECK-NEXT: "offset": 371,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 395,
+// CHECK-NEXT: "offset": 371,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 395,
+// CHECK-NEXT: "offset": 371,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 399,
+// CHECK-NEXT: "offset": 375,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 399,
+// CHECK-NEXT: "offset": 375,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 399,
+// CHECK-NEXT: "offset": 375,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 399,
+// CHECK-NEXT: "offset": 375,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 432,
+// CHECK-NEXT: "offset": 405,
// CHECK-NEXT: "line": 28,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 437,
+// CHECK-NEXT: "offset": 410,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "==",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 432,
+// CHECK-NEXT: "offset": 405,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 432,
+// CHECK-NEXT: "offset": 405,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 432,
+// CHECK-NEXT: "offset": 405,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 432,
+// CHECK-NEXT: "offset": 405,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 437,
+// CHECK-NEXT: "offset": 410,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 437,
+// CHECK-NEXT: "offset": 410,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 437,
+// CHECK-NEXT: "offset": 410,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 437,
+// CHECK-NEXT: "offset": 410,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 443,
+// CHECK-NEXT: "offset": 415,
// CHECK-NEXT: "line": 29,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 448,
+// CHECK-NEXT: "offset": 420,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "!=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 443,
+// CHECK-NEXT: "offset": 415,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 443,
+// CHECK-NEXT: "offset": 415,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 443,
+// CHECK-NEXT: "offset": 415,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 443,
+// CHECK-NEXT: "offset": 415,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 448,
+// CHECK-NEXT: "offset": 420,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 448,
+// CHECK-NEXT: "offset": 420,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 448,
+// CHECK-NEXT: "offset": 420,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 448,
+// CHECK-NEXT: "offset": 420,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 483,
+// CHECK-NEXT: "offset": 452,
// CHECK-NEXT: "line": 32,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 487,
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "<",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 483,
+// CHECK-NEXT: "offset": 452,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 483,
+// CHECK-NEXT: "offset": 452,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 483,
+// CHECK-NEXT: "offset": 452,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 483,
+// CHECK-NEXT: "offset": 452,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 487,
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 487,
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 487,
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 487,
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 493,
+// CHECK-NEXT: "offset": 461,
// CHECK-NEXT: "line": 33,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 497,
+// CHECK-NEXT: "offset": 465,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ">",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 493,
+// CHECK-NEXT: "offset": 461,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 493,
+// CHECK-NEXT: "offset": 461,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 493,
+// CHECK-NEXT: "offset": 461,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 493,
+// CHECK-NEXT: "offset": 461,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 497,
+// CHECK-NEXT: "offset": 465,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 497,
+// CHECK-NEXT: "offset": 465,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 497,
+// CHECK-NEXT: "offset": 465,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 497,
+// CHECK-NEXT: "offset": 465,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 503,
+// CHECK-NEXT: "offset": 470,
// CHECK-NEXT: "line": 34,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 508,
+// CHECK-NEXT: "offset": 475,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "<=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 503,
+// CHECK-NEXT: "offset": 470,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 503,
+// CHECK-NEXT: "offset": 470,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 503,
+// CHECK-NEXT: "offset": 470,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 503,
+// CHECK-NEXT: "offset": 470,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 508,
+// CHECK-NEXT: "offset": 475,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 508,
+// CHECK-NEXT: "offset": 475,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 508,
+// CHECK-NEXT: "offset": 475,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 508,
+// CHECK-NEXT: "offset": 475,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 514,
+// CHECK-NEXT: "offset": 480,
// CHECK-NEXT: "line": 35,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 519,
+// CHECK-NEXT: "offset": 485,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ">=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 514,
+// CHECK-NEXT: "offset": 480,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 514,
+// CHECK-NEXT: "offset": 480,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 514,
+// CHECK-NEXT: "offset": 480,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 514,
+// CHECK-NEXT: "offset": 480,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 519,
+// CHECK-NEXT: "offset": 485,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 519,
+// CHECK-NEXT: "offset": 485,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 519,
+// CHECK-NEXT: "offset": 485,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 519,
+// CHECK-NEXT: "offset": 485,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 556,
+// CHECK-NEXT: "offset": 519,
// CHECK-NEXT: "line": 38,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 561,
+// CHECK-NEXT: "offset": 524,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "<<",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 556,
+// CHECK-NEXT: "offset": 519,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 556,
+// CHECK-NEXT: "offset": 519,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 556,
+// CHECK-NEXT: "offset": 519,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 556,
+// CHECK-NEXT: "offset": 519,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 561,
+// CHECK-NEXT: "offset": 524,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 561,
+// CHECK-NEXT: "offset": 524,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 561,
+// CHECK-NEXT: "offset": 524,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 561,
+// CHECK-NEXT: "offset": 524,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 567,
+// CHECK-NEXT: "offset": 529,
// CHECK-NEXT: "line": 39,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 572,
+// CHECK-NEXT: "offset": 534,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ">>",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 567,
+// CHECK-NEXT: "offset": 529,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 567,
+// CHECK-NEXT: "offset": 529,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 567,
+// CHECK-NEXT: "offset": 529,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 567,
+// CHECK-NEXT: "offset": 529,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 572,
+// CHECK-NEXT: "offset": 534,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 572,
+// CHECK-NEXT: "offset": 534,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 572,
+// CHECK-NEXT: "offset": 534,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 572,
+// CHECK-NEXT: "offset": 534,
// CHECK-NEXT: "col": 8,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 605,
+// CHECK-NEXT: "offset": 564,
// CHECK-NEXT: "line": 42,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 609,
+// CHECK-NEXT: "offset": 568,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 605,
+// CHECK-NEXT: "offset": 564,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 605,
+// CHECK-NEXT: "offset": 564,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 605,
+// CHECK-NEXT: "offset": 564,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 605,
+// CHECK-NEXT: "offset": 564,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 609,
+// CHECK-NEXT: "offset": 568,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 609,
+// CHECK-NEXT: "offset": 568,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 609,
+// CHECK-NEXT: "offset": 568,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 609,
+// CHECK-NEXT: "offset": 568,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 615,
+// CHECK-NEXT: "offset": 573,
// CHECK-NEXT: "line": 43,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 619,
+// CHECK-NEXT: "offset": 577,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 615,
+// CHECK-NEXT: "offset": 573,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 615,
+// CHECK-NEXT: "offset": 573,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 615,
+// CHECK-NEXT: "offset": 573,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 615,
+// CHECK-NEXT: "offset": 573,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 619,
+// CHECK-NEXT: "offset": 577,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 619,
+// CHECK-NEXT: "offset": 577,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 619,
+// CHECK-NEXT: "offset": 577,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 619,
+// CHECK-NEXT: "offset": 577,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 658,
+// CHECK-NEXT: "offset": 613,
// CHECK-NEXT: "line": 46,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 662,
+// CHECK-NEXT: "offset": 617,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "*",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 658,
+// CHECK-NEXT: "offset": 613,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 658,
+// CHECK-NEXT: "offset": 613,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 658,
+// CHECK-NEXT: "offset": 613,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 658,
+// CHECK-NEXT: "offset": 613,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 662,
+// CHECK-NEXT: "offset": 617,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 662,
+// CHECK-NEXT: "offset": 617,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 662,
+// CHECK-NEXT: "offset": 617,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 662,
+// CHECK-NEXT: "offset": 617,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 668,
+// CHECK-NEXT: "offset": 622,
// CHECK-NEXT: "line": 47,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 672,
+// CHECK-NEXT: "offset": 626,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "/",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 668,
+// CHECK-NEXT: "offset": 622,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 668,
+// CHECK-NEXT: "offset": 622,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 668,
+// CHECK-NEXT: "offset": 622,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 668,
+// CHECK-NEXT: "offset": 622,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 672,
+// CHECK-NEXT: "offset": 626,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 672,
+// CHECK-NEXT: "offset": 626,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 672,
+// CHECK-NEXT: "offset": 626,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 672,
+// CHECK-NEXT: "offset": 626,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 678,
+// CHECK-NEXT: "offset": 631,
// CHECK-NEXT: "line": 48,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 682,
+// CHECK-NEXT: "offset": 635,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "%",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 678,
+// CHECK-NEXT: "offset": 631,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 678,
+// CHECK-NEXT: "offset": 631,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 678,
+// CHECK-NEXT: "offset": 631,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 678,
+// CHECK-NEXT: "offset": 631,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 682,
+// CHECK-NEXT: "offset": 635,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 682,
+// CHECK-NEXT: "offset": 635,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 682,
+// CHECK-NEXT: "offset": 635,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 682,
+// CHECK-NEXT: "offset": 635,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 696,
+// CHECK-NEXT: "offset": 646,
// CHECK-NEXT: "line": 51,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 691,
+// CHECK-NEXT: "offset": 641,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 894,
+// CHECK-NEXT: "offset": 829,
// CHECK-NEXT: "line": 66,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 715,
+// CHECK-NEXT: "offset": 665,
// CHECK-NEXT: "line": 51,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 711,
+// CHECK-NEXT: "offset": 661,
// CHECK-NEXT: "col": 21,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 715,
+// CHECK-NEXT: "offset": 665,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 723,
+// CHECK-NEXT: "offset": 673,
// CHECK-NEXT: "col": 33,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 718,
+// CHECK-NEXT: "offset": 668,
// CHECK-NEXT: "col": 28,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 723,
+// CHECK-NEXT: "offset": 673,
// CHECK-NEXT: "col": 33,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 726,
+// CHECK-NEXT: "offset": 676,
// CHECK-NEXT: "col": 36,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 894,
+// CHECK-NEXT: "offset": 829,
// CHECK-NEXT: "line": 66,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 752,
+// CHECK-NEXT: "offset": 700,
// CHECK-NEXT: "line": 53,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 759,
+// CHECK-NEXT: "offset": 707,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToFloating",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 759,
+// CHECK-NEXT: "offset": 707,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 759,
+// CHECK-NEXT: "offset": 707,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 759,
+// CHECK-NEXT: "offset": 707,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 759,
+// CHECK-NEXT: "offset": 707,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 812,
+// CHECK-NEXT: "offset": 756,
// CHECK-NEXT: "line": 57,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 813,
+// CHECK-NEXT: "offset": 757,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 813,
+// CHECK-NEXT: "offset": 757,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 813,
+// CHECK-NEXT: "offset": 757,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 813,
+// CHECK-NEXT: "offset": 757,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 813,
+// CHECK-NEXT: "offset": 757,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 819,
+// CHECK-NEXT: "offset": 762,
// CHECK-NEXT: "line": 58,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 820,
+// CHECK-NEXT: "offset": 763,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 820,
+// CHECK-NEXT: "offset": 763,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 820,
+// CHECK-NEXT: "offset": 763,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 820,
+// CHECK-NEXT: "offset": 763,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 820,
+// CHECK-NEXT: "offset": 763,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 826,
+// CHECK-NEXT: "offset": 768,
// CHECK-NEXT: "line": 59,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 827,
+// CHECK-NEXT: "offset": 769,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "&",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 827,
+// CHECK-NEXT: "offset": 769,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 827,
+// CHECK-NEXT: "offset": 769,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 833,
+// CHECK-NEXT: "offset": 774,
// CHECK-NEXT: "line": 60,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 833,
+// CHECK-NEXT: "offset": 774,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 834,
+// CHECK-NEXT: "offset": 775,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 840,
+// CHECK-NEXT: "offset": 780,
// CHECK-NEXT: "line": 61,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 841,
+// CHECK-NEXT: "offset": 781,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "!",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 841,
+// CHECK-NEXT: "offset": 781,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 841,
+// CHECK-NEXT: "offset": 781,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 841,
+// CHECK-NEXT: "offset": 781,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 841,
+// CHECK-NEXT: "offset": 781,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryExprOrTypeTraitExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 849,
+// CHECK-NEXT: "offset": 787,
// CHECK-NEXT: "line": 63,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 856,
+// CHECK-NEXT: "offset": 794,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "sizeof",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 856,
+// CHECK-NEXT: "offset": 794,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 856,
+// CHECK-NEXT: "offset": 794,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "UnaryExprOrTypeTraitExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 862,
+// CHECK-NEXT: "offset": 799,
// CHECK-NEXT: "line": 64,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 872,
+// CHECK-NEXT: "offset": 809,
// CHECK-NEXT: "col": 13,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "sizeof",
// CHECK-NEXT: "argType": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: "kind": "UnaryExprOrTypeTraitExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 878,
+// CHECK-NEXT: "offset": 814,
// CHECK-NEXT: "line": 65,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 8
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 890,
+// CHECK-NEXT: "offset": 826,
// CHECK-NEXT: "col": 15,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "alignof",
// CHECK-NEXT: "argType": {
// CHECK-NEXT: "qualType": "int"
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 932,
+// CHECK-NEXT: "offset": 861,
// CHECK-NEXT: "line": 72,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 16
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 927,
+// CHECK-NEXT: "offset": 856,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1136,
+// CHECK-NEXT: "offset": 1054,
// CHECK-NEXT: "line": 83,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 954,
+// CHECK-NEXT: "offset": 883,
// CHECK-NEXT: "line": 72,
// CHECK-NEXT: "col": 28,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 949,
+// CHECK-NEXT: "offset": 878,
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 954,
+// CHECK-NEXT: "offset": 883,
// CHECK-NEXT: "col": 28,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 966,
+// CHECK-NEXT: "offset": 895,
// CHECK-NEXT: "col": 40,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 957,
+// CHECK-NEXT: "offset": 886,
// CHECK-NEXT: "col": 31,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 966,
+// CHECK-NEXT: "offset": 895,
// CHECK-NEXT: "col": 40,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 979,
+// CHECK-NEXT: "offset": 908,
// CHECK-NEXT: "col": 53,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 969,
+// CHECK-NEXT: "offset": 898,
// CHECK-NEXT: "col": 43,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 979,
+// CHECK-NEXT: "offset": 908,
// CHECK-NEXT: "col": 53,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 982,
+// CHECK-NEXT: "offset": 911,
// CHECK-NEXT: "col": 56,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1136,
+// CHECK-NEXT: "offset": 1054,
// CHECK-NEXT: "line": 83,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "line": 73,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 990,
+// CHECK-NEXT: "offset": 918,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ArraySubscriptExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 990,
+// CHECK-NEXT: "offset": 918,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 987,
+// CHECK-NEXT: "offset": 915,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 989,
+// CHECK-NEXT: "offset": 917,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 989,
+// CHECK-NEXT: "offset": 917,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "kind": "CallExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 996,
+// CHECK-NEXT: "offset": 923,
// CHECK-NEXT: "line": 74,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1016,
+// CHECK-NEXT: "offset": 943,
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 996,
+// CHECK-NEXT: "offset": 923,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 996,
+// CHECK-NEXT: "offset": 923,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(int, int *)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 996,
+// CHECK-NEXT: "offset": 923,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 996,
+// CHECK-NEXT: "offset": 923,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 14
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (int, int *)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FunctionDecl",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1011,
+// CHECK-NEXT: "offset": 938,
// CHECK-NEXT: "col": 18,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "UnaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1011,
+// CHECK-NEXT: "offset": 938,
// CHECK-NEXT: "col": 18,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1012,
+// CHECK-NEXT: "offset": 939,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1015,
+// CHECK-NEXT: "offset": 942,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1015,
+// CHECK-NEXT: "offset": 942,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1015,
+// CHECK-NEXT: "offset": 942,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1015,
+// CHECK-NEXT: "offset": 942,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1024,
+// CHECK-NEXT: "offset": 949,
// CHECK-NEXT: "line": 76,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1026,
+// CHECK-NEXT: "offset": 951,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "MemberExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1024,
+// CHECK-NEXT: "offset": 949,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1026,
+// CHECK-NEXT: "offset": 951,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1024,
+// CHECK-NEXT: "offset": 949,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1024,
+// CHECK-NEXT: "offset": 949,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "line": 77,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1035,
+// CHECK-NEXT: "offset": 959,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "MemberExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1035,
+// CHECK-NEXT: "offset": 959,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "struct S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1032,
+// CHECK-NEXT: "offset": 956,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1092,
+// CHECK-NEXT: "offset": 1012,
// CHECK-NEXT: "line": 81,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1114,
+// CHECK-NEXT: "offset": 1034,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "CompoundLiteralExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1092,
+// CHECK-NEXT: "offset": 1012,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1114,
+// CHECK-NEXT: "offset": 1034,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "InitListExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1101,
+// CHECK-NEXT: "offset": 1021,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1114,
+// CHECK-NEXT: "offset": 1034,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int [4]"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1102,
+// CHECK-NEXT: "offset": 1022,
// CHECK-NEXT: "col": 13,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1102,
+// CHECK-NEXT: "offset": 1022,
// CHECK-NEXT: "col": 13,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1105,
+// CHECK-NEXT: "offset": 1025,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1105,
+// CHECK-NEXT: "offset": 1025,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1108,
+// CHECK-NEXT: "offset": 1028,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1108,
+// CHECK-NEXT: "offset": 1028,
// CHECK-NEXT: "col": 19,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "3"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1111,
+// CHECK-NEXT: "offset": 1031,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1111,
+// CHECK-NEXT: "offset": 1031,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "4"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1120,
+// CHECK-NEXT: "offset": 1039,
// CHECK-NEXT: "line": 82,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1132,
+// CHECK-NEXT: "offset": 1051,
// CHECK-NEXT: "col": 15,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "desugaredQualType": "struct S",
// CHECK-NEXT: "qualType": "struct S"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "CompoundLiteralExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1120,
+// CHECK-NEXT: "offset": 1039,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1132,
+// CHECK-NEXT: "offset": 1051,
// CHECK-NEXT: "col": 15,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "InitListExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1130,
+// CHECK-NEXT: "offset": 1049,
// CHECK-NEXT: "col": 13,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1132,
+// CHECK-NEXT: "offset": 1051,
// CHECK-NEXT: "col": 15,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "desugaredQualType": "struct S",
// CHECK-NEXT: "qualType": "struct S"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1131,
+// CHECK-NEXT: "offset": 1050,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1131,
+// CHECK-NEXT: "offset": 1050,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 1165,
+// CHECK-NEXT: "offset": 1079,
// CHECK-NEXT: "line": 87,
// CHECK-NEXT: "col": 6,
// CHECK-NEXT: "tokLen": 18
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1160,
+// CHECK-NEXT: "offset": 1074,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1360,
+// CHECK-NEXT: "offset": 1254,
// CHECK-NEXT: "line": 107,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": 1188,
+// CHECK-NEXT: "offset": 1102,
// CHECK-NEXT: "line": 87,
// CHECK-NEXT: "col": 29,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1184,
+// CHECK-NEXT: "offset": 1098,
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1188,
+// CHECK-NEXT: "offset": 1102,
// CHECK-NEXT: "col": 29,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1191,
+// CHECK-NEXT: "offset": 1105,
// CHECK-NEXT: "col": 32,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1360,
+// CHECK-NEXT: "offset": 1254,
// CHECK-NEXT: "line": 107,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1196,
+// CHECK-NEXT: "offset": 1109,
// CHECK-NEXT: "line": 88,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1196,
+// CHECK-NEXT: "offset": 1109,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1196,
+// CHECK-NEXT: "offset": 1109,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1196,
+// CHECK-NEXT: "offset": 1109,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "CharacterLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1202,
+// CHECK-NEXT: "offset": 1114,
// CHECK-NEXT: "line": 89,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1202,
+// CHECK-NEXT: "offset": 1114,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": 97
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "CharacterLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1210,
+// CHECK-NEXT: "offset": 1121,
// CHECK-NEXT: "line": 90,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1210,
+// CHECK-NEXT: "offset": 1121,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": 97
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1219,
+// CHECK-NEXT: "offset": 1129,
// CHECK-NEXT: "line": 91,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1219,
+// CHECK-NEXT: "offset": 1129,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "StringLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1219,
+// CHECK-NEXT: "offset": 1129,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1219,
+// CHECK-NEXT: "offset": 1129,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1227,
+// CHECK-NEXT: "offset": 1136,
// CHECK-NEXT: "line": 92,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1227,
+// CHECK-NEXT: "offset": 1136,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "StringLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1227,
+// CHECK-NEXT: "offset": 1136,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1227,
+// CHECK-NEXT: "offset": 1136,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1236,
+// CHECK-NEXT: "offset": 1144,
// CHECK-NEXT: "line": 93,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 5
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1236,
+// CHECK-NEXT: "offset": 1144,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 5
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "StringLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1236,
+// CHECK-NEXT: "offset": 1144,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 5
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1236,
+// CHECK-NEXT: "offset": 1144,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 5
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1246,
+// CHECK-NEXT: "offset": 1153,
// CHECK-NEXT: "line": 94,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1246,
+// CHECK-NEXT: "offset": 1153,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "StringLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1246,
+// CHECK-NEXT: "offset": 1153,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1246,
+// CHECK-NEXT: "offset": 1153,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1255,
+// CHECK-NEXT: "offset": 1161,
// CHECK-NEXT: "line": 95,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1255,
+// CHECK-NEXT: "offset": 1161,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned short *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "StringLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1255,
+// CHECK-NEXT: "offset": 1161,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1255,
+// CHECK-NEXT: "offset": 1161,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1266,
+// CHECK-NEXT: "offset": 1170,
// CHECK-NEXT: "line": 97,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1266,
+// CHECK-NEXT: "offset": 1170,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1272,
+// CHECK-NEXT: "offset": 1175,
// CHECK-NEXT: "line": 98,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1272,
+// CHECK-NEXT: "offset": 1175,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1279,
+// CHECK-NEXT: "offset": 1181,
// CHECK-NEXT: "line": 99,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1279,
+// CHECK-NEXT: "offset": 1181,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "long long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "FloatingLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1287,
+// CHECK-NEXT: "offset": 1188,
// CHECK-NEXT: "line": 100,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1287,
+// CHECK-NEXT: "offset": 1188,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "double"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "FloatingLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1295,
+// CHECK-NEXT: "offset": 1195,
// CHECK-NEXT: "line": 101,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1295,
+// CHECK-NEXT: "offset": 1195,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "FloatingLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1304,
+// CHECK-NEXT: "offset": 1203,
// CHECK-NEXT: "line": 102,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 26
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1304,
+// CHECK-NEXT: "offset": 1203,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 26
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "+Inf"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "FloatingLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1335,
+// CHECK-NEXT: "offset": 1233,
// CHECK-NEXT: "line": 103,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1335,
+// CHECK-NEXT: "offset": 1233,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 4
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "long double"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1344,
+// CHECK-NEXT: "offset": 1241,
// CHECK-NEXT: "line": 104,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1344,
+// CHECK-NEXT: "offset": 1241,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 3
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "EnumConstantDecl",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1354,
+// CHECK-NEXT: "offset": 1249,
// CHECK-NEXT: "line": 106,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1356,
+// CHECK-NEXT: "offset": 1251,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "kind": "ParenExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1354,
+// CHECK-NEXT: "offset": 1249,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1356,
+// CHECK-NEXT: "offset": 1251,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": 1355,
+// CHECK-NEXT: "offset": 1250,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": 1355,
+// CHECK-NEXT: "offset": 1250,
// CHECK-NEXT: "col": 4,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 952,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 995,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int S::*"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int S::*"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": ".*",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (S::*)(int)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "->*",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (S::*)(int)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1149,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const T *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BaseToDerived",
// CHECK-NEXT: "path": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const T *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "Dynamic",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BitCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1326,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "Ts"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isGlobal": true,
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FunctionDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "initStyle": "list",
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isArray": true,
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isArray": true,
// CHECK-NEXT: "initStyle": "list",
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int [2]"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPlacement": true,
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BitCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPlacement": true,
// CHECK-NEXT: "initStyle": "list",
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BitCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isGlobal": true,
// CHECK-NEXT: "operatorDeleteDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isArray": true,
// CHECK-NEXT: "isArrayAsWritten": true,
// CHECK-NEXT: "operatorDeleteDecl": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1541,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "func",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "func",
// CHECK-NEXT: "isArrow": true,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "desugaredQualType": "int",
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "foo",
// CHECK-NEXT: "isArrow": true,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "float",
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "foo",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "~S",
// CHECK-NEXT: "isArrow": true,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "~S",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "~S",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "~S",
// CHECK-NEXT: "isArrow": true,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "~U",
// CHECK-NEXT: "isArrow": true,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "U<int> *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1841,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "V *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:98:7)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NULL TYPE"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "V *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:99:7)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NULL TYPE"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "*",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "V *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:105:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:106:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:107:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NULL TYPE"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:108:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:109:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:110:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:111:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:112:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:113:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NULL TYPE"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:114:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:115:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:116:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "(lambda at {{.*}}:117:3)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {},
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {},
// CHECK-NEXT: {},
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {},
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2336,
// CHECK-NEXT: "desugaredQualType": "NS::X",
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void () noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "adl": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(NS::X)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "adl": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(...)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "NS::X",
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2387,
// CHECK-NEXT: "desugaredQualType": "NS::X",
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void () noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(NS::X)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2437,
// CHECK-NEXT: "desugaredQualType": "NS::X",
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void () noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(NS::X)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "adl": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(...)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "NS::X",
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2559,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void () noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(NS::X)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NS::X"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void (const NS::X &) noexcept"
// CHECK-NEXT: },
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1506,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1574,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "method1",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "I *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "method2",
// CHECK-NEXT: "receiverKind": "class",
// CHECK-NEXT: "classType": {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1640,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSNumber *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "numberWithInt:",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1678,
// CHECK-NEXT: "qualType": "SEL",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "dealloc"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1737,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "conformsToProtocol:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "Protocol *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "protocol": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ObjCProtocolDecl",
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1817,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "setProp:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "prop",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "J *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1892,
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "setObject:atIndexedSubscript:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "objectAtIndexedSubscript:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableArray *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "setObject:forKeyedSubscript:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NullToPointer",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BitCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "selector": "objectForKeyedSubscript:",
// CHECK-NEXT: "receiverKind": "instance",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSMutableDictionary *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "BitCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "NSString *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2060,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "I *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 2113,
// CHECK-NEXT: "qualType": "BOOL",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "__objc_yes"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "BOOL",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "__objc_no"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXMethodDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 232,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXMethodDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 271,
// CHECK-NEXT: "pure": true
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXMethodDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 343,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "100"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXMethodDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 399,
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 504,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 545,
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=IfStmt
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "true",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "==",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "id",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "cleanupsHaveSideEffects": true,
// CHECK-NEXT: "cleanups": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1675,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1725,
// CHECK-NEXT: "tagUsed": "struct"
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 123,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 206,
// CHECK-NEXT: "tagUsed": "union"
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 388,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXRecordDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 470,
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=VarDecl,CompoundStmt
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 99,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 121,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "VarDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 198,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": true,
// CHECK-NEXT: "opcode": "++",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": true,
// CHECK-NEXT: "opcode": "++",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "~",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "~",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "100"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "label1",
// CHECK-NEXT: "labelDeclId": "0x{{.*}}"
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "3"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "5"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "<",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "++",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "!",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "!",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "_Bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(int)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (int)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FunctionDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 198,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)()"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "&",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "4"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 266,
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 378,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FunctionDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "operatorDeleteDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FunctionDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isArray": true,
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "2"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isArray": true,
// CHECK-NEXT: "isArrayAsWritten": true,
// CHECK-NEXT: "operatorDeleteDecl": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isGlobal": true,
// CHECK-NEXT: "operatorNewDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isGlobal": true,
// CHECK-NEXT: "operatorDeleteDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {},
// CHECK-NEXT: "range": {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 598,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 766,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "list": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "isPostfix": false,
// CHECK-NEXT: "opcode": "&",
// CHECK-NEXT: "canOverflow": false,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1049,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue"
+// CHECK-NEXT: "valueCategory": "prvalue"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1214,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "U [3]"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "array_filler": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "U"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "field": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FieldDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "U"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "field": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "FieldDecl",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1261,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1315,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "12"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "true",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "==",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "sizeof",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "true",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "==",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "sizeof",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1529,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToBoolean",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "!=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "Container"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void () noexcept"
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "begin",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<bound member function type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "end",
// CHECK-NEXT: "isArrow": false,
// CHECK-NEXT: "referencedMemberDecl": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "!=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "ArrayToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "10"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "bool"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "!=",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "desugaredQualType": "int *",
// CHECK-NEXT: "qualType": "int *"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionTemplateDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 1737,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "resultDependent": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "<dependent type>"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "resultDependent": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 143,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(void)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "cleanupsHaveSideEffects": true,
// CHECK-NEXT: "cleanups": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(void)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 185,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(void)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "cleanupsHaveSideEffects": true,
// CHECK-NEXT: "cleanups": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (^)(void)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "FunctionDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 252,
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
-
// CHECK: "kind": "TranslationUnitDecl",
// CHECK-NEXT: "loc": {},
// CHECK-NEXT: "range": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "NonTypeTemplateParmDecl",
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=ExprWithCleanups
-
// CHECK: "kind": "ExprWithCleanups",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const S"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "temp": "0x{{.*}}",
// CHECK-NEXT: "dtor": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "S"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "ctorType": {
// CHECK-NEXT: "qualType": "void ()"
// CHECK-NEXT: },
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ExprWithCleanups",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FloatingToIntegral",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "double"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "1"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ExprWithCleanups",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "void (*)(const int &)"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FunctionToPointerDecay",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "const int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "FloatingToIntegral",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
using TestContainsErrors = int[sizeof(undef())];
-
// CHECK: "kind": "TypeAliasDecl",
// CHECK-NEXT: "loc": {
// CHECK-NEXT: "offset": 130,
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned long"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "name": "sizeof",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=ImplicitCastExpr,CStyleCastExpr
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=ImplicitCastExpr,CStyleCastExpr,CXXStaticCastExpr,CXXFunctionalCastExpr
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXStaticCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXStaticCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXStaticCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXStaticCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXFunctionalCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "qualType": "UnsignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "UnsignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "qualType": "UnsignedInt",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXFunctionalCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "qualType": "SignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "SignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "qualType": "UnsignedInt",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXFunctionalCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "qualType": "UnsignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "UnsignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "qualType": "SignedInt",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
// CHECK: "kind": "CXXFunctionalCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "qualType": "SignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "NoOp",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "qualType": "SignedChar",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: "qualType": "SignedInt",
// CHECK-NEXT: "typeAliasDeclId": "0x{{.*}}"
// CHECK-NEXT: },
-// CHECK-NEXT: "valueCategory": "rvalue",
+// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [