Index: include/clang/Sema/Ownership.h =================================================================== --- include/clang/Sema/Ownership.h +++ include/clang/Sema/Ownership.h @@ -161,10 +161,7 @@ bool isUnset() const { return !Invalid && !Val; } PtrTy get() const { return Val; } - // FIXME: Replace with get. - PtrTy release() const { return Val; } - PtrTy take() const { return Val; } - template T *takeAs() { return static_cast(get()); } + template T *getAs() { return static_cast(get()); } void set(PtrTy V) { Val = V; } @@ -206,10 +203,7 @@ void *VP = reinterpret_cast(PtrWithInvalid & ~0x01); return PtrTraits::getFromVoidPointer(VP); } - // FIXME: Replace with get. - PtrTy take() const { return get(); } - PtrTy release() const { return get(); } - template T *takeAs() { return static_cast(get()); } + template T *getAs() { return static_cast(get()); } void set(PtrTy V) { void *VP = PtrTraits::getAsVoidPointer(V); Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -2950,13 +2950,13 @@ return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation()); } FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) { - return FullExprArg(ActOnFinishFullExpr(Arg, CC).release()); + return FullExprArg(ActOnFinishFullExpr(Arg, CC).get()); } FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) { ExprResult FE = ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(), /*DiscardedValue*/ true); - return FullExprArg(FE.release()); + return FullExprArg(FE.get()); } StmtResult ActOnExprStmt(ExprResult Arg); @@ -3932,7 +3932,7 @@ /// potential exceptions of the special member function contains "any" EPI.ExceptionSpecType = EST_ComputedNoexcept; EPI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(), - tok::kw_false).take(); + tok::kw_false).get(); } } FunctionProtoType::ExtProtoInfo getEPI() const { @@ -7692,7 +7692,7 @@ QualType FindCompositePointerType(SourceLocation Loc, ExprResult &E1, ExprResult &E2, bool *NonStandardCompositeType = nullptr) { - Expr *E1Tmp = E1.take(), *E2Tmp = E2.take(); + Expr *E1Tmp = E1.get(), *E2Tmp = E2.get(); QualType Composite = FindCompositePointerType(Loc, E1Tmp, E2Tmp, NonStandardCompositeType); E1 = Owned(E1Tmp); Index: lib/Parse/ParseCXXInlineMethods.cpp =================================================================== --- lib/Parse/ParseCXXInlineMethods.cpp +++ lib/Parse/ParseCXXInlineMethods.cpp @@ -349,7 +349,7 @@ (*Toks)[Toks->size() - 3].getLocation()); } Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc, - DefArgResult.take()); + DefArgResult.get()); } assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, @@ -535,7 +535,7 @@ EqualLoc); Actions.ActOnFinishCXXInClassMemberInitializer(MI.Field, EqualLoc, - Init.release()); + Init.get()); // The next token should be our artificial terminating EOF token. if (Tok.isNot(tok::eof)) { Index: lib/Parse/ParseDecl.cpp =================================================================== --- lib/Parse/ParseDecl.cpp +++ lib/Parse/ParseDecl.cpp @@ -304,7 +304,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return 0; } - ArgExprs.push_back(ArgExpr.release()); + ArgExprs.push_back(ArgExpr.get()); // Eat the comma, move to the next argument } while (TryConsumeToken(tok::comma)); } @@ -906,7 +906,7 @@ Changes[Introduced], Changes[Deprecated], Changes[Obsoleted], - UnavailableLoc, MessageExpr.take(), + UnavailableLoc, MessageExpr.get(), AttributeList::AS_GNU); } @@ -1187,7 +1187,7 @@ if (!T.consumeClose()) { Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, nullptr, AttrNameLoc, - ArgumentKind, MatchingCType.release(), + ArgumentKind, MatchingCType.get(), LayoutCompatible, MustBeNull, AttributeList::AS_GNU); } @@ -1699,7 +1699,7 @@ return true; } - D.setAsmLabel(AsmLabel.release()); + D.setAsmLabel(AsmLabel.get()); D.SetRangeEnd(Loc); } @@ -1857,7 +1857,7 @@ SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch); Actions.ActOnInitializerError(ThisDecl); } else - Actions.AddInitializerToDecl(ThisDecl, Init.take(), + Actions.AddInitializerToDecl(ThisDecl, Init.get(), /*DirectInit=*/false, TypeContainsAuto); } } else if (Tok.is(tok::l_paren)) { @@ -1896,7 +1896,7 @@ ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(), T.getCloseLocation(), Exprs); - Actions.AddInitializerToDecl(ThisDecl, Initializer.take(), + Actions.AddInitializerToDecl(ThisDecl, Initializer.get(), /*DirectInit=*/true, TypeContainsAuto); } } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) && @@ -1919,7 +1919,7 @@ if (Init.isInvalid()) { Actions.ActOnInitializerError(ThisDecl); } else - Actions.AddInitializerToDecl(ThisDecl, Init.take(), + Actions.AddInitializerToDecl(ThisDecl, Init.get(), /*DirectInit=*/true, TypeContainsAuto); } else { @@ -2294,7 +2294,7 @@ *EndLoc = T.getCloseLocation(); ArgsVector ArgExprs; - ArgExprs.push_back(ArgExpr.release()); + ArgExprs.push_back(ArgExpr.get()); Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1, AttributeList::AS_Keyword, EllipsisLoc); } @@ -3261,7 +3261,7 @@ if (Res.isInvalid()) SkipUntil(tok::semi, StopBeforeMatch); else - DeclaratorInfo.BitfieldSize = Res.release(); + DeclaratorInfo.BitfieldSize = Res.get(); } // If attributes exist after the declarator, parse them. @@ -3817,7 +3817,7 @@ LastEnumConstDecl, IdentLoc, Ident, attrs.getList(), EqualLoc, - AssignedVal.release()); + AssignedVal.get()); PD.complete(EnumConstDecl); EnumConstantDecls.push_back(EnumConstDecl); @@ -5435,7 +5435,7 @@ } else { // Inform the actions module about the default argument Actions.ActOnParamDefaultArgument(Param, EqualLoc, - DefArgResult.take()); + DefArgResult.get()); } } } @@ -5497,7 +5497,7 @@ // Remember that we parsed a array type, and remember its features. D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, - ExprRes.release(), + ExprRes.get(), T.getOpenLocation(), T.getCloseLocation()), attrs, T.getCloseLocation()); @@ -5567,7 +5567,7 @@ // Remember that we parsed a array type, and remember its features. D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(), StaticLoc.isValid(), isStar, - NumElements.release(), + NumElements.get(), T.getOpenLocation(), T.getCloseLocation()), attrs, T.getCloseLocation()); @@ -5670,7 +5670,7 @@ const char *PrevSpec = nullptr; unsigned DiagID; if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec, - DiagID, Result.release(), + DiagID, Result.get(), Actions.getASTContext().getPrintingPolicy())) Diag(StartLoc, DiagID) << PrevSpec; } Index: lib/Parse/ParseDeclCXX.cpp =================================================================== --- lib/Parse/ParseDeclCXX.cpp +++ lib/Parse/ParseDeclCXX.cpp @@ -289,7 +289,7 @@ Lang.isInvalid() ? nullptr : Actions.ActOnStartLinkageSpecification( - getCurScope(), DS.getSourceRange().getBegin(), Lang.take(), + getCurScope(), DS.getSourceRange().getBegin(), Lang.get(), Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation()); ParsedAttributesWithRange attrs(AttrFactory); @@ -713,8 +713,8 @@ ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert); return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc, - AssertExpr.take(), - AssertMessage.take(), + AssertExpr.get(), + AssertMessage.get(), T.getCloseLocation()); } @@ -789,7 +789,7 @@ return EndLoc; } - Result = Actions.ActOnDecltypeExpression(Result.take()); + Result = Actions.ActOnDecltypeExpression(Result.get()); } // Match the ')' @@ -816,7 +816,7 @@ // Check for duplicate type specifiers (e.g. "int decltype(a)"). if (Result.get() ? DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec, - DiagID, Result.release(), Policy) + DiagID, Result.get(), Policy) : DS.SetTypeSpecType(DeclSpec::TST_decltype_auto, StartLoc, PrevSpec, DiagID, Policy)) { Diag(StartLoc, DiagID) << PrevSpec; @@ -869,7 +869,7 @@ const char *PrevSpec = nullptr; unsigned DiagID; if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec, - DiagID, Result.release(), + DiagID, Result.get(), Actions.getASTContext().getPrintingPolicy())) Diag(StartLoc, DiagID) << PrevSpec; DS.setTypeofParensRange(T.getRange()); @@ -1939,7 +1939,7 @@ if (AsmLabel.isInvalid()) SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); - DeclaratorInfo.setAsmLabel(AsmLabel.release()); + DeclaratorInfo.setAsmLabel(AsmLabel.get()); DeclaratorInfo.SetRangeEnd(Loc); } @@ -2305,7 +2305,7 @@ ThisDecl = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, DeclaratorInfo, TemplateParams, - BitfieldSize.release(), + BitfieldSize.get(), VS, HasInClassInit); if (VarTemplateDecl *VT = @@ -2893,7 +2893,7 @@ return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II, TemplateTypeTy, DS, IdLoc, - InitList.take(), EllipsisLoc); + InitList.get(), EllipsisLoc); } else if(Tok.is(tok::l_paren)) { BalancedDelimiterTracker T(*this, tok::l_paren); T.consumeOpen(); @@ -3251,15 +3251,15 @@ // parsing an argument list, we need to determine whether this attribute // was allowed to have an argument list (such as [[deprecated]]), and how // many arguments were parsed (so we can diagnose on [[deprecated()]]). - if (Attr->getMaxArgs() && !NumArgs) { - // The attribute was allowed to have arguments, but none were provided - // even though the attribute parsed successfully. This is an error. - // FIXME: This is a good place for a fixit which removes the parens. - Diag(LParenLoc, diag::err_attribute_requires_arguments) << AttrName; - return false; - } else if (!Attr->getMaxArgs()) { - // The attribute parsed successfully, but was not allowed to have any - // arguments. It doesn't matter whether any were provided -- the + if (Attr->getMaxArgs() && !NumArgs) { + // The attribute was allowed to have arguments, but none were provided + // even though the attribute parsed successfully. This is an error. + // FIXME: This is a good place for a fixit which removes the parens. + Diag(LParenLoc, diag::err_attribute_requires_arguments) << AttrName; + return false; + } else if (!Attr->getMaxArgs()) { + // The attribute parsed successfully, but was not allowed to have any + // arguments. It doesn't matter whether any were provided -- the // presence of the argument list (even if empty) is diagnosed. Diag(LParenLoc, diag::err_cxx11_attribute_forbids_arguments) << AttrName; Index: lib/Parse/ParseExpr.cpp =================================================================== --- lib/Parse/ParseExpr.cpp +++ lib/Parse/ParseExpr.cpp @@ -148,7 +148,7 @@ if (!LHS.isInvalid()) LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__, - LHS.take()); + LHS.get()); return ParseRHSOfBinaryExpression(LHS, prec::Comma); } @@ -392,11 +392,11 @@ Actions.getExprRange(RHS.get()).getEnd())); LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(), - OpToken.getKind(), LHS.take(), RHS.take()); + OpToken.getKind(), LHS.get(), RHS.get()); } else LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc, - LHS.take(), TernaryMiddle.take(), - RHS.take()); + LHS.get(), TernaryMiddle.get(), + RHS.get()); } } } @@ -1114,7 +1114,7 @@ if (!Result.isInvalid()) Result = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(), - Result.take(), T.getCloseLocation()); + Result.get(), T.getCloseLocation()); return Result; } @@ -1252,8 +1252,8 @@ SourceLocation RLoc = Tok.getLocation(); if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) { - LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.take(), Loc, - Idx.take(), RLoc); + LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.get(), Loc, + Idx.get(), RLoc); } else LHS = ExprError(); @@ -1343,7 +1343,7 @@ assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&& "Unexpected number of commas!"); - LHS = Actions.ActOnCallExpr(getCurScope(), LHS.take(), Loc, + LHS = Actions.ActOnCallExpr(getCurScope(), LHS.get(), Loc, ArgExprs, Tok.getLocation(), ExecConfig); PT.consumeClose(); @@ -1362,7 +1362,7 @@ ParsedType ObjectType; bool MayBePseudoDestructor = false; if (getLangOpts().CPlusPlus && !LHS.isInvalid()) { - Expr *Base = LHS.take(); + Expr *Base = LHS.get(); const Type* BaseType = Base->getType().getTypePtrOrNull(); if (BaseType && Tok.is(tok::l_paren) && (BaseType->isFunctionType() || @@ -1396,7 +1396,7 @@ } if (MayBePseudoDestructor && !LHS.isInvalid()) { - LHS = ParseCXXPseudoDestructor(LHS.take(), OpLoc, OpKind, SS, + LHS = ParseCXXPseudoDestructor(LHS.get(), OpLoc, OpKind, SS, ObjectType); break; } @@ -1430,7 +1430,7 @@ LHS = ExprError(); if (!LHS.isInvalid()) - LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.take(), OpLoc, + LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.get(), OpLoc, OpKind, SS, TemplateKWLoc, Name, CurParsedObjCImpl ? CurParsedObjCImpl->Dcl : nullptr, @@ -1441,7 +1441,7 @@ case tok::minusminus: // postfix-expression: postfix-expression '--' if (!LHS.isInvalid()) { LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(), - Tok.getKind(), LHS.take()); + Tok.getKind(), LHS.get()); } ConsumeToken(); break; @@ -1653,7 +1653,7 @@ Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(), ExprKind, /*isType=*/false, - Operand.release(), + Operand.get(), CastRange); return Operand; } @@ -1711,7 +1711,7 @@ if (Expr.isInvalid() || Ty.isInvalid()) Res = ExprError(); else - Res = Actions.ActOnVAArg(StartLoc, Expr.take(), Ty.get(), ConsumeParen()); + Res = Actions.ActOnVAArg(StartLoc, Expr.get(), Ty.get(), ConsumeParen()); break; } case tok::kw___builtin_offsetof: { @@ -1773,7 +1773,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return Res; } - Comps.back().U.E = Res.release(); + Comps.back().U.E = Res.get(); ST.consumeClose(); Comps.back().LocEnd = ST.getCloseLocation(); @@ -1824,8 +1824,8 @@ Diag(Tok, diag::err_expected) << tok::r_paren; return ExprError(); } - Res = Actions.ActOnChooseExpr(StartLoc, Cond.take(), Expr1.take(), - Expr2.take(), ConsumeParen()); + Res = Actions.ActOnChooseExpr(StartLoc, Cond.get(), Expr1.get(), + Expr2.get(), ConsumeParen()); break; } case tok::kw___builtin_astype: { @@ -1853,7 +1853,7 @@ return ExprError(); } - Res = Actions.ActOnAsTypeExpr(Expr.take(), DestTy.get(), StartLoc, + Res = Actions.ActOnAsTypeExpr(Expr.get(), DestTy.get(), StartLoc, ConsumeParen()); break; } @@ -1882,7 +1882,7 @@ return ExprError(); } - Res = Actions.ActOnConvertVectorExpr(Expr.take(), DestTy.get(), StartLoc, + Res = Actions.ActOnConvertVectorExpr(Expr.get(), DestTy.get(), StartLoc, ConsumeParen()); break; } @@ -1893,7 +1893,7 @@ // These can be followed by postfix-expr pieces because they are // primary-expressions. - return ParsePostfixExpressionSuffix(Res.take()); + return ParsePostfixExpressionSuffix(Res.get()); } /// ParseParenExpression - This parses the unit that starts with a '(' token, @@ -1969,7 +1969,7 @@ // If the substmt parsed correctly, build the AST node. if (!Stmt.isInvalid()) { - Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.take(), Tok.getLocation()); + Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.get(), Tok.getLocation()); } else { Actions.ActOnStmtExprError(); } @@ -2096,7 +2096,7 @@ if (!Result.isInvalid()) { Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc, DeclaratorInfo, CastTy, - RParenLoc, Result.take()); + RParenLoc, Result.get()); } return Result; } @@ -2125,7 +2125,7 @@ // Don't build a paren expression unless we actually match a ')'. if (!Result.isInvalid() && Tok.is(tok::r_paren)) Result = - Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.take()); + Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.get()); } // Match the ')'. @@ -2156,7 +2156,7 @@ Diag(LParenLoc, diag::ext_c99_compound_literal); ExprResult Result = ParseInitializer(); if (!Result.isInvalid() && Ty) - return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.take()); + return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.get()); return Result; } @@ -2250,7 +2250,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return ExprError(); } - Ty = TR.release(); + Ty = TR.get(); } Types.push_back(Ty); @@ -2266,7 +2266,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return ExprError(); } - Exprs.push_back(ER.release()); + Exprs.push_back(ER.get()); } while (TryConsumeToken(tok::comma)); T.consumeClose(); @@ -2275,7 +2275,7 @@ return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc, T.getCloseLocation(), - ControllingExpr.release(), + ControllingExpr.get(), Types, Exprs); } @@ -2329,7 +2329,7 @@ if (Expr.isInvalid()) return true; - Exprs.push_back(Expr.release()); + Exprs.push_back(Expr.get()); if (Tok.isNot(tok::comma)) return false; @@ -2354,7 +2354,7 @@ if (Expr.isInvalid()) return true; - Exprs.push_back(Expr.release()); + Exprs.push_back(Expr.get()); if (Tok.isNot(tok::comma)) return false; @@ -2496,7 +2496,7 @@ StmtResult Stmt(ParseCompoundStatementBody()); BlockScope.Exit(); if (!Stmt.isInvalid()) - Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.take(), getCurScope()); + Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.get(), getCurScope()); else Actions.ActOnBlockError(CaretLoc, getCurScope()); return Result; Index: lib/Parse/ParseExprCXX.cpp =================================================================== --- lib/Parse/ParseExprCXX.cpp +++ lib/Parse/ParseExprCXX.cpp @@ -1184,7 +1184,7 @@ BodyScope.Exit(); if (!Stmt.isInvalid()) - return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.take(), getCurScope()); + return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope()); Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); return ExprError(); @@ -1253,7 +1253,7 @@ Result = Actions.ActOnCXXNamedCast(OpLoc, Kind, LAngleBracketLoc, DeclaratorInfo, RAngleBracketLoc, - T.getOpenLocation(), Result.take(), + T.getOpenLocation(), Result.get(), T.getCloseLocation()); return Result; @@ -1319,7 +1319,7 @@ return ExprError(); Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false, - Result.release(), RParenLoc); + Result.get(), RParenLoc); } } @@ -1367,7 +1367,7 @@ Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/false, - Result.release(), T.getCloseLocation()); + Result.get(), T.getCloseLocation()); } } @@ -1494,7 +1494,7 @@ default: ExprResult Expr(ParseAssignmentExpression()); if (Expr.isInvalid()) return Expr; - return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.take()); + return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get()); } } @@ -1534,7 +1534,7 @@ ExprResult Init = ParseBraceInitializer(); if (Init.isInvalid()) return Init; - Expr *InitList = Init.take(); + Expr *InitList = Init.get(); return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(), MultiExprArg(&InitList, 1), SourceLocation()); @@ -1636,7 +1636,7 @@ SkipUntil(tok::semi, StopAtSemi); return true; } - DeclaratorInfo.setAsmLabel(AsmLabel.release()); + DeclaratorInfo.setAsmLabel(AsmLabel.get()); DeclaratorInfo.SetRangeEnd(Loc); } @@ -1676,7 +1676,7 @@ } if (!InitExpr.isInvalid()) - Actions.AddInitializerToDecl(DeclOut, InitExpr.take(), !CopyInitialization, + Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization, DS.containsPlaceholderType()); else Actions.ActOnInitializerError(DeclOut); @@ -2617,7 +2617,7 @@ return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen, PlacementArgs, PlacementRParen, - TypeIdParens, DeclaratorInfo, Initializer.take()); + TypeIdParens, DeclaratorInfo, Initializer.get()); } /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be @@ -2655,7 +2655,7 @@ D.AddTypeInfo(DeclaratorChunk::getArray(0, /*static=*/false, /*star=*/false, - Size.release(), + Size.get(), T.getOpenLocation(), T.getCloseLocation()), Attrs, T.getCloseLocation()); @@ -2732,7 +2732,7 @@ if (Operand.isInvalid()) return Operand; - return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.take()); + return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get()); } static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { @@ -3017,7 +3017,7 @@ if (!Result.isInvalid()) Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(), DeclaratorInfo, CastTy, - Tracker.getCloseLocation(), Result.take()); + Tracker.getCloseLocation(), Result.get()); return Result; } @@ -3028,7 +3028,7 @@ Result = ParseExpression(); if (!Result.isInvalid() && Tok.is(tok::r_paren)) Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(), - Tok.getLocation(), Result.take()); + Tok.getLocation(), Result.get()); // Match the ')'. if (Result.isInvalid()) { Index: lib/Parse/ParseInit.cpp =================================================================== --- lib/Parse/ParseInit.cpp +++ lib/Parse/ParseInit.cpp @@ -309,12 +309,12 @@ return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, SourceLocation(), ParsedType(), - Idx.take()); + Idx.get()); } // If this is a normal array designator, remember it. if (Tok.isNot(tok::ellipsis)) { - Desig.AddDesignator(Designator::getArray(Idx.release(), StartLoc)); + Desig.AddDesignator(Designator::getArray(Idx.get(), StartLoc)); } else { // Handle the gnu array range extension. Diag(Tok, diag::ext_gnu_array_range); @@ -325,8 +325,8 @@ SkipUntil(tok::r_square, StopAtSemi); return RHS; } - Desig.AddDesignator(Designator::getArrayRange(Idx.release(), - RHS.release(), + Desig.AddDesignator(Designator::getArrayRange(Idx.get(), + RHS.get(), StartLoc, EllipsisLoc)); } @@ -426,7 +426,7 @@ // If we couldn't parse the subelement, bail out. if (!SubElt.isInvalid()) { - InitExprs.push_back(SubElt.release()); + InitExprs.push_back(SubElt.get()); } else { InitExprsOk = false; @@ -509,7 +509,7 @@ // If we couldn't parse the subelement, bail out. if (!SubElt.isInvalid()) - InitExprs.push_back(SubElt.release()); + InitExprs.push_back(SubElt.get()); else InitExprsOk = false; Index: lib/Parse/ParseObjc.cpp =================================================================== --- lib/Parse/ParseObjc.cpp +++ lib/Parse/ParseObjc.cpp @@ -1783,7 +1783,7 @@ } // consume ';' ExpectAndConsume(tok::semi, diag::err_expected_after, "@throw"); - return Actions.ActOnObjCAtThrowStmt(atLoc, Res.take(), getCurScope()); + return Actions.ActOnObjCAtThrowStmt(atLoc, Res.get(), getCurScope()); } /// objc-synchronized-statement: @@ -1820,7 +1820,7 @@ // Check the @synchronized operand now. if (!operand.isInvalid()) - operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.take()); + operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.get()); // Parse the compound statement within a new scope. ParseScope bodyScope(this, Scope::DeclScope); @@ -1911,9 +1911,9 @@ StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc, RParenLoc, FirstPart, - CatchBody.take()); + CatchBody.get()); if (!Catch.isInvalid()) - CatchStmts.push_back(Catch.release()); + CatchStmts.push_back(Catch.get()); } else { Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after) @@ -1934,7 +1934,7 @@ if (FinallyBody.isInvalid()) FinallyBody = Actions.ActOnNullStmt(Tok.getLocation()); FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc, - FinallyBody.take()); + FinallyBody.get()); catch_or_finally_seen = true; break; } @@ -1944,9 +1944,9 @@ return StmtError(); } - return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.take(), + return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.get(), CatchStmts, - FinallyStmt.take()); + FinallyStmt.get()); } /// objc-autoreleasepool-statement: @@ -1969,7 +1969,7 @@ if (AutoreleasePoolBody.isInvalid()) AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation()); return Actions.ActOnObjCAutoreleasePoolStmt(atLoc, - AutoreleasePoolBody.take()); + AutoreleasePoolBody.get()); } /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them @@ -2116,12 +2116,12 @@ } ConsumeToken(); // Consume the literal token. - Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.take()); + Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.get()); if (Lit.isInvalid()) return Lit; return ParsePostfixExpressionSuffix( - Actions.BuildObjCNumericLiteral(AtLoc, Lit.take())); + Actions.BuildObjCNumericLiteral(AtLoc, Lit.get())); } case tok::string_literal: // primary-expression: string-literal @@ -2222,7 +2222,7 @@ return true; IsExpr = true; - TypeOrExpr = Receiver.take(); + TypeOrExpr = Receiver.get(); return false; } @@ -2248,14 +2248,14 @@ // instance method. ExprResult Receiver = ParseCXXTypeConstructExpression(DS); if (!Receiver.isInvalid()) - Receiver = ParsePostfixExpressionSuffix(Receiver.take()); + Receiver = ParsePostfixExpressionSuffix(Receiver.get()); if (!Receiver.isInvalid()) - Receiver = ParseRHSOfBinaryExpression(Receiver.take(), prec::Comma); + Receiver = ParseRHSOfBinaryExpression(Receiver.get(), prec::Comma); if (Receiver.isInvalid()) return true; IsExpr = true; - TypeOrExpr = Receiver.take(); + TypeOrExpr = Receiver.get(); return false; } @@ -2401,7 +2401,7 @@ } return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), - ParsedType(), Res.take()); + ParsedType(), Res.get()); } /// \brief Parse the remainder of an Objective-C message following the @@ -2522,7 +2522,7 @@ } // We have a valid expression. - KeyExprs.push_back(Res.release()); + KeyExprs.push_back(Res.get()); // Code completion after each argument. if (Tok.is(tok::code_completion)) { @@ -2566,7 +2566,7 @@ } // We have a valid expression. - KeyExprs.push_back(Res.release()); + KeyExprs.push_back(Res.get()); } } else if (!selIdent) { Diag(Tok, diag::err_expected) << tok::identifier; // missing selector name. @@ -2617,7 +2617,7 @@ SmallVector AtLocs; ExprVector AtStrings; AtLocs.push_back(AtLoc); - AtStrings.push_back(Res.release()); + AtStrings.push_back(Res.get()); while (Tok.is(tok::at)) { AtLocs.push_back(ConsumeToken()); // eat the @. @@ -2630,7 +2630,7 @@ if (Lit.isInvalid()) return Lit; - AtStrings.push_back(Lit.release()); + AtStrings.push_back(Lit.get()); } return Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.data(), @@ -2657,7 +2657,7 @@ return Lit; } ConsumeToken(); // Consume the literal token. - return Actions.BuildObjCNumericLiteral(AtLoc, Lit.take()); + return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()); } /// ParseObjCNumericLiteral - @@ -2671,7 +2671,7 @@ return Lit; } ConsumeToken(); // Consume the literal token. - return Actions.BuildObjCNumericLiteral(AtLoc, Lit.take()); + return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()); } /// ParseObjCBoxedExpr - @@ -2694,9 +2694,9 @@ // Wrap the sub-expression in a parenthesized expression, to distinguish // a boxed expression from a literal. SourceLocation LPLoc = T.getOpenLocation(), RPLoc = T.getCloseLocation(); - ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.take()); + ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.get()); return Actions.BuildObjCBoxedExpr(SourceRange(AtLoc, RPLoc), - ValueExpr.take()); + ValueExpr.get()); } ExprResult Parser::ParseObjCArrayLiteral(SourceLocation AtLoc) { @@ -2720,7 +2720,7 @@ if (Res.isInvalid()) return true; - ElementExprs.push_back(Res.release()); + ElementExprs.push_back(Res.get()); if (Tok.is(tok::comma)) ConsumeToken(); // Eat the ','. Index: lib/Parse/ParseOpenMP.cpp =================================================================== --- lib/Parse/ParseOpenMP.cpp +++ lib/Parse/ParseOpenMP.cpp @@ -157,13 +157,13 @@ Actions.ActOnCapturedRegionError(); CreateDirective = false; } else { - AssociatedStmt = Actions.ActOnCapturedRegionEnd(AssociatedStmt.take()); + AssociatedStmt = Actions.ActOnCapturedRegionEnd(AssociatedStmt.get()); CreateDirective = AssociatedStmt.isUsable(); } } if (CreateDirective) Directive = Actions.ActOnOpenMPExecutableDirective(DKind, Clauses, - AssociatedStmt.take(), + AssociatedStmt.get(), Loc, EndLoc); // Exit scope. @@ -234,7 +234,7 @@ ExprResult Res = Actions.ActOnOpenMPIdExpression(getCurScope(), SS, NameInfo); if (Res.isUsable()) - VarList.push_back(Res.take()); + VarList.push_back(Res.get()); } // Consume ','. if (Tok.is(tok::comma)) { @@ -351,7 +351,7 @@ if (Val.isInvalid()) return nullptr; - return Actions.ActOnOpenMPSingleExprClause(Kind, Val.take(), Loc, + return Actions.ActOnOpenMPSingleExprClause(Kind, Val.get(), Loc, T.getOpenLocation(), T.getCloseLocation()); } @@ -419,7 +419,7 @@ // Parse variable ExprResult VarExpr = ParseAssignmentExpression(); if (VarExpr.isUsable()) { - Vars.push_back(VarExpr.take()); + Vars.push_back(VarExpr.get()); } else { SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch); @@ -442,7 +442,7 @@ ConsumeToken(); ExprResult Tail = ParseAssignmentExpression(); if (Tail.isUsable()) - TailExpr = Tail.take(); + TailExpr = Tail.get(); else SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch); Index: lib/Parse/ParseStmt.cpp =================================================================== --- lib/Parse/ParseStmt.cpp +++ lib/Parse/ParseStmt.cpp @@ -445,8 +445,8 @@ return Actions.ActOnSEHTryBlock(false /* IsCXXTry */, TryLoc, - TryBlock.take(), - Handler.take()); + TryBlock.get(), + Handler.get()); } /// ParseSEHExceptBlock - Handle __except @@ -488,7 +488,7 @@ if(Block.isInvalid()) return Block; - return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.take(), Block.take()); + return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.get(), Block.get()); } /// ParseSEHFinallyBlock - Handle __finally @@ -505,7 +505,7 @@ if(Block.isInvalid()) return Block; - return Actions.ActOnSEHFinallyBlock(FinallyBlock,Block.take()); + return Actions.ActOnSEHFinallyBlock(FinallyBlock,Block.get()); } /// ParseLabeledStatement - We have an identifier and a ':' after it. @@ -915,7 +915,7 @@ ExpectAndConsumeSemi(diag::err_expected_semi_declaration); if (R.isUsable()) - Stmts.push_back(R.release()); + Stmts.push_back(R.get()); } while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { @@ -975,7 +975,7 @@ } if (R.isUsable()) - Stmts.push_back(R.release()); + Stmts.push_back(R.get()); } SourceLocation CloseLoc = Tok.getLocation(); @@ -1596,7 +1596,7 @@ ExprResult Third = ParseExpression(); // FIXME: The C++11 standard doesn't actually say that this is a // discarded-value expression, but it clearly should be. - ThirdPart = Actions.MakeFullDiscardedValueExpr(Third.take()); + ThirdPart = Actions.MakeFullDiscardedValueExpr(Third.get()); } } // Match the ')'. @@ -1609,7 +1609,7 @@ StmtResult ForEachStmt; if (ForRange) { - ForRangeStmt = Actions.ActOnCXXForRangeStmt(ForLoc, FirstPart.take(), + ForRangeStmt = Actions.ActOnCXXForRangeStmt(ForLoc, FirstPart.get(), ForRangeInit.ColonLoc, ForRangeInit.RangeExpr.get(), T.getCloseLocation(), @@ -1620,8 +1620,8 @@ // statement immediately in order to close over temporaries correctly. } else if (ForEach) { ForEachStmt = Actions.ActOnObjCForCollectionStmt(ForLoc, - FirstPart.take(), - Collection.take(), + FirstPart.get(), + Collection.get(), T.getCloseLocation()); } @@ -1659,15 +1659,15 @@ return StmtError(); if (ForEach) - return Actions.FinishObjCForCollectionStmt(ForEachStmt.take(), - Body.take()); + return Actions.FinishObjCForCollectionStmt(ForEachStmt.get(), + Body.get()); if (ForRange) - return Actions.FinishCXXForRangeStmt(ForRangeStmt.take(), Body.take()); + return Actions.FinishCXXForRangeStmt(ForRangeStmt.get(), Body.get()); - return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.take(), + return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.get(), SecondPart, SecondVar, ThirdPart, - T.getCloseLocation(), Body.take()); + T.getCloseLocation(), Body.get()); } /// ParseGotoStatement @@ -1696,7 +1696,7 @@ SkipUntil(tok::semi, StopBeforeMatch); return StmtError(); } - Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.take()); + Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.get()); } else { Diag(Tok, diag::err_expected) << tok::identifier; return StmtError(); @@ -1756,7 +1756,7 @@ return StmtError(); } } - return Actions.ActOnReturnStmt(ReturnLoc, R.take(), getCurScope()); + return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope()); } namespace { @@ -1818,7 +1818,7 @@ } // Initialize the "decl" with the lookup result. - Info.OpDecl = static_cast(Result.take()); + Info.OpDecl = static_cast(Result.get()); return Info.OpDecl; } @@ -2254,7 +2254,7 @@ // Need address of variable. if (OpExprs[i].second) OpExpr = Actions.BuildUnaryOp(getCurScope(), AsmLoc, UO_AddrOf, OpExpr) - .take(); + .get(); ConstraintRefs[i] = StringRef(Constraints[i]); Exprs[i] = OpExpr; @@ -2334,7 +2334,7 @@ T.consumeClose(); return Actions.ActOnGCCAsmStmt(AsmLoc, /*isSimple*/ true, isVolatile, /*NumOutputs*/ 0, /*NumInputs*/ 0, nullptr, - Constraints, Exprs, AsmString.take(), + Constraints, Exprs, AsmString.get(), Clobbers, T.getCloseLocation()); } @@ -2387,7 +2387,7 @@ if (Clobber.isInvalid()) break; - Clobbers.push_back(Clobber.release()); + Clobbers.push_back(Clobber.get()); if (!TryConsumeToken(tok::comma)) break; @@ -2398,7 +2398,7 @@ T.consumeClose(); return Actions.ActOnGCCAsmStmt(AsmLoc, false, isVolatile, NumOutputs, NumInputs, Names.data(), Constraints, Exprs, - AsmString.take(), Clobbers, + AsmString.get(), Clobbers, T.getCloseLocation()); } @@ -2447,7 +2447,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return true; } - Constraints.push_back(Constraint.release()); + Constraints.push_back(Constraint.get()); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::err_expected_lparen_after) << "asm operand"; @@ -2464,7 +2464,7 @@ SkipUntil(tok::r_paren, StopAtSemi); return true; } - Exprs.push_back(Res.release()); + Exprs.push_back(Res.get()); // Eat the comma and continue parsing if it exists. if (!TryConsumeToken(tok::comma)) return false; @@ -2496,7 +2496,7 @@ } BodyScope.Exit(); - return Actions.ActOnFinishFunctionBody(Decl, FnBody.take()); + return Actions.ActOnFinishFunctionBody(Decl, FnBody.get()); } /// ParseFunctionTryBlock - Parse a C++ function-try-block. @@ -2533,7 +2533,7 @@ } BodyScope.Exit(); - return Actions.ActOnFinishFunctionBody(Decl, FnBody.take()); + return Actions.ActOnFinishFunctionBody(Decl, FnBody.get()); } bool Parser::trySkippingFunctionBody() { @@ -2619,8 +2619,8 @@ return Actions.ActOnSEHTryBlock(true /* IsCXXTry */, TryLoc, - TryBlock.take(), - Handler.take()); + TryBlock.get(), + Handler.get()); } else { StmtVector Handlers; @@ -2634,14 +2634,14 @@ while (Tok.is(tok::kw_catch)) { StmtResult Handler(ParseCXXCatchBlock(FnTry)); if (!Handler.isInvalid()) - Handlers.push_back(Handler.release()); + Handlers.push_back(Handler.get()); } // Don't bother creating the full statement if we don't have any usable // handlers. if (Handlers.empty()) return StmtError(); - return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.take(), Handlers); + return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.get(), Handlers); } } @@ -2701,7 +2701,7 @@ if (Block.isInvalid()) return Block; - return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.take()); + return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.get()); } void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) { @@ -2756,7 +2756,7 @@ while (Tok.isNot(tok::r_brace)) { StmtResult R = ParseStatementOrDeclaration(Stmts, false); if (R.isUsable()) - Stmts.push_back(R.release()); + Stmts.push_back(R.get()); } Braces.consumeClose(); } Index: lib/Parse/ParseTemplate.cpp =================================================================== --- lib/Parse/ParseTemplate.cpp +++ lib/Parse/ParseTemplate.cpp @@ -651,7 +651,7 @@ // Create the parameter. return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl, Depth, Position, EqualLoc, - DefaultArg.take()); + DefaultArg.get()); } /// \brief Parses a '>' at the end of a template list. @@ -1118,7 +1118,7 @@ return ParsedTemplateArgument(); return ParsedTemplateArgument(ParsedTemplateArgument::NonType, - ExprArg.release(), Loc); + ExprArg.get(), Loc); } /// \brief Determine whether the current tokens can only be parsed as a Index: lib/Sema/Sema.cpp =================================================================== --- lib/Sema/Sema.cpp +++ lib/Sema/Sema.cpp @@ -1408,7 +1408,7 @@ // FIXME: Try this before emitting the fixit, and suppress diagnostics // while doing so. - E = ActOnCallExpr(nullptr, E.take(), Range.getEnd(), None, + E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None, Range.getEnd().getLocWithOffset(1)); return true; } Index: lib/Sema/SemaCast.cpp =================================================================== --- lib/Sema/SemaCast.cpp +++ lib/Sema/SemaCast.cpp @@ -134,7 +134,7 @@ if (!isPlaceholder() || isPlaceholder(BuiltinType::Overload)) return; - SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.take()); + SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get()); if (SrcExpr.isInvalid()) return; PlaceholderKind = (BuiltinType::Kind) 0; @@ -262,7 +262,7 @@ return ExprError(); } return Op.complete(CXXConstCastExpr::Create(Context, Op.ResultType, - Op.ValueKind, Op.SrcExpr.take(), DestTInfo, + Op.ValueKind, Op.SrcExpr.get(), DestTInfo, OpLoc, Parens.getEnd(), AngleBrackets)); @@ -273,7 +273,7 @@ return ExprError(); } return Op.complete(CXXDynamicCastExpr::Create(Context, Op.ResultType, - Op.ValueKind, Op.Kind, Op.SrcExpr.take(), + Op.ValueKind, Op.Kind, Op.SrcExpr.get(), &Op.BasePath, DestTInfo, OpLoc, Parens.getEnd(), AngleBrackets)); @@ -285,7 +285,7 @@ return ExprError(); } return Op.complete(CXXReinterpretCastExpr::Create(Context, Op.ResultType, - Op.ValueKind, Op.Kind, Op.SrcExpr.take(), + Op.ValueKind, Op.Kind, Op.SrcExpr.get(), nullptr, DestTInfo, OpLoc, Parens.getEnd(), AngleBrackets)); @@ -298,7 +298,7 @@ } return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType, - Op.ValueKind, Op.Kind, Op.SrcExpr.take(), + Op.ValueKind, Op.Kind, Op.SrcExpr.get(), &Op.BasePath, DestTInfo, OpLoc, Parens.getEnd(), AngleBrackets)); @@ -535,9 +535,9 @@ /// checked downcasts in class hierarchies. void CastOperation::CheckDynamicCast() { if (ValueKind == VK_RValue) - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); else if (isPlaceholder()) - SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.take()); + SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get()); if (SrcExpr.isInvalid()) // if conversion failed, don't report another error return; @@ -690,9 +690,9 @@ /// legacy_function(const_cast\(str)); void CastOperation::CheckConstCast() { if (ValueKind == VK_RValue) - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); else if (isPlaceholder()) - SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.take()); + SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get()); if (SrcExpr.isInvalid()) // if conversion failed, don't report another error return; @@ -805,7 +805,7 @@ /// char *bytes = reinterpret_cast\(int_ptr); void CastOperation::CheckReinterpretCast() { if (ValueKind == VK_RValue && !isPlaceholder(BuiltinType::Overload)) - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); else checkNonOverloadPlaceholders(); if (SrcExpr.isInvalid()) // if conversion failed, don't report another error @@ -864,13 +864,13 @@ return; } - SrcExpr = Self.IgnoredValueConversions(SrcExpr.take()); + SrcExpr = Self.IgnoredValueConversions(SrcExpr.get()); return; } if (ValueKind == VK_RValue && !DestType->isRecordType() && !isPlaceholder(BuiltinType::Overload)) { - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); if (SrcExpr.isInvalid()) // if conversion failed, don't report another error return; } @@ -1589,7 +1589,7 @@ // This is a const_cast from a class prvalue to an rvalue reference type. // Materialize a temporary to store the result of the conversion. SrcExpr = new (Self.Context) MaterializeTemporaryExpr( - SrcType, SrcExpr.take(), /*IsLValueReference*/ false); + SrcType, SrcExpr.get(), /*IsLValueReference*/ false); return TC_Success; } @@ -2024,7 +2024,7 @@ return; } - SrcExpr = Self.IgnoredValueConversions(SrcExpr.take()); + SrcExpr = Self.IgnoredValueConversions(SrcExpr.get()); return; } @@ -2037,7 +2037,7 @@ if (ValueKind == VK_RValue && !DestType->isRecordType() && !isPlaceholder(BuiltinType::Overload)) { - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); if (SrcExpr.isInvalid()) return; } @@ -2175,7 +2175,7 @@ // type needs to be scalar. if (DestType->isVoidType()) { // We don't necessarily do lvalue-to-rvalue conversions on this. - SrcExpr = Self.IgnoredValueConversions(SrcExpr.take()); + SrcExpr = Self.IgnoredValueConversions(SrcExpr.get()); if (SrcExpr.isInvalid()) return; @@ -2184,7 +2184,7 @@ return; } - SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); + SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); if (SrcExpr.isInvalid()) return; QualType SrcType = SrcExpr.get()->getType(); @@ -2265,7 +2265,7 @@ } if (DestType->isExtVectorType()) { - SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.take(), Kind); + SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind); return; } @@ -2387,7 +2387,7 @@ return ExprError(); return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType, - Op.ValueKind, Op.Kind, Op.SrcExpr.take(), + Op.ValueKind, Op.Kind, Op.SrcExpr.get(), &Op.BasePath, CastTypeInfo, LPLoc, RPLoc)); } @@ -2409,5 +2409,5 @@ return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType, Op.ValueKind, CastTypeInfo, Op.Kind, - Op.SrcExpr.take(), &Op.BasePath, LPLoc, RPLoc)); + Op.SrcExpr.get(), &Op.BasePath, LPLoc, RPLoc)); } Index: lib/Sema/SemaChecking.cpp =================================================================== --- lib/Sema/SemaChecking.cpp +++ lib/Sema/SemaChecking.cpp @@ -106,7 +106,7 @@ if (ResultType.isNull()) return true; - TheCall->setArg(0, Arg.take()); + TheCall->setArg(0, Arg.get()); TheCall->setType(ResultType); return false; } @@ -493,7 +493,7 @@ ExprResult PointerArgRes = DefaultFunctionArrayLvalueConversion(PointerArg); if (PointerArgRes.isInvalid()) return true; - PointerArg = PointerArgRes.take(); + PointerArg = PointerArgRes.get(); const PointerType *pointerType = PointerArg->getType()->getAs(); if (!pointerType) { @@ -525,7 +525,7 @@ PointerArgRes = ImpCastExprToType(PointerArg, AddrType, CastNeeded); if (PointerArgRes.isInvalid()) return true; - PointerArg = PointerArgRes.take(); + PointerArg = PointerArgRes.get(); TheCall->setArg(IsLdrex ? 0 : 1, PointerArg); @@ -1243,7 +1243,7 @@ if (Arg.isInvalid()) return true; - E->setArg(ArgIndex, Arg.take()); + E->setArg(ArgIndex, Arg.get()); return false; } @@ -1278,7 +1278,7 @@ ExprResult FirstArgResult = DefaultFunctionArrayLvalueConversion(FirstArg); if (FirstArgResult.isInvalid()) return ExprError(); - FirstArg = FirstArgResult.take(); + FirstArg = FirstArgResult.get(); TheCall->setArg(0, FirstArg); const PointerType *pointerType = FirstArg->getType()->getAs(); @@ -1556,7 +1556,7 @@ // pass in 42. The 42 gets converted to char. This is even more strange // for things like 45.123 -> char, etc. // FIXME: Do this check. - TheCall->setArg(i+1, Arg.take()); + TheCall->setArg(i+1, Arg.get()); } ASTContext& Context = this->getASTContext(); @@ -1577,7 +1577,7 @@ QualType CalleePtrTy = Context.getPointerType(NewBuiltinDecl->getType()); ExprResult PromotedCall = ImpCastExprToType(NewDRE, CalleePtrTy, CK_BuiltinFnToFnPtr); - TheCall->setCallee(PromotedCall.take()); + TheCall->setCallee(PromotedCall.get()); // Change the result type of the call to match the original value type. This // is arbitrary, but the codegen for these builtins ins design to handle it Index: lib/Sema/SemaCodeComplete.cpp =================================================================== --- lib/Sema/SemaCodeComplete.cpp +++ lib/Sema/SemaCodeComplete.cpp @@ -3428,7 +3428,7 @@ if (E.isInvalid()) CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction); else if (getLangOpts().ObjC1) - CodeCompleteObjCInstanceMessage(S, E.take(), None, false); + CodeCompleteObjCInstanceMessage(S, E.get(), None, false); } /// \brief The set of properties that have already been added, referenced by @@ -5466,7 +5466,7 @@ ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr); if (Conv.isInvalid()) // conversion failed. bail. return; - RecExpr = Conv.take(); + RecExpr = Conv.get(); } QualType ReceiverType = RecExpr? RecExpr->getType() : Super? Context.getObjCObjectPointerType( @@ -5490,7 +5490,7 @@ } else if (RecExpr && getLangOpts().CPlusPlus) { ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr); if (Conv.isUsable()) { - RecExpr = Conv.take(); + RecExpr = Conv.get(); ReceiverType = RecExpr->getType(); } } Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -8197,7 +8197,7 @@ VDecl->setInvalidDecl(); return; } - Init = Result.take(); + Init = Result.get(); DefaultedToAuto = true; } @@ -8336,7 +8336,7 @@ VDecl->setInvalidDecl(); return; } - Init = Result.take(); + Init = Result.get(); } // Perform the initialization. @@ -8364,7 +8364,7 @@ return; } - Init = Result.takeAs(); + Init = Result.getAs(); } // Check for self-references within variable initializers. @@ -8422,7 +8422,7 @@ VDecl->setInvalidDecl(); return; } - Init = Result.take(); + Init = Result.get(); // Attach the initializer to the decl. VDecl->setInit(Init); @@ -8984,7 +8984,7 @@ var, var->getType(), varRef, /*AllowNRVO=*/true); if (!result.isInvalid()) { result = MaybeCreateExprWithCleanups(result); - Expr *init = result.takeAs(); + Expr *init = result.getAs(); Context.setBlockVarCopyInits(var, init); } } @@ -11454,7 +11454,7 @@ ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); if (ICE.isInvalid()) return ICE; - BitWidth = ICE.take(); + BitWidth = ICE.get(); if (Value != 0 && ZeroWidth) *ZeroWidth = false; @@ -11694,7 +11694,7 @@ // If this is declared as a bit-field, check the bit-field. if (!InvalidDecl && BitWidth) { BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, - &ZeroWidth).take(); + &ZeroWidth).get(); if (!BitWidth) { InvalidDecl = true; BitWidth = nullptr; @@ -11882,7 +11882,7 @@ if (BitWidth) { // 6.7.2.1p3, 6.7.2.1p4 - BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).take(); + BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get(); if (!BitWidth) D.setInvalidType(); } else { @@ -12483,7 +12483,7 @@ Val = nullptr; if (Val) - Val = DefaultLvalueConversion(Val).take(); + Val = DefaultLvalueConversion(Val).get(); if (Val) { if (Enum->isDependentType() || Val->isTypeDependent()) @@ -12502,10 +12502,10 @@ if (Converted.isInvalid()) Val = nullptr; else - Val = Converted.take(); + Val = Converted.get(); } else if (!Val->isValueDependent() && !(Val = VerifyIntegerConstantExpression(Val, - &EnumVal).take())) { + &EnumVal).get())) { // C99 6.7.2.2p2: Make sure we have an integer constant expression. } else { if (Enum->isFixed()) { @@ -12518,11 +12518,11 @@ if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { if (getLangOpts().MSVCCompat) { Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; - Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); + Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); } else Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; } else - Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); + Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); } else if (getLangOpts().CPlusPlus) { // C++11 [dcl.enum]p5: // If the underlying type is not fixed, the type of each enumerator @@ -12543,7 +12543,7 @@ << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { // Force the type of the expression to 'int'. - Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take(); + Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get(); } EltTy = Val->getType(); } Index: lib/Sema/SemaDeclAttr.cpp =================================================================== --- lib/Sema/SemaDeclAttr.cpp +++ lib/Sema/SemaDeclAttr.cpp @@ -751,7 +751,7 @@ ExprResult Converted = S.PerformContextuallyConvertToBool(Cond); if (Converted.isInvalid()) return; - Cond = Converted.take(); + Cond = Converted.get(); } StringRef Msg; @@ -2787,7 +2787,7 @@ } AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true, - ICE.take(), SpellingListIndex); + ICE.get(), SpellingListIndex); AA->setPackExpansion(IsPackExpansion); D->addAttr(AA); } Index: lib/Sema/SemaDeclCXX.cpp =================================================================== --- lib/Sema/SemaDeclCXX.cpp +++ lib/Sema/SemaDeclCXX.cpp @@ -268,7 +268,7 @@ ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg); if (Result.isInvalid()) return true; - Arg = Result.takeAs(); + Arg = Result.getAs(); CheckCompletedExpr(Arg, EqualLoc); Arg = MaybeCreateExprWithCleanups(Arg); @@ -2392,13 +2392,13 @@ // C++11 [class.base.init]p7: // The initialization of each base and member constitutes a // full-expression. - Init = ActOnFinishFullExpr(Init.take(), InitLoc); + Init = ActOnFinishFullExpr(Init.get(), InitLoc); if (Init.isInvalid()) { FD->setInvalidDecl(); return; } - InitExpr = Init.release(); + InitExpr = Init.get(); FD->setInClassInitializer(InitExpr); } @@ -2836,7 +2836,7 @@ DelegationInit = Owned(Init); return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(), - DelegationInit.takeAs(), + DelegationInit.getAs(), InitRange.getEnd()); } @@ -2967,7 +2967,7 @@ return new (Context) CXXCtorInitializer(Context, BaseTInfo, BaseSpec->isVirtual(), InitRange.getBegin(), - BaseInit.takeAs(), + BaseInit.getAs(), InitRange.getEnd(), EllipsisLoc); } @@ -2982,7 +2982,7 @@ return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E, SourceRange(ExprLoc, ExprLoc), - E->getSourceRange()).take(); + E->getSourceRange()).get(); } /// ImplicitInitializerKind - How an implicit base or member initializer should @@ -3024,7 +3024,7 @@ VK_LValue, SourceLocation()); if (ArgExpr.isInvalid()) return true; - Args.push_back(CastForMoving(SemaRef, ArgExpr.take(), PD->getType())); + Args.push_back(CastForMoving(SemaRef, ArgExpr.get(), PD->getType())); } InitializationKind InitKind = InitializationKind::CreateDirect( @@ -3071,7 +3071,7 @@ CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy, CK_UncheckedDerivedToBase, Moving ? VK_XValue : VK_LValue, - &BasePath).take(); + &BasePath).get(); InitializationKind InitKind = InitializationKind::CreateDirect(Constructor->getLocation(), @@ -3092,7 +3092,7 @@ SourceLocation()), BaseSpec->isVirtual(), SourceLocation(), - BaseInit.takeAs(), + BaseInit.getAs(), SourceLocation(), SourceLocation()); @@ -3157,7 +3157,7 @@ // - if a member m has rvalue reference type T&&, it is direct-initialized // with static_cast(x.m); if (RefersToRValueRef(CtorArg.get())) { - CtorArg = CastForMoving(SemaRef, CtorArg.take()); + CtorArg = CastForMoving(SemaRef, CtorArg.get()); } // When the field we are copying is an array, create index variables for @@ -3191,13 +3191,13 @@ = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); assert(!IterationVarRef.isInvalid() && "Reference to invented variable cannot fail!"); - IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.take()); + IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.get()); assert(!IterationVarRef.isInvalid() && "Conversion of invented variable cannot fail!"); // Subscript the array with this iteration variable. - CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.take(), Loc, - IterationVarRef.take(), + CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.get(), Loc, + IterationVarRef.get(), Loc); if (CtorArg.isInvalid()) return true; @@ -3207,7 +3207,7 @@ // The array subscript expression is an lvalue, which is wrong for moving. if (Moving && InitializingArray) - CtorArg = CastForMoving(SemaRef, CtorArg.take()); + CtorArg = CastForMoving(SemaRef, CtorArg.get()); // Construct the entity that we will be initializing. For an array, this // will be first element in the array, which may require several levels @@ -3227,7 +3227,7 @@ InitializationKind InitKind = InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation()); - Expr *CtorArgE = CtorArg.takeAs(); + Expr *CtorArgE = CtorArg.getAs(); InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind, CtorArgE); ExprResult MemberInit @@ -3243,11 +3243,11 @@ CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect, Loc, Loc, - MemberInit.takeAs(), + MemberInit.getAs(), Loc); } else CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc, - Loc, MemberInit.takeAs(), + Loc, MemberInit.getAs(), Loc, IndexVariables.data(), IndexVariables.size()); @@ -8874,7 +8874,7 @@ public: virtual Expr *build(Sema &S, SourceLocation Loc) const override { - return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).take()); + return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get()); } RefBuilder(VarDecl *Var, QualType VarType) @@ -8884,7 +8884,7 @@ class ThisBuilder: public ExprBuilder { public: virtual Expr *build(Sema &S, SourceLocation Loc) const override { - return assertNotNull(S.ActOnCXXThis(Loc).takeAs()); + return assertNotNull(S.ActOnCXXThis(Loc).getAs()); } }; @@ -8898,7 +8898,7 @@ virtual Expr *build(Sema &S, SourceLocation Loc) const override { return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type, CK_UncheckedDerivedToBase, Kind, - &Path).take()); + &Path).get()); } CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind, @@ -8912,7 +8912,7 @@ public: virtual Expr *build(Sema &S, SourceLocation Loc) const override { return assertNotNull( - S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).take()); + S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get()); } DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {} @@ -8929,7 +8929,7 @@ virtual Expr *build(Sema &S, SourceLocation Loc) const override { return assertNotNull(S.BuildMemberReferenceExpr( Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(), - nullptr, MemberLookup, nullptr).take()); + nullptr, MemberLookup, nullptr).get()); } MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow, @@ -8955,7 +8955,7 @@ public: virtual Expr *build(Sema &S, SourceLocation Loc) const override { return assertNotNull( - S.DefaultLvalueConversion(Builder.build(S, Loc)).take()); + S.DefaultLvalueConversion(Builder.build(S, Loc)).get()); } LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {} @@ -8968,7 +8968,7 @@ public: virtual Expr *build(Sema &S, SourceLocation Loc) const override { return assertNotNull(S.CreateBuiltinArraySubscriptExpr( - Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).take()); + Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get()); } SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index) @@ -9026,11 +9026,11 @@ Expr *CallArgs[] = { To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc) }; - ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.take(), + ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(), Loc, CallArgs, Loc); assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!"); - return S.Owned(Call.takeAs()); + return S.Owned(Call.getAs()); } /// \brief Builds a statement that copies/moves the given entity from \p From to @@ -9148,7 +9148,7 @@ Expr *FromInst = From.build(S, Loc); ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr, - OpEqualRef.takeAs(), + OpEqualRef.getAs(), Loc, FromInst, Loc); if (Call.isInvalid()) return StmtError(); @@ -9247,7 +9247,7 @@ return S.ActOnForStmt(Loc, Loc, InitStmt, S.MakeFullExpr(Comparison), nullptr, S.MakeFullDiscardedValueExpr(Increment), - Loc, Copy.take()); + Loc, Copy.get()); } static StmtResult @@ -9542,7 +9542,7 @@ } // Success! Record the copy. - Statements.push_back(Copy.takeAs()); + Statements.push_back(Copy.getAs()); } // Assign non-static members. @@ -9613,7 +9613,7 @@ } // Success! Record the copy. - Statements.push_back(Copy.takeAs()); + Statements.push_back(Copy.getAs()); } if (!Invalid) { @@ -9624,7 +9624,7 @@ if (Return.isInvalid()) Invalid = true; else { - Statements.push_back(Return.takeAs()); + Statements.push_back(Return.getAs()); if (Trap.hasErrorOccurred()) { Diag(CurrentLocation, diag::note_member_synthesized_at) @@ -9646,7 +9646,7 @@ /*isStmtExpr=*/false); assert(!Body.isInvalid() && "Compound statement creation cannot fail"); } - CopyAssignOperator->setBody(Body.takeAs()); + CopyAssignOperator->setBody(Body.getAs()); if (ASTMutationListener *L = getASTMutationListener()) { L->CompletedImplicitDefinition(CopyAssignOperator); @@ -9958,7 +9958,7 @@ } // Success! Record the move. - Statements.push_back(Move.takeAs()); + Statements.push_back(Move.getAs()); } // Assign non-static members. @@ -10032,7 +10032,7 @@ } // Success! Record the copy. - Statements.push_back(Move.takeAs()); + Statements.push_back(Move.getAs()); } if (!Invalid) { @@ -10043,7 +10043,7 @@ if (Return.isInvalid()) Invalid = true; else { - Statements.push_back(Return.takeAs()); + Statements.push_back(Return.getAs()); if (Trap.hasErrorOccurred()) { Diag(CurrentLocation, diag::note_member_synthesized_at) @@ -10065,7 +10065,7 @@ /*isStmtExpr=*/false); assert(!Body.isInvalid() && "Compound statement creation cannot fail"); } - MoveAssignOperator->setBody(Body.takeAs()); + MoveAssignOperator->setBody(Body.getAs()); if (ASTMutationListener *L = getASTMutationListener()) { L->CompletedImplicitDefinition(MoveAssignOperator); @@ -10217,7 +10217,7 @@ Sema::CompoundScopeRAII CompoundScope(*this); CopyConstructor->setBody(ActOnCompoundStmt( CopyConstructor->getLocation(), CopyConstructor->getLocation(), None, - /*isStmtExpr=*/ false).takeAs()); + /*isStmtExpr=*/ false).getAs()); } CopyConstructor->markUsed(Context); @@ -10373,7 +10373,7 @@ Sema::CompoundScopeRAII CompoundScope(*this); MoveConstructor->setBody(ActOnCompoundStmt( MoveConstructor->getLocation(), MoveConstructor->getLocation(), None, - /*isStmtExpr=*/ false).takeAs()); + /*isStmtExpr=*/ false).getAs()); } MoveConstructor->markUsed(Context); @@ -10442,9 +10442,9 @@ } // Construct the body of the conversion function { return __invoke; }. Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(), - VK_LValue, Conv->getLocation()).take(); + VK_LValue, Conv->getLocation()).get(); assert(FunctionRef && "Can't refer to __invoke function?"); - Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).take(); + Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get(); Conv->setBody(new (Context) CompoundStmt(Context, Return, Conv->getLocation(), Conv->getLocation())); @@ -10478,8 +10478,8 @@ DiagnosticErrorTrap Trap(Diags); // Copy-initialize the lambda object as needed to capture it. - Expr *This = ActOnCXXThis(CurrentLocation).take(); - Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).take(); + Expr *This = ActOnCXXThis(CurrentLocation).get(); + Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get(); ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation, Conv->getLocation(), @@ -10510,7 +10510,7 @@ } // Set the body of the conversion function. - Stmt *ReturnS = Return.take(); + Stmt *ReturnS = Return.get(); Conv->setBody(new (Context) CompoundStmt(Context, ReturnS, Conv->getLocation(), Conv->getLocation())); @@ -11242,7 +11242,7 @@ else { // If the constructor used was non-trivial, set this as the // "initializer". - CXXConstructExpr *construct = result.takeAs(); + CXXConstructExpr *construct = result.getAs(); if (!construct->getConstructor()->isTrivial()) { Expr *init = MaybeCreateExprWithCleanups(construct); ExDecl->setInit(init); @@ -11462,7 +11462,7 @@ TemplateParams, AS_public, /*ModulePrivateLoc=*/SourceLocation(), TempParamLists.size() - 1, - TempParamLists.data()).take(); + TempParamLists.data()).get(); } else { // The "template<>" header is extraneous. Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) @@ -12540,7 +12540,7 @@ Member = new (Context) CXXCtorInitializer(Context, Field, SourceLocation(), SourceLocation(), - MemberInit.takeAs(), + MemberInit.getAs(), SourceLocation()); AllToInit.push_back(Member); @@ -12823,7 +12823,7 @@ if (!NoexceptExpr->isValueDependent()) NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, nullptr, diag::err_noexcept_needs_constant_expression, - /*AllowFold*/ false).take(); + /*AllowFold*/ false).get(); EPI.NoexceptExpr = NoexceptExpr; } return; Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp +++ lib/Sema/SemaExpr.cpp @@ -426,7 +426,7 @@ if (E->getType()->isPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return ExprError(); - E = result.take(); + E = result.get(); } QualType Ty = E->getType(); @@ -440,7 +440,7 @@ return ExprError(); } E = ImpCastExprToType(E, Context.getPointerType(Ty), - CK_FunctionToPointerDecay).take(); + CK_FunctionToPointerDecay).get(); } else if (Ty->isArrayType()) { // In C90 mode, arrays only promote to pointers if the array expression is // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has @@ -455,7 +455,7 @@ // if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), - CK_ArrayToPointerDecay).take(); + CK_ArrayToPointerDecay).get(); } return Owned(E); } @@ -540,7 +540,7 @@ if (E->getType()->isPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return ExprError(); - E = result.take(); + E = result.get(); } // C++ [conv.lval]p1: @@ -631,7 +631,7 @@ ExprResult Res = DefaultFunctionArrayConversion(E); if (Res.isInvalid()) return ExprError(); - Res = DefaultLvalueConversion(Res.take()); + Res = DefaultLvalueConversion(Res.get()); if (Res.isInvalid()) return ExprError(); return Res; @@ -646,14 +646,14 @@ // to function type. if (Ty->isFunctionType()) { Res = ImpCastExprToType(E, Context.getPointerType(Ty), - CK_FunctionToPointerDecay).take(); + CK_FunctionToPointerDecay).get(); if (Res.isInvalid()) return ExprError(); } - Res = DefaultLvalueConversion(Res.take()); + Res = DefaultLvalueConversion(Res.get()); if (Res.isInvalid()) return ExprError(); - return Owned(Res.take()); + return Owned(Res.get()); } /// UsualUnaryConversions - Performs various conversions that are common to most @@ -666,14 +666,14 @@ ExprResult Res = DefaultFunctionArrayLvalueConversion(E); if (Res.isInvalid()) return ExprError(); - E = Res.take(); + E = Res.get(); QualType Ty = E->getType(); assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); // Half FP have to be promoted to float unless it is natively supported if (Ty->isHalfType() && !getLangOpts().NativeHalfType) - return ImpCastExprToType(Res.take(), Context.FloatTy, CK_FloatingCast); + return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast); // Try to perform integral promotions if the object has a theoretically // promotable type. @@ -694,12 +694,12 @@ QualType PTy = Context.isPromotableBitField(E); if (!PTy.isNull()) { - E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); + E = ImpCastExprToType(E, PTy, CK_IntegralCast).get(); return Owned(E); } if (Ty->isPromotableIntegerType()) { QualType PT = Context.getPromotedIntegerType(Ty); - E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); + E = ImpCastExprToType(E, PT, CK_IntegralCast).get(); return Owned(E); } } @@ -717,14 +717,14 @@ ExprResult Res = UsualUnaryConversions(E); if (Res.isInvalid()) return ExprError(); - E = Res.take(); + E = Res.get(); // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to // double. const BuiltinType *BTy = Ty->getAs(); if (BTy && (BTy->getKind() == BuiltinType::Half || BTy->getKind() == BuiltinType::Float)) - E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); + E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get(); // C++ performs lvalue-to-rvalue conversion as a default argument // promotion, even on class types, but note: @@ -856,14 +856,14 @@ ExprResult ExprRes = CheckPlaceholderExpr(E); if (ExprRes.isInvalid()) return ExprError(); - E = ExprRes.take(); + E = ExprRes.get(); } } ExprResult ExprRes = DefaultArgumentPromotion(E); if (ExprRes.isInvalid()) return ExprError(); - E = ExprRes.take(); + E = ExprRes.get(); // Diagnostics regarding non-POD argument types are // emitted along with format string checking in Sema::CheckFunctionCall(). @@ -914,12 +914,12 @@ if (SkipCast) return false; if (IntTy->isIntegerType()) { QualType fpTy = cast(ComplexTy)->getElementType(); - IntExpr = S.ImpCastExprToType(IntExpr.take(), fpTy, CK_IntegralToFloating); - IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, + IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating); + IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, CK_FloatingRealToComplex); } else { assert(IntTy->isComplexIntegerType()); - IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, + IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, CK_IntegralComplexToFloatingComplex); } return false; @@ -937,12 +937,12 @@ if (order < 0) { // _Complex float -> _Complex double if (!IsCompAssign) - LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast); + LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingComplexCast); return RHSType; } if (order > 0) // _Complex float -> _Complex double - RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast); + RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingComplexCast); return LHSType; } @@ -963,8 +963,8 @@ // float -> _Complex double if (ConvertOtherExpr) { QualType fp = cast(ComplexTy)->getElementType(); - OtherExpr = S.ImpCastExprToType(OtherExpr.take(), fp, CK_FloatingCast); - OtherExpr = S.ImpCastExprToType(OtherExpr.take(), ComplexTy, + OtherExpr = S.ImpCastExprToType(OtherExpr.get(), fp, CK_FloatingCast); + OtherExpr = S.ImpCastExprToType(OtherExpr.get(), ComplexTy, CK_FloatingRealToComplex); } return ComplexTy; @@ -976,12 +976,12 @@ // double -> _Complex double if (ConvertOtherExpr) - OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result, + OtherExpr = S.ImpCastExprToType(OtherExpr.get(), result, CK_FloatingRealToComplex); // _Complex float -> _Complex double if (ConvertComplexExpr && order < 0) - ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result, + ComplexExpr = S.ImpCastExprToType(ComplexExpr.get(), result, CK_FloatingComplexCast); return result; @@ -1043,7 +1043,7 @@ if (IntTy->isIntegerType()) { if (ConvertInt) // Convert intExpr to the lhs floating point type. - IntExpr = S.ImpCastExprToType(IntExpr.take(), FloatTy, + IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy, CK_IntegralToFloating); return FloatTy; } @@ -1054,12 +1054,12 @@ // _Complex int -> _Complex float if (ConvertInt) - IntExpr = S.ImpCastExprToType(IntExpr.take(), result, + IntExpr = S.ImpCastExprToType(IntExpr.get(), result, CK_IntegralComplexToFloatingComplex); // float -> _Complex float if (ConvertFloat) - FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result, + FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result, CK_FloatingRealToComplex); return result; @@ -1078,13 +1078,13 @@ if (LHSFloat && RHSFloat) { int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); if (order > 0) { - RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast); + RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast); return LHSType; } assert(order < 0 && "illegal float comparison"); if (!IsCompAssign) - LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast); + LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast); return RHSType; } @@ -1126,29 +1126,29 @@ if (LHSSigned == RHSSigned) { // Same signedness; use the higher-ranked type if (order >= 0) { - RHS = (*doRHSCast)(S, RHS.take(), LHSType); + RHS = (*doRHSCast)(S, RHS.get(), LHSType); return LHSType; } else if (!IsCompAssign) - LHS = (*doLHSCast)(S, LHS.take(), RHSType); + LHS = (*doLHSCast)(S, LHS.get(), RHSType); return RHSType; } else if (order != (LHSSigned ? 1 : -1)) { // The unsigned type has greater than or equal rank to the // signed type, so use the unsigned type if (RHSSigned) { - RHS = (*doRHSCast)(S, RHS.take(), LHSType); + RHS = (*doRHSCast)(S, RHS.get(), LHSType); return LHSType; } else if (!IsCompAssign) - LHS = (*doLHSCast)(S, LHS.take(), RHSType); + LHS = (*doLHSCast)(S, LHS.get(), RHSType); return RHSType; } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { // The two types are different widths; if we are here, that // means the signed type is larger than the unsigned type, so // use the signed type. if (LHSSigned) { - RHS = (*doRHSCast)(S, RHS.take(), LHSType); + RHS = (*doRHSCast)(S, RHS.get(), LHSType); return LHSType; } else if (!IsCompAssign) - LHS = (*doLHSCast)(S, LHS.take(), RHSType); + LHS = (*doLHSCast)(S, LHS.get(), RHSType); return RHSType; } else { // The signed type is higher-ranked than the unsigned type, @@ -1157,9 +1157,9 @@ // to the signed type. QualType result = S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); - RHS = (*doRHSCast)(S, RHS.take(), result); + RHS = (*doRHSCast)(S, RHS.get(), result); if (!IsCompAssign) - LHS = (*doLHSCast)(S, LHS.take(), result); + LHS = (*doLHSCast)(S, LHS.get(), result); return result; } } @@ -1189,7 +1189,7 @@ handleIntegerConversion (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign); QualType ComplexType = S.Context.getComplexType(ScalarType); - RHS = S.ImpCastExprToType(RHS.take(), ComplexType, + RHS = S.ImpCastExprToType(RHS.get(), ComplexType, CK_IntegralRealToComplex); return ComplexType; @@ -1204,7 +1204,7 @@ QualType ComplexType = S.Context.getComplexType(ScalarType); if (!IsCompAssign) - LHS = S.ImpCastExprToType(LHS.take(), ComplexType, + LHS = S.ImpCastExprToType(LHS.get(), ComplexType, CK_IntegralRealToComplex); return ComplexType; } @@ -1216,12 +1216,12 @@ QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, bool IsCompAssign) { if (!IsCompAssign) { - LHS = UsualUnaryConversions(LHS.take()); + LHS = UsualUnaryConversions(LHS.get()); if (LHS.isInvalid()) return QualType(); } - RHS = UsualUnaryConversions(RHS.take()); + RHS = UsualUnaryConversions(RHS.get()); if (RHS.isInvalid()) return QualType(); @@ -1253,7 +1253,7 @@ if (!LHSBitfieldPromoteTy.isNull()) LHSType = LHSBitfieldPromoteTy; if (LHSType != LHSUnpromotedType && !IsCompAssign) - LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast); + LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast); // If both types are identical, no conversion is needed. if (LHSType == RHSType) @@ -1325,7 +1325,7 @@ if (ControllingExpr->getType()->isPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(ControllingExpr); if (result.isInvalid()) return ExprError(); - ControllingExpr = result.take(); + ControllingExpr = result.get(); } bool TypeErrorFound = false, @@ -2019,7 +2019,7 @@ if (E.isInvalid()) return ExprError(); - if (Expr *Ex = E.takeAs()) + if (Expr *Ex = E.getAs()) return Owned(Ex); } } @@ -2277,7 +2277,7 @@ if (SelfExpr.isInvalid()) return ExprError(); - SelfExpr = DefaultLvalueConversion(SelfExpr.take()); + SelfExpr = DefaultLvalueConversion(SelfExpr.get()); if (SelfExpr.isInvalid()) return ExprError(); @@ -2290,7 +2290,7 @@ ObjCIvarRefExpr *Result = new (Context) ObjCIvarRefExpr(IV, IV->getType(), Loc, IV->getLocation(), - SelfExpr.take(), + SelfExpr.get(), true, true); if (getLangOpts().ObjCAutoRefCount) { @@ -2450,7 +2450,7 @@ if (PointerConversions) QType = Context.getPointerType(QType); From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, - VK, &BasePath).take(); + VK, &BasePath).get(); FromType = QType; FromRecordType = QRecordType; @@ -2487,7 +2487,7 @@ if (PointerConversions) UType = Context.getPointerType(UType); From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, - VK, &BasePath).take(); + VK, &BasePath).get(); FromType = UType; FromRecordType = URecordType; } @@ -3102,10 +3102,10 @@ if (Ty == Context.DoubleTy) { if (getLangOpts().SinglePrecisionConstants) { - Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); + Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); - Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); + Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); } } } else if (!Literal.isIntegerLiteral()) { @@ -3570,7 +3570,7 @@ if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { PE = TransformToPotentiallyEvaluated(E); if (PE.isInvalid()) return ExprError(); - E = PE.take(); + E = PE.get(); } // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. @@ -3607,7 +3607,7 @@ // _Real and _Imag are only l-values for normal l-values. if (V.get()->getObjectKind() != OK_Ordinary) { - V = S.DefaultLvalueConversion(V.take()); + V = S.DefaultLvalueConversion(V.get()); if (V.isInvalid()) return QualType(); } @@ -3649,7 +3649,7 @@ // Since this might is a postfix expression, get rid of ParenListExprs. ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); if (Result.isInvalid()) return ExprError(); - Input = Result.take(); + Input = Result.get(); return BuildUnaryOp(S, OpLoc, Opc, Input); } @@ -3678,7 +3678,7 @@ if (isa(base)) { ExprResult result = MaybeConvertParenListExprToParenExpr(S, base); if (result.isInvalid()) return ExprError(); - base = result.take(); + base = result.get(); } // Handle any non-overload placeholder types in the base and index @@ -3689,12 +3689,12 @@ if (base->getType()->isNonOverloadPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(base); if (result.isInvalid()) return ExprError(); - base = result.take(); + base = result.get(); } if (idx->getType()->isNonOverloadPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(idx); if (result.isInvalid()) return ExprError(); - idx = result.take(); + idx = result.get(); } // Build an unanalyzed expression if either operand is type-dependent. @@ -3735,12 +3735,12 @@ ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); if (Result.isInvalid()) return ExprError(); - LHSExp = Result.take(); + LHSExp = Result.get(); } ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); if (Result.isInvalid()) return ExprError(); - RHSExp = Result.take(); + RHSExp = Result.get(); QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); ExprValueKind VK = VK_LValue; @@ -3806,7 +3806,7 @@ Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << LHSExp->getSourceRange(); LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), - CK_ArrayToPointerDecay).take(); + CK_ArrayToPointerDecay).get(); LHSTy = LHSExp->getType(); BaseExpr = LHSExp; @@ -3817,7 +3817,7 @@ Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << RHSExp->getSourceRange(); RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), - CK_ArrayToPointerDecay).take(); + CK_ArrayToPointerDecay).get(); RHSTy = RHSExp->getType(); BaseExpr = RHSExp; @@ -3913,14 +3913,14 @@ InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(), /*FIXME:EqualLoc*/UninstExpr->getLocStart()); - Expr *ResultE = Result.takeAs(); + Expr *ResultE = Result.getAs(); InitializationSequence InitSeq(*this, Entity, Kind, ResultE); Result = InitSeq.Perform(*this, Entity, Kind, ResultE); if (Result.isInvalid()) return ExprError(); - Expr *Arg = Result.takeAs(); + Expr *Arg = Result.getAs(); CheckCompletedExpr(Arg, Param->getOuterLocStart()); // Build the default argument expression. return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg)); @@ -4210,7 +4210,7 @@ if (ArgE.isInvalid()) return true; - Arg = ArgE.takeAs(); + Arg = ArgE.getAs(); } else { assert(Param && "can't use default arguments without a known callee"); @@ -4219,7 +4219,7 @@ if (ArgExpr.isInvalid()) return true; - Arg = ArgExpr.takeAs(); + Arg = ArgExpr.getAs(); } // Check for array bounds violations for each argument to the call. This @@ -4243,7 +4243,7 @@ QualType paramType; // ignored ExprResult arg = checkUnknownAnyArg(CallLoc, Args[i], paramType); Invalid |= arg.isInvalid(); - AllArgs.push_back(arg.take()); + AllArgs.push_back(arg.get()); } // Otherwise do argument promotion, (C99 6.5.2.2p7). @@ -4252,7 +4252,7 @@ ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); Invalid |= Arg.isInvalid(); - AllArgs.push_back(Arg.take()); + AllArgs.push_back(Arg.get()); } } @@ -4374,7 +4374,7 @@ if (isPlaceholderToRemoveAsArg(args[i]->getType())) { ExprResult result = S.CheckPlaceholderExpr(args[i]); if (result.isInvalid()) hasInvalid = true; - else args[i] = result.take(); + else args[i] = result.get(); } } return hasInvalid; @@ -4390,7 +4390,7 @@ // Since this might be a postfix expression, get rid of ParenListExprs. ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); if (Result.isInvalid()) return ExprError(); - Fn = Result.take(); + Fn = Result.get(); if (checkArgsForPlaceholders(*this, ArgExprs)) return ExprError(); @@ -4413,7 +4413,7 @@ if (Fn->getType() == Context.PseudoObjectTy) { ExprResult result = CheckPlaceholderExpr(Fn); if (result.isInvalid()) return ExprError(); - Fn = result.take(); + Fn = result.get(); } // Determine whether this is a dependent call inside a C++ template, @@ -4446,7 +4446,7 @@ if (Fn->getType() == Context.UnknownAnyTy) { ExprResult result = rebuildUnknownAnyFunction(*this, Fn); if (result.isInvalid()) return ExprError(); - Fn = result.take(); + Fn = result.get(); } if (Fn->getType() == Context.BoundMemberTy) { @@ -4476,7 +4476,7 @@ if (Fn->getType() == Context.UnknownAnyTy) { ExprResult result = rebuildUnknownAnyFunction(*this, Fn); if (result.isInvalid()) return ExprError(); - Fn = result.take(); + Fn = result.get(); } Expr *NakedFn = Fn->IgnoreParens(); @@ -4583,13 +4583,13 @@ if (BuiltinID && Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) { Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()), - CK_BuiltinFnToFnPtr).take(); + CK_BuiltinFnToFnPtr).get(); } else { Result = CallExprUnaryConversions(Fn); } if (Result.isInvalid()) return ExprError(); - Fn = Result.take(); + Fn = Result.get(); // Make the call expr early, before semantic checks. This guarantees cleanup // of arguments and function on error. @@ -4624,7 +4624,7 @@ if (Fn->getType() == Context.UnknownAnyTy) { ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); if (rewrite.isInvalid()) return ExprError(); - Fn = rewrite.take(); + Fn = rewrite.get(); TheCall->setCallee(Fn); goto retry; } @@ -4699,7 +4699,7 @@ if (ArgE.isInvalid()) return true; - Arg = ArgE.takeAs(); + Arg = ArgE.getAs(); } else { ExprResult ArgE = DefaultArgumentPromotion(Arg); @@ -4707,7 +4707,7 @@ if (ArgE.isInvalid()) return true; - Arg = ArgE.takeAs(); + Arg = ArgE.getAs(); } if (RequireCompleteType(Arg->getLocStart(), @@ -4824,7 +4824,7 @@ // of one failure would be terrible for indexing/etc. if (result.isInvalid()) continue; - InitArgList[I] = result.take(); + InitArgList[I] = result.get(); } } @@ -4931,12 +4931,12 @@ case Type::STK_Floating: return CK_IntegralToFloating; case Type::STK_IntegralComplex: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), DestTy->castAs()->getElementType(), CK_IntegralCast); return CK_IntegralRealToComplex; case Type::STK_FloatingComplex: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), DestTy->castAs()->getElementType(), CK_IntegralToFloating); return CK_FloatingRealToComplex; @@ -4954,12 +4954,12 @@ case Type::STK_Integral: return CK_FloatingToIntegral; case Type::STK_FloatingComplex: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), DestTy->castAs()->getElementType(), CK_FloatingCast); return CK_FloatingRealToComplex; case Type::STK_IntegralComplex: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), DestTy->castAs()->getElementType(), CK_FloatingToIntegral); return CK_IntegralRealToComplex; @@ -4982,13 +4982,13 @@ QualType ET = SrcTy->castAs()->getElementType(); if (Context.hasSameType(ET, DestTy)) return CK_FloatingComplexToReal; - Src = ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); + Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal); return CK_FloatingCast; } case Type::STK_Bool: return CK_FloatingComplexToBoolean; case Type::STK_Integral: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), SrcTy->castAs()->getElementType(), CK_FloatingComplexToReal); return CK_FloatingToIntegral; @@ -5011,13 +5011,13 @@ QualType ET = SrcTy->castAs()->getElementType(); if (Context.hasSameType(ET, DestTy)) return CK_IntegralComplexToReal; - Src = ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); + Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal); return CK_IntegralCast; } case Type::STK_Bool: return CK_IntegralComplexToBoolean; case Type::STK_Floating: - Src = ImpCastExprToType(Src.take(), + Src = ImpCastExprToType(Src.get(), SrcTy->castAs()->getElementType(), CK_IntegralComplexToReal); return CK_IntegralToFloating; @@ -5132,7 +5132,7 @@ CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); if (CastExprRes.isInvalid()) return ExprError(); - CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); + CastExpr = ImpCastExprToType(CastExprRes.get(), DestElemTy, CK).get(); Kind = CK_VectorSplat; return Owned(CastExpr); @@ -5191,7 +5191,7 @@ if (isa(CastExpr)) { ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); if (Result.isInvalid()) return ExprError(); - CastExpr = Result.take(); + CastExpr = Result.get(); } if (getLangOpts().CPlusPlus && !castType->isVoidType() && @@ -5246,9 +5246,9 @@ ExprResult Literal = DefaultLvalueConversion(exprs[0]); if (Literal.isInvalid()) return ExprError(); - Literal = ImpCastExprToType(Literal.take(), ElemTy, + Literal = ImpCastExprToType(Literal.get(), ElemTy, PrepareScalarCast(Literal, ElemTy)); - return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); + return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); } else if (numExprs < numElems) { Diag(E->getExprLoc(), @@ -5268,9 +5268,9 @@ ExprResult Literal = DefaultLvalueConversion(exprs[0]); if (Literal.isInvalid()) return ExprError(); - Literal = ImpCastExprToType(Literal.take(), ElemTy, + Literal = ImpCastExprToType(Literal.get(), ElemTy, PrepareScalarCast(Literal, ElemTy)); - return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); + return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); } initExprs.append(exprs, exprs + numExprs); @@ -5387,8 +5387,8 @@ } // Implicity convert these scalars to the type of the condition. - LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); - RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); + LHS = S.ImpCastExprToType(LHS.get(), CondTy, CK_IntegralCast); + RHS = S.ImpCastExprToType(RHS.get(), CondTy, CK_IntegralCast); return false; } @@ -5404,8 +5404,8 @@ if (!RHSExpr->getType()->isVoidType()) S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) << LHSExpr->getSourceRange(); - LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid); - RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid); + LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid); + RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid); return S.Context.VoidTy; } @@ -5418,7 +5418,7 @@ Expr::NPC_ValueDependentIsNull)) return true; - NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer); + NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer); return false; } @@ -5477,8 +5477,8 @@ // reason, but this is what gcc does, and we do have to pick // to get a consistent AST. QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); - LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); - RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); + LHS = S.ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); + RHS = S.ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); return incompatTy; } @@ -5489,8 +5489,8 @@ else ResultTy = S.Context.getPointerType(ResultTy); - LHS = S.ImpCastExprToType(LHS.take(), ResultTy, CK_BitCast); - RHS = S.ImpCastExprToType(RHS.take(), ResultTy, CK_BitCast); + LHS = S.ImpCastExprToType(LHS.get(), ResultTy, CK_BitCast); + RHS = S.ImpCastExprToType(RHS.get(), ResultTy, CK_BitCast); return ResultTy; } @@ -5505,8 +5505,8 @@ if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { QualType destType = S.Context.getPointerType(S.Context.VoidTy); - LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); - RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); + LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); + RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); return destType; } S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) @@ -5539,9 +5539,9 @@ = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); QualType destType = S.Context.getPointerType(destPointee); // Add qualifiers if necessary. - LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp); + LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp); // Promote to void*. - RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); + RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); return destType; } if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { @@ -5549,9 +5549,9 @@ = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); QualType destType = S.Context.getPointerType(destPointee); // Add qualifiers if necessary. - RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp); + RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp); // Promote to void*. - LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); + LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); return destType; } @@ -5573,7 +5573,7 @@ S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch) << Expr1->getType() << Expr2->getType() << Expr1->getSourceRange() << Expr2->getSourceRange(); - Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(), + Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(), CK_IntegralToPointer); return true; } @@ -5602,7 +5602,7 @@ OK = OK_Ordinary; // First, check the condition. - Cond = UsualUnaryConversions(Cond.take()); + Cond = UsualUnaryConversions(Cond.get()); if (Cond.isInvalid()) return QualType(); if (checkCondition(*this, Cond.get())) @@ -5708,34 +5708,34 @@ // redefinition type if an attempt is made to access its fields. if (LHSTy->isObjCClassType() && (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { - RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); + RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); return LHSTy; } if (RHSTy->isObjCClassType() && (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { - LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); + LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); return RHSTy; } // And the same for struct objc_object* / id if (LHSTy->isObjCIdType() && (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { - RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); + RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); return LHSTy; } if (RHSTy->isObjCIdType() && (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { - LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); + LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); return RHSTy; } // And the same for struct objc_selector* / SEL if (Context.isObjCSelType(LHSTy) && (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { - RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast); return LHSTy; } if (Context.isObjCSelType(RHSTy) && (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { - LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast); return RHSTy; } // Check constraints for Objective-C object pointers types. @@ -5784,13 +5784,13 @@ << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); QualType incompatTy = Context.getObjCIdType(); - LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); - RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); return incompatTy; } // The object pointer types are compatible. - LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); - RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast); return compositeType; } // Check Objective-C object pointer types and 'void *' @@ -5809,9 +5809,9 @@ = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); QualType destType = Context.getPointerType(destPointee); // Add qualifiers if necessary. - LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); + LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp); // Promote to void*. - RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast); return destType; } if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { @@ -5829,9 +5829,9 @@ = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); QualType destType = Context.getPointerType(destPointee); // Add qualifiers if necessary. - RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); + RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp); // Promote to void*. - LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast); return destType; } return QualType(); @@ -5973,7 +5973,7 @@ if (commonExpr->hasPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(commonExpr); if (!result.isUsable()) return ExprError(); - commonExpr = result.take(); + commonExpr = result.get(); } // We usually want to apply unary conversions *before* saving, except // in the special case of a C++ l-value conditional. @@ -5987,7 +5987,7 @@ ExprResult commonRes = UsualUnaryConversions(commonExpr); if (commonRes.isInvalid()) return ExprError(); - commonExpr = commonRes.take(); + commonExpr = commonRes.get(); } opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), @@ -6011,13 +6011,13 @@ RHS.get()); if (!commonExpr) - return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, - LHS.take(), ColonLoc, - RHS.take(), result, VK, OK)); + return Owned(new (Context) ConditionalOperator(Cond.get(), QuestionLoc, + LHS.get(), ColonLoc, + RHS.get(), result, VK, OK)); return Owned(new (Context) - BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), - RHS.take(), QuestionLoc, ColonLoc, result, VK, + BinaryConditionalOperator(commonExpr, opaqueValue, Cond.get(), LHS.get(), + RHS.get(), QuestionLoc, ColonLoc, result, VK, OK)); } @@ -6270,7 +6270,7 @@ if (result != Compatible) return result; if (Kind != CK_NoOp) - RHS = ImpCastExprToType(RHS.take(), AtomicTy->getValueType(), Kind); + RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind); Kind = CK_NonAtomicToAtomic; return Compatible; } @@ -6301,7 +6301,7 @@ QualType elType = cast(LHSType)->getElementType(); if (elType != RHSType) { Kind = PrepareScalarCast(RHS, elType); - RHS = ImpCastExprToType(RHS.take(), elType, Kind); + RHS = ImpCastExprToType(RHS.get(), elType, Kind); } Kind = CK_VectorSplat; return Compatible; @@ -6514,7 +6514,7 @@ FieldDecl *Field) { // Build an initializer list that designates the appropriate member // of the transparent union. - Expr *E = EResult.take(); + Expr *E = EResult.get(); InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), E, SourceLocation()); Initializer->setType(UnionType); @@ -6550,14 +6550,14 @@ // 2) null pointer constant if (RHSType->isPointerType()) if (RHSType->castAs()->getPointeeType()->isVoidType()) { - RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast); InitField = it; break; } if (RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { - RHS = ImpCastExprToType(RHS.take(), it->getType(), + RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_NullToPointer); InitField = it; break; @@ -6567,7 +6567,7 @@ CastKind Kind = CK_Invalid; if (CheckAssignmentConstraints(it->getType(), RHS, Kind) == Compatible) { - RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind); + RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind); InitField = it; break; } @@ -6632,7 +6632,7 @@ CastKind Kind; CXXCastPath Path; CheckPointerConversion(RHS.get(), LHSType, Kind, Path, false); - RHS = ImpCastExprToType(RHS.take(), LHSType, Kind, VK_RValue, &Path); + RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path); return Compatible; } @@ -6643,7 +6643,7 @@ // // Suppress this for references: C++ 8.5.3p5. if (!LHSType->isReferenceType()) { - RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); + RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); if (RHS.isInvalid()) return Incompatible; } @@ -6660,7 +6660,7 @@ // does not have reference type. if (result != Incompatible && RHS.get()->getType() != LHSType) { QualType Ty = LHSType.getNonLValueExprType(Context); - Expr *E = RHS.take(); + Expr *E = RHS.get(); if (getLangOpts().ObjCAutoRefCount) CheckObjCARCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion, DiagnoseCFAudited); @@ -6726,8 +6726,8 @@ // Adjust scalar if desired. if (scalar) { if (scalarCast != CK_Invalid) - *scalar = S.ImpCastExprToType(scalar->take(), vectorEltTy, scalarCast); - *scalar = S.ImpCastExprToType(scalar->take(), vectorTy, CK_VectorSplat); + *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast); + *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat); } return false; } @@ -6735,11 +6735,11 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { if (!IsCompAssign) { - LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); + LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); if (LHS.isInvalid()) return QualType(); } - RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); + RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); if (RHS.isInvalid()) return QualType(); @@ -6760,12 +6760,12 @@ if (LHSVecType && RHSVecType && Context.areCompatibleVectorTypes(LHSType, RHSType)) { if (isa(LHSVecType)) { - RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); return LHSType; } if (!IsCompAssign) - LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); return RHSType; } @@ -6789,7 +6789,7 @@ // FIXME: We really just pick the LHS type arbitrarily? if (isLaxVectorConversion(RHSType, LHSType)) { QualType resultType = LHSType; - RHS = ImpCastExprToType(RHS.take(), resultType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), resultType, CK_BitCast); return resultType; } @@ -7402,14 +7402,14 @@ // For the LHS, do usual unary conversions, but then reset them away // if this is a compound assignment. ExprResult OldLHS = LHS; - LHS = UsualUnaryConversions(LHS.take()); + LHS = UsualUnaryConversions(LHS.get()); if (LHS.isInvalid()) return QualType(); QualType LHSType = LHS.get()->getType(); if (IsCompAssign) LHS = OldLHS; // The RHS is simpler. - RHS = UsualUnaryConversions(RHS.take()); + RHS = UsualUnaryConversions(RHS.get()); if (RHS.isInvalid()) return QualType(); QualType RHSType = RHS.get()->getType(); @@ -7521,8 +7521,8 @@ << LHSType << RHSType << T << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); - LHS = S.ImpCastExprToType(LHS.take(), T, CK_BitCast); - RHS = S.ImpCastExprToType(RHS.take(), T, CK_BitCast); + LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast); + RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast); return false; } @@ -7911,7 +7911,7 @@ if (isSFINAEContext()) return QualType(); - RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); return ResultTy; } } @@ -7947,9 +7947,9 @@ CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast; if (LHSIsNull && !RHSIsNull) - LHS = ImpCastExprToType(LHS.take(), RHSType, Kind); + LHS = ImpCastExprToType(LHS.get(), RHSType, Kind); else - RHS = ImpCastExprToType(RHS.take(), LHSType, Kind); + RHS = ImpCastExprToType(RHS.get(), LHSType, Kind); } return ResultTy; } @@ -7965,7 +7965,7 @@ ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || (!IsRelational && (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { - RHS = ImpCastExprToType(RHS.take(), LHSType, + RHS = ImpCastExprToType(RHS.get(), LHSType, LHSType->isMemberPointerType() ? CK_NullToMemberPointer : CK_NullToPointer); @@ -7975,7 +7975,7 @@ ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || (!IsRelational && (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { - LHS = ImpCastExprToType(LHS.take(), RHSType, + LHS = ImpCastExprToType(LHS.get(), RHSType, RHSType->isMemberPointerType() ? CK_NullToMemberPointer : CK_NullToPointer); @@ -8011,7 +8011,7 @@ << LHSType << RHSType << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); } - RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); return ResultTy; } @@ -8029,11 +8029,11 @@ << RHS.get()->getSourceRange(); } if (LHSIsNull && !RHSIsNull) - LHS = ImpCastExprToType(LHS.take(), RHSType, + LHS = ImpCastExprToType(LHS.get(), RHSType, RHSType->isPointerType() ? CK_BitCast : CK_AnyPointerToBlockPointerCast); else - RHS = ImpCastExprToType(RHS.take(), LHSType, + RHS = ImpCastExprToType(RHS.get(), LHSType, LHSType->isPointerType() ? CK_BitCast : CK_AnyPointerToBlockPointerCast); return ResultTy; @@ -8053,14 +8053,14 @@ /*isError*/false); } if (LHSIsNull && !RHSIsNull) { - Expr *E = LHS.take(); + Expr *E = LHS.get(); if (getLangOpts().ObjCAutoRefCount) CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion); LHS = ImpCastExprToType(E, RHSType, RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); } else { - Expr *E = RHS.take(); + Expr *E = RHS.get(); if (getLangOpts().ObjCAutoRefCount) CheckObjCARCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion); RHS = ImpCastExprToType(E, LHSType, @@ -8077,9 +8077,9 @@ diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc); if (LHSIsNull && !RHSIsNull) - LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); + LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); else - RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); + RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); return ResultTy; } } @@ -8111,10 +8111,10 @@ } if (LHSType->isIntegerType()) - LHS = ImpCastExprToType(LHS.take(), RHSType, + LHS = ImpCastExprToType(LHS.get(), RHSType, LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); else - RHS = ImpCastExprToType(RHS.take(), LHSType, + RHS = ImpCastExprToType(RHS.get(), LHSType, RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); return ResultTy; } @@ -8122,12 +8122,12 @@ // Handle block pointers. if (!IsRelational && RHSIsNull && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { - RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); + RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer); return ResultTy; } if (!IsRelational && LHSIsNull && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { - LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer); + LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer); return ResultTy; } @@ -8233,8 +8233,8 @@ IsCompAssign); if (LHSResult.isInvalid() || RHSResult.isInvalid()) return QualType(); - LHS = LHSResult.take(); - RHS = RHSResult.take(); + LHS = LHSResult.get(); + RHS = RHSResult.get(); if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType()) return compType; @@ -8297,11 +8297,11 @@ return InvalidOperands(Loc, LHS, RHS); } - LHS = UsualUnaryConversions(LHS.take()); + LHS = UsualUnaryConversions(LHS.get()); if (LHS.isInvalid()) return QualType(); - RHS = UsualUnaryConversions(RHS.take()); + RHS = UsualUnaryConversions(RHS.get()); if (RHS.isInvalid()) return QualType(); @@ -8616,8 +8616,8 @@ // C99 6.5.17 static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc) { - LHS = S.CheckPlaceholderExpr(LHS.take()); - RHS = S.CheckPlaceholderExpr(RHS.take()); + LHS = S.CheckPlaceholderExpr(LHS.get()); + RHS = S.CheckPlaceholderExpr(RHS.get()); if (LHS.isInvalid() || RHS.isInvalid()) return QualType(); @@ -8627,14 +8627,14 @@ // So we treat the LHS as a ignored value, and in C++ we allow the // containing site to determine what should be done with the RHS. - LHS = S.IgnoredValueConversions(LHS.take()); + LHS = S.IgnoredValueConversions(LHS.get()); if (LHS.isInvalid()) return QualType(); S.DiagnoseUnusedExprResult(LHS.get()); if (!S.getLangOpts().CPlusPlus) { - RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); + RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get()); if (RHS.isInvalid()) return QualType(); if (!RHS.get()->getType()->isVoidType()) @@ -8694,7 +8694,7 @@ } else if (ResType->isPlaceholderType()) { ExprResult PR = S.CheckPlaceholderExpr(Op); if (PR.isInvalid()) return QualType(); - return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, + return CheckIncrementDecrementOperand(S, PR.get(), VK, OpLoc, IsInc, IsPrefix); } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) @@ -8835,7 +8835,7 @@ return QualType(); } - OrigOp = CheckPlaceholderExpr(OrigOp.take()); + OrigOp = CheckPlaceholderExpr(OrigOp.get()); if (OrigOp.isInvalid()) return QualType(); } @@ -8877,7 +8877,7 @@ return QualType(); // Materialize the temporary as an lvalue so that we can take its address. OrigOp = op = new (Context) - MaterializeTemporaryExpr(op->getType(), OrigOp.take(), true); + MaterializeTemporaryExpr(op->getType(), OrigOp.get(), true); } else if (isa(op)) { return Context.getPointerType(op->getType()); } else if (lval == Expr::LV_MemberFunction) { @@ -9008,7 +9008,7 @@ ExprResult ConvResult = S.UsualUnaryConversions(Op); if (ConvResult.isInvalid()) return QualType(); - Op = ConvResult.take(); + Op = ConvResult.get(); QualType OpTy = Op->getType(); QualType Result; @@ -9026,8 +9026,8 @@ else { ExprResult PR = S.CheckPlaceholderExpr(Op); if (PR.isInvalid()) return QualType(); - if (PR.take() != Op) - return CheckIndirectionOperand(S, PR.take(), VK, OpLoc); + if (PR.get() != Op) + return CheckIndirectionOperand(S, PR.get(), VK, OpLoc); } if (Result.isNull()) { @@ -9218,7 +9218,7 @@ ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr); if (Init.isInvalid()) return Init; - RHSExpr = Init.take(); + RHSExpr = Init.get(); } ExprResult LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); @@ -9356,7 +9356,7 @@ DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get()); if (CompResultTy.isNull()) - return Owned(new (Context) BinaryOperator(LHS.take(), RHS.take(), Opc, + return Owned(new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc, FPFeatures.fp_contract)); if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() != @@ -9364,7 +9364,7 @@ VK = VK_LValue; OK = LHS.get()->getObjectKind(); } - return Owned(new (Context) CompoundAssignOperator(LHS.take(), RHS.take(), Opc, + return Owned(new (Context) CompoundAssignOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy, OpLoc, FPFeatures.fp_contract)); @@ -9639,7 +9639,7 @@ // instantiates to having an overloadable type. ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); if (resolvedRHS.isInvalid()) return ExprError(); - RHSExpr = resolvedRHS.take(); + RHSExpr = resolvedRHS.get(); if (RHSExpr->isTypeDependent() || RHSExpr->getType()->isOverloadableType()) @@ -9648,7 +9648,7 @@ ExprResult LHS = CheckPlaceholderExpr(LHSExpr); if (LHS.isInvalid()) return ExprError(); - LHSExpr = LHS.take(); + LHSExpr = LHS.get(); } // Handle pseudo-objects in the RHS. @@ -9672,7 +9672,7 @@ ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); if (!resolvedRHS.isUsable()) return ExprError(); - RHSExpr = resolvedRHS.take(); + RHSExpr = resolvedRHS.get(); } if (getLangOpts().CPlusPlus) { @@ -9714,14 +9714,14 @@ resultType = CheckAddressOfOperand(Input, OpLoc); break; case UO_Deref: { - Input = DefaultFunctionArrayLvalueConversion(Input.take()); + Input = DefaultFunctionArrayLvalueConversion(Input.get()); if (Input.isInvalid()) return ExprError(); resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); break; } case UO_Plus: case UO_Minus: - Input = UsualUnaryConversions(Input.take()); + Input = UsualUnaryConversions(Input.get()); if (Input.isInvalid()) return ExprError(); resultType = Input.get()->getType(); if (resultType->isDependentType()) @@ -9738,7 +9738,7 @@ << resultType << Input.get()->getSourceRange()); case UO_Not: // bitwise complement - Input = UsualUnaryConversions(Input.take()); + Input = UsualUnaryConversions(Input.get()); if (Input.isInvalid()) return ExprError(); resultType = Input.get()->getType(); @@ -9769,13 +9769,13 @@ case UO_LNot: // logical negation // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). - Input = DefaultFunctionArrayLvalueConversion(Input.take()); + Input = DefaultFunctionArrayLvalueConversion(Input.get()); if (Input.isInvalid()) return ExprError(); resultType = Input.get()->getType(); // Though we still have to promote half FP to float... if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) { - Input = ImpCastExprToType(Input.take(), Context.FloatTy, CK_FloatingCast).take(); + Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get(); resultType = Context.FloatTy; } @@ -9786,7 +9786,7 @@ if (Context.getLangOpts().CPlusPlus) { // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: // operand contextually converted to bool. - Input = ImpCastExprToType(Input.take(), Context.BoolTy, + Input = ImpCastExprToType(Input.get(), Context.BoolTy, ScalarTypeToBooleanCastKind(resultType)); } else if (Context.getLangOpts().OpenCL && Context.getLangOpts().OpenCLVersion < 120) { @@ -9830,7 +9830,7 @@ VK = Input.get()->getValueKind(); } else if (!getLangOpts().CPlusPlus) { // In C, a volatile scalar is read by __imag. In C++, it is not. - Input = DefaultLvalueConversion(Input.take()); + Input = DefaultLvalueConversion(Input.get()); } break; case UO_Extension: @@ -9849,7 +9849,7 @@ if (Opc != UO_AddrOf && Opc != UO_Deref) CheckArrayAccess(Input.get()); - return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType, + return Owned(new (Context) UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc)); } @@ -9920,7 +9920,7 @@ // Anything else needs to be handled now. ExprResult Result = CheckPlaceholderExpr(Input); if (Result.isInvalid()) return ExprError(); - Input = Result.take(); + Input = Result.get(); } if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() && @@ -10056,9 +10056,9 @@ return ExprError(); if (LastExpr.get() != nullptr) { if (!LastLabelStmt) - Compound->setLastStmt(LastExpr.take()); + Compound->setLastStmt(LastExpr.get()); else - LastLabelStmt->setSubStmt(LastExpr.take()); + LastLabelStmt->setSubStmt(LastExpr.get()); StmtExprMayBindToTemp = true; } } @@ -10125,7 +10125,7 @@ ExprResult IdxRval = DefaultLvalueConversion(static_cast(OC.U.E)); if (IdxRval.isInvalid()) return ExprError(); - Expr *Idx = IdxRval.take(); + Expr *Idx = IdxRval.get(); // The expression must be an integral expression. // FIXME: An integral constant expression? @@ -10290,7 +10290,7 @@ diag::err_typecheck_choose_expr_requires_constant, false); if (CondICE.isInvalid()) return ExprError(); - CondExpr = CondICE.take(); + CondExpr = CondICE.get(); CondIsTrue = condEval.getZExtValue(); // If the condition is > zero, then the AST type is the same as the LSHExpr. @@ -10612,7 +10612,7 @@ ExprResult Result = UsualUnaryConversions(E); if (Result.isInvalid()) return ExprError(); - E = Result.take(); + E = Result.get(); } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) { // If va_list is a record type and we are compiling in C++ mode, // check the argument using reference binding. @@ -10622,7 +10622,7 @@ ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E); if (Init.isInvalid()) return ExprError(); - E = Init.takeAs(); + E = Init.getAs(); } else { // Otherwise, the va_list argument must be an l-value because // it is modified by va_arg. @@ -10728,7 +10728,7 @@ return false; Diag(SL->getLocStart(), diag::err_missing_atsign_prefix) << FixItHint::CreateInsertion(SL->getLocStart(), "@"); - Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).take(); + Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).get(); return true; } @@ -11004,7 +11004,7 @@ ConvertDiagnoser); if (Converted.isInvalid()) return Converted; - E = Converted.take(); + E = Converted.get(); if (!E->getType()->isIntegralOrUnscopedEnumerationType()) return ExprError(); } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { @@ -11656,7 +11656,7 @@ !cast(Result.get())->getConstructor() ->isTrivial()) { Result = S.MaybeCreateExprWithCleanups(Result); - CopyExpr = Result.take(); + CopyExpr = Result.get(); } } } @@ -11788,20 +11788,20 @@ = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); assert(!IterationVarRef.isInvalid() && "Reference to invented variable cannot fail!"); - IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.take()); + IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.get()); assert(!IterationVarRef.isInvalid() && "Conversion of invented variable cannot fail!"); // Subscript the array with this iteration variable. ExprResult Subscript = S.CreateBuiltinArraySubscriptExpr( - Ref, Loc, IterationVarRef.take(), Loc); + Ref, Loc, IterationVarRef.get(), Loc); if (Subscript.isInvalid()) { S.CleanupVarDeclMarking(); S.DiscardCleanupsInEvaluationContext(); return ExprError(); } - Ref = Subscript.take(); + Ref = Subscript.get(); BaseType = Array->getElementType(); } @@ -11922,7 +11922,7 @@ CaptureType, DeclRefType, Loc, RefersToEnclosingLocal); if (!Result.isInvalid()) - CopyExpr = Result.take(); + CopyExpr = Result.get(); } // Compute the type of a reference to this captured variable. @@ -12692,7 +12692,7 @@ ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return ExprError(); - E = result.take(); + E = result.get(); if (!E->isTypeDependent()) { if (getLangOpts().CPlusPlus) @@ -12701,7 +12701,7 @@ ExprResult ERes = DefaultFunctionArrayLvalueConversion(E); if (ERes.isInvalid()) return ExprError(); - E = ERes.take(); + E = ERes.get(); QualType T = E->getType(); if (!T->isScalarType()) { // C99 6.8.4.1p1 @@ -12748,7 +12748,7 @@ ExprResult SubResult = Visit(E->getSubExpr()); if (SubResult.isInvalid()) return ExprError(); - Expr *SubExpr = SubResult.take(); + Expr *SubExpr = SubResult.get(); E->setSubExpr(SubExpr); E->setType(SubExpr->getType()); E->setValueKind(SubExpr->getValueKind()); @@ -12768,7 +12768,7 @@ ExprResult SubResult = Visit(E->getSubExpr()); if (SubResult.isInvalid()) return ExprError(); - Expr *SubExpr = SubResult.take(); + Expr *SubExpr = SubResult.get(); E->setSubExpr(SubExpr); E->setType(S.Context.getPointerType(SubExpr->getType())); assert(E->getValueKind() == VK_RValue); @@ -12805,7 +12805,7 @@ static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) { ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr); if (Result.isInvalid()) return ExprError(); - return S.DefaultFunctionArrayConversion(Result.take()); + return S.DefaultFunctionArrayConversion(Result.get()); } namespace { @@ -12842,7 +12842,7 @@ template ExprResult rebuildSugarExpr(T *E) { ExprResult SubResult = Visit(E->getSubExpr()); if (SubResult.isInvalid()) return ExprError(); - Expr *SubExpr = SubResult.take(); + Expr *SubExpr = SubResult.get(); E->setSubExpr(SubExpr); E->setType(SubExpr->getType()); E->setValueKind(SubExpr->getValueKind()); @@ -12873,7 +12873,7 @@ DestType = Ptr->getPointeeType(); ExprResult SubResult = Visit(E->getSubExpr()); if (SubResult.isInvalid()) return ExprError(); - E->setSubExpr(SubResult.take()); + E->setSubExpr(SubResult.get()); return E; } @@ -12995,7 +12995,7 @@ // Finally, we can recurse. ExprResult CalleeResult = Visit(CalleeExpr); if (!CalleeResult.isUsable()) return ExprError(); - E->setCallee(CalleeResult.take()); + E->setCallee(CalleeResult.get()); // Bind a temporary if necessary. return S.MaybeBindToTemporary(E); @@ -13036,7 +13036,7 @@ ExprResult Result = Visit(E->getSubExpr()); if (!Result.isUsable()) return ExprError(); - E->setSubExpr(Result.take()); + E->setSubExpr(Result.get()); return S.Owned(E); } else if (E->getCastKind() == CK_LValueToRValue) { assert(E->getValueKind() == VK_RValue); @@ -13052,7 +13052,7 @@ ExprResult Result = Visit(E->getSubExpr()); if (!Result.isUsable()) return ExprError(); - E->setSubExpr(Result.take()); + E->setSubExpr(Result.get()); return S.Owned(E); } else { llvm_unreachable("Unhandled cast type!"); @@ -13071,7 +13071,7 @@ DestType = Ptr->getPointeeType(); ExprResult Result = resolveDecl(E, VD); if (Result.isInvalid()) return ExprError(); - return S.ImpCastExprToType(Result.take(), Type, + return S.ImpCastExprToType(Result.get(), Type, CK_FunctionToPointerDecay, VK_RValue); } @@ -13125,7 +13125,7 @@ ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr); if (!result.isUsable()) return ExprError(); - CastExpr = result.take(); + CastExpr = result.get(); VK = CastExpr->getValueKind(); CastKind = CK_NoOp; Index: lib/Sema/SemaExprCXX.cpp =================================================================== --- lib/Sema/SemaExprCXX.cpp +++ lib/Sema/SemaExprCXX.cpp @@ -393,7 +393,7 @@ if (E->getType()->isPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return ExprError(); - E = result.take(); + E = result.get(); } QualType T = E->getType(); @@ -414,7 +414,7 @@ // and recheck the subexpression. ExprResult Result = TransformToPotentiallyEvaluated(E); if (Result.isInvalid()) return ExprError(); - E = Result.take(); + E = Result.get(); // We require a vtable to query the type at run time. MarkVTableUsed(TypeidLoc, RecordD); @@ -430,7 +430,7 @@ QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals); if (!Context.hasSameType(T, UnqualT)) { T = UnqualT; - E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).take(); + E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get(); } } @@ -626,7 +626,7 @@ ExprResult ExRes = CheckCXXThrowOperand(OpLoc, Ex, IsThrownVarInScope); if (ExRes.isInvalid()) return ExprError(); - Ex = ExRes.take(); + Ex = ExRes.get(); } return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc, @@ -644,12 +644,12 @@ // or "pointer to function returning T", [...] if (E->getType().hasQualifiers()) E = ImpCastExprToType(E, E->getType().getUnqualifiedType(), CK_NoOp, - E->getValueKind()).take(); + E->getValueKind()).get(); ExprResult Res = DefaultFunctionArrayConversion(E); if (Res.isInvalid()) return ExprError(); - E = Res.take(); + E = Res.get(); // If the type of the exception would be an incomplete type or a pointer // to an incomplete type other than (cv) void the program is ill-formed. @@ -697,7 +697,7 @@ IsThrownVarInScope); if (Res.isInvalid()) return ExprError(); - E = Res.take(); + E = Res.get(); // If the exception has class type, we need additional handling. const RecordType *RecordTy = Ty->getAs(); @@ -958,7 +958,7 @@ QualType ResultType = Result.get()->getType(); Result = Owned(CXXFunctionalCastExpr::Create( Context, ResultType, Expr::getValueKindForType(TInfo->getType()), TInfo, - CK_NoOp, Result.take(), /*Path=*/ nullptr, LParenLoc, RParenLoc)); + CK_NoOp, Result.get(), /*Path=*/ nullptr, LParenLoc, RParenLoc)); } // FIXME: Improve AST representation? @@ -1082,12 +1082,12 @@ Array.NumElts = CheckConvertedConstantExpression(NumElts, Context.getSizeType(), Value, CCEK_NewExpr) - .take(); + .get(); } else { Array.NumElts = VerifyIntegerConstantExpression(NumElts, nullptr, diag::err_new_array_nonconst) - .take(); + .get(); } if (!Array.NumElts) return ExprError(); @@ -1243,7 +1243,7 @@ if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(ArraySize); if (result.isInvalid()) return ExprError(); - ArraySize = result.take(); + ArraySize = result.get(); } // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have // integral or enumeration type with a non-negative value." @@ -1325,7 +1325,7 @@ if (ConvertedSize.isInvalid()) return ExprError(); - ArraySize = ConvertedSize.take(); + ArraySize = ConvertedSize.get(); QualType SizeType = ArraySize->getType(); if (!SizeType->isIntegralOrUnscopedEnumerationType()) @@ -1503,7 +1503,7 @@ dyn_cast_or_null(FullInit.get())) FullInit = Owned(Binder->getSubExpr()); - Initializer = FullInit.take(); + Initializer = FullInit.get(); } // Mark the new and delete operators as referenced. @@ -2248,7 +2248,7 @@ if (!Ex.get()->isTypeDependent()) { // Perform lvalue-to-rvalue cast, if needed. - Ex = DefaultLvalueConversion(Ex.take()); + Ex = DefaultLvalueConversion(Ex.get()); if (Ex.isInvalid()) return ExprError(); @@ -2307,7 +2307,7 @@ } } Converter; - Ex = PerformContextualImplicitConversion(StartLoc, Ex.take(), Converter); + Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter); if (Ex.isInvalid()) return ExprError(); Type = Ex.get()->getType(); @@ -2435,7 +2435,7 @@ return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten, UsualArrayDeleteWantsSize, - OperatorDelete, Ex.take(), StartLoc)); + OperatorDelete, Ex.get(), StartLoc)); } /// \brief Check the use of the given variable as a C++ condition in an if, @@ -2471,7 +2471,7 @@ MarkDeclRefReferenced(cast(Condition.get())); if (ConvertToBoolean) { - Condition = CheckBooleanCondition(Condition.take(), StmtLoc); + Condition = CheckBooleanCondition(Condition.get(), StmtLoc); if (Condition.isInvalid()) return ExprError(); } @@ -2564,7 +2564,7 @@ if (Result.isInvalid()) return ExprError(); - return S.MaybeBindToTemporary(Result.takeAs()); + return S.MaybeBindToTemporary(Result.getAs()); } case CK_UserDefinedConversion: { @@ -2606,7 +2606,7 @@ Action, CCK); if (Res.isInvalid()) return ExprError(); - From = Res.take(); + From = Res.get(); break; } @@ -2642,7 +2642,7 @@ CCK); if (Res.isInvalid()) return ExprError(); - From = Res.take(); + From = Res.get(); } ExprResult CastArg @@ -2657,7 +2657,7 @@ if (CastArg.isInvalid()) return ExprError(); - From = CastArg.take(); + From = CastArg.get(); return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, AA_Converting, CCK); @@ -2757,20 +2757,20 @@ FromType = FromType.getUnqualifiedType(); ExprResult FromRes = DefaultLvalueConversion(From); assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!"); - From = FromRes.take(); + From = FromRes.get(); break; } case ICK_Array_To_Pointer: FromType = Context.getArrayDecayedType(FromType); From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*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).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; default: @@ -2794,7 +2794,7 @@ return ExprError(); From = ImpCastExprToType(From, ToType, CK_NoOp, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Integral_Promotion: @@ -2804,17 +2804,17 @@ 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).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); } else { From = ImpCastExprToType(From, ToType, CK_IntegralCast, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); } break; case ICK_Floating_Promotion: case ICK_Floating_Conversion: From = ImpCastExprToType(From, ToType, CK_FloatingCast, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Complex_Promotion: @@ -2833,22 +2833,22 @@ CK = CK_IntegralComplexCast; } From = ImpCastExprToType(From, ToType, CK, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; } case ICK_Floating_Integral: if (ToType->isRealFloatingType()) From = ImpCastExprToType(From, ToType, CK_IntegralToFloating, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); else From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Compatible_Conversion: From = ImpCastExprToType(From, ToType, CK_NoOp, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Writeback_Conversion: @@ -2893,12 +2893,12 @@ if (Kind == CK_BlockPointerToObjCPointerCast) { ExprResult E = From; (void) PrepareCastToObjCObjectPointer(E); - From = E.take(); + From = E.get(); } if (getLangOpts().ObjCAutoRefCount) CheckObjCARCConversion(SourceRange(), ToType, From, CCK); From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK) - .take(); + .get(); break; } @@ -2910,20 +2910,20 @@ if (CheckExceptionSpecCompatibility(From, ToType)) return ExprError(); From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK) - .take(); + .get(); break; } case ICK_Boolean_Conversion: // Perform half-to-boolean conversion via float. if (From->getType()->isHalfType()) { - From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).take(); + From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get(); FromType = Context.FloatTy; } From = ImpCastExprToType(From, Context.BoolTy, ScalarTypeToBooleanCastKind(FromType), - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Derived_To_Base: { @@ -2938,18 +2938,18 @@ From = ImpCastExprToType(From, ToType.getNonReferenceType(), CK_DerivedToBase, From->getValueKind(), - &BasePath, CCK).take(); + &BasePath, CCK).get(); break; } case ICK_Vector_Conversion: From = ImpCastExprToType(From, ToType, CK_BitCast, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Vector_Splat: From = ImpCastExprToType(From, ToType, CK_VectorSplat, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; case ICK_Complex_Real: @@ -2963,16 +2963,16 @@ // do nothing } else if (From->getType()->isRealFloatingType()) { From = ImpCastExprToType(From, ElType, - isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take(); + isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get(); } else { assert(From->getType()->isIntegerType()); From = ImpCastExprToType(From, ElType, - isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take(); + isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get(); } // y -> _Complex y From = ImpCastExprToType(From, ToType, isFloatingComplex ? CK_FloatingRealToComplex - : CK_IntegralRealToComplex).take(); + : CK_IntegralRealToComplex).get(); // Case 2. _Complex x -> y } else { @@ -2986,7 +2986,7 @@ From = ImpCastExprToType(From, ElType, isFloatingComplex ? CK_FloatingComplexToReal : CK_IntegralComplexToReal, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); // x -> y if (Context.hasSameUnqualifiedType(ElType, ToType)) { @@ -2994,19 +2994,19 @@ } else if (ToType->isRealFloatingType()) { From = ImpCastExprToType(From, ToType, isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); } else { assert(ToType->isIntegerType()); From = ImpCastExprToType(From, ToType, isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); } } break; case ICK_Block_Pointer_Conversion: { From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast, - VK_RValue, /*BasePath=*/nullptr, CCK).take(); + VK_RValue, /*BasePath=*/nullptr, CCK).get(); break; } @@ -3016,7 +3016,7 @@ CheckTransparentUnionArgumentConstraints(ToType, FromRes); if (FromRes.isInvalid()) return ExprError(); - From = FromRes.take(); + From = FromRes.get(); assert ((ConvTy == Sema::Compatible) && "Improper transparent union conversion"); (void)ConvTy; @@ -3026,7 +3026,7 @@ case ICK_Zero_Event_Conversion: From = ImpCastExprToType(From, ToType, CK_ZeroToOCLEvent, - From->getValueKind()).take(); + From->getValueKind()).get(); break; case ICK_Lvalue_To_Rvalue: @@ -3048,7 +3048,7 @@ ExprValueKind VK = ToType->isReferenceType() ? From->getValueKind() : VK_RValue; From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context), - CK_NoOp, VK, /*BasePath=*/nullptr, CCK).take(); + CK_NoOp, VK, /*BasePath=*/nullptr, CCK).get(); if (SCS.DeprecatedStringLiteralToCharPtr && !getLangOpts().WritableStrings) { @@ -3071,7 +3071,7 @@ assert(Context.hasSameType( ToAtomicType->castAs()->getValueType(), From->getType())); From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic, - VK_RValue, nullptr, CCK).take(); + VK_RValue, nullptr, CCK).get(); } return Owned(From); @@ -4037,7 +4037,7 @@ } else if (Queried->getType()->isPlaceholderType()) { ExprResult PE = CheckPlaceholderExpr(Queried); if (PE.isInvalid()) return ExprError(); - return BuildExpressionTrait(ET, KWLoc, PE.take(), RParen); + return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen); } bool Value = EvaluateExpressionTrait(ET, Queried); @@ -4056,12 +4056,12 @@ // The LHS undergoes lvalue conversions if this is ->*. if (isIndirect) { - LHS = DefaultLvalueConversion(LHS.take()); + LHS = DefaultLvalueConversion(LHS.get()); if (LHS.isInvalid()) return QualType(); } // The RHS always undergoes lvalue conversions. - RHS = DefaultLvalueConversion(RHS.take()); + RHS = DefaultLvalueConversion(RHS.get()); if (RHS.isInvalid()) return QualType(); const char *OpSpelling = isIndirect ? "->*" : ".*"; @@ -4124,7 +4124,7 @@ // Cast LHS to type of use. QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind(); - LHS = ImpCastExprToType(LHS.take(), UseType, CK_DerivedToBase, VK, + LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK, &BasePath); } @@ -4347,7 +4347,7 @@ InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(), SourceLocation()); - Expr *Arg = E.take(); + Expr *Arg = E.get(); InitializationSequence InitSeq(Self, Entity, Kind, Arg); ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg); if (Result.isInvalid()) @@ -4371,7 +4371,7 @@ // C++11 [expr.cond]p1 // The first expression is contextually converted to bool. if (!Cond.get()->isTypeDependent()) { - ExprResult CondRes = CheckCXXBooleanCondition(Cond.take()); + ExprResult CondRes = CheckCXXBooleanCondition(Cond.get()); if (CondRes.isInvalid()) return QualType(); Cond = CondRes; @@ -4471,11 +4471,11 @@ Qualifiers LCVR = Qualifiers::fromCVRMask(LTy.getCVRQualifiers()); Qualifiers RCVR = Qualifiers::fromCVRMask(RTy.getCVRQualifiers()); if (RCVR.isStrictSupersetOf(LCVR)) { - LHS = ImpCastExprToType(LHS.take(), RTy, CK_NoOp, LVK); + LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK); LTy = LHS.get()->getType(); } else if (LCVR.isStrictSupersetOf(RCVR)) { - RHS = ImpCastExprToType(RHS.take(), LTy, CK_NoOp, RVK); + RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK); RTy = RHS.get()->getType(); } } @@ -4512,8 +4512,8 @@ // C++11 [expr.cond]p6 // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard // conversions are performed on the second and third operands. - LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); - RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); + LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); + RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); if (LHS.isInvalid() || RHS.isInvalid()) return QualType(); LTy = LHS.get()->getType(); @@ -4640,12 +4640,12 @@ !T2->isAnyPointerType() && !T2->isMemberPointerType()) { if (T1->isNullPtrType() && E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { - E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take(); + E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get(); return T1; } if (T2->isNullPtrType() && E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { - E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take(); + E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get(); return T2; } return QualType(); @@ -4653,16 +4653,16 @@ if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { if (T2->isMemberPointerType()) - E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).take(); + E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).get(); else - E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take(); + E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get(); return T2; } if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { if (T1->isMemberPointerType()) - E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).take(); + E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).get(); else - E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take(); + E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get(); return T1; } @@ -4800,14 +4800,14 @@ = E1ToC1.Perform(*this, Entity1, Kind, E1); if (E1Result.isInvalid()) return QualType(); - E1 = E1Result.takeAs(); + E1 = E1Result.getAs(); // Convert E2 to Composite1 ExprResult E2Result = E2ToC1.Perform(*this, Entity1, Kind, E2); if (E2Result.isInvalid()) return QualType(); - E2 = E2Result.takeAs(); + E2 = E2Result.getAs(); return Composite1; } @@ -4825,14 +4825,14 @@ = E1ToC2.Perform(*this, Entity2, Kind, E1); if (E1Result.isInvalid()) return QualType(); - E1 = E1Result.takeAs(); + E1 = E1Result.getAs(); // Convert E2 to Composite2 ExprResult E2Result = E2ToC2.Perform(*this, Entity2, Kind, E2); if (E2Result.isInvalid()) return QualType(); - E2 = E2Result.takeAs(); + E2 = E2Result.getAs(); return Composite2; } @@ -4990,7 +4990,7 @@ if (SubExpr.isInvalid()) return ExprError(); - return Owned(MaybeCreateExprWithCleanups(SubExpr.take())); + return Owned(MaybeCreateExprWithCleanups(SubExpr.get())); } Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) { @@ -5057,7 +5057,7 @@ return ExprError(); if (SubExpr.get() == PE->getSubExpr()) return Owned(E); - return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.take()); + return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get()); } if (BinaryOperator *BO = dyn_cast(E)) { if (BO->getOpcode() == BO_Comma) { @@ -5066,7 +5066,7 @@ return ExprError(); if (RHS.get() == BO->getRHS()) return Owned(E); - return Owned(new (Context) BinaryOperator(BO->getLHS(), RHS.take(), + return Owned(new (Context) BinaryOperator(BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(), BO->getObjectKind(), @@ -5172,7 +5172,7 @@ Result = CheckPlaceholderExpr(Base); if (Result.isInvalid()) return ExprError(); - Base = Result.take(); + Base = Result.get(); QualType BaseType = Base->getType(); MayBePseudoDestructor = false; @@ -5317,7 +5317,7 @@ if (Base->hasPlaceholderType()) { ExprResult result = S.CheckPlaceholderExpr(Base); if (result.isInvalid()) return true; - Base = result.take(); + Base = result.get(); } ObjectType = Base->getType(); @@ -5644,7 +5644,7 @@ return true; MemberExpr *ME = - new (Context) MemberExpr(Exp.take(), /*IsArrow=*/false, Method, + new (Context) MemberExpr(Exp.get(), /*IsArrow=*/false, Method, SourceLocation(), Context.BoundMemberTy, VK_RValue, OK_Ordinary); if (HadMultipleCandidates) @@ -5734,7 +5734,7 @@ if (E->hasPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return Owned(E); - E = result.take(); + E = result.get(); } // C99 6.3.2.1: @@ -5763,7 +5763,7 @@ ExprResult Res = DefaultLvalueConversion(E); if (Res.isInvalid()) return Owned(E); - E = Res.take(); + E = Res.get(); } return Owned(E); } @@ -5772,7 +5772,7 @@ if (const EnumType *T = E->getType()->getAs()) { if (!T->getDecl()->isComplete()) { // FIXME: stupid workaround for a codegen bug! - E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).take(); + E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get(); return Owned(E); } } @@ -5780,7 +5780,7 @@ ExprResult Res = DefaultFunctionArrayLvalueConversion(E); if (Res.isInvalid()) return Owned(E); - E = Res.take(); + E = Res.get(); if (!E->getType()->isVoidType()) RequireCompleteType(E->getExprLoc(), E->getType(), @@ -5951,17 +5951,17 @@ // Top-level expressions default to 'id' when we're in a debugger. if (DiscardedValue && getLangOpts().DebuggerCastResultToId && FullExpr.get()->getType() == Context.UnknownAnyTy) { - FullExpr = forceUnknownAnyToType(FullExpr.take(), Context.getObjCIdType()); + FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType()); if (FullExpr.isInvalid()) return ExprError(); } if (DiscardedValue) { - FullExpr = CheckPlaceholderExpr(FullExpr.take()); + FullExpr = CheckPlaceholderExpr(FullExpr.get()); if (FullExpr.isInvalid()) return ExprError(); - FullExpr = IgnoredValueConversions(FullExpr.take()); + FullExpr = IgnoredValueConversions(FullExpr.get()); if (FullExpr.isInvalid()) return ExprError(); } Index: lib/Sema/SemaExprMember.cpp =================================================================== --- lib/Sema/SemaExprMember.cpp +++ lib/Sema/SemaExprMember.cpp @@ -690,7 +690,7 @@ if (BaseResult.isInvalid()) return ExprError(); - Base = BaseResult.take(); + Base = BaseResult.get(); if (Result.isInvalid()) { Owned(Base); @@ -746,7 +746,7 @@ = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable); if (result.isInvalid()) return ExprError(); - baseObjectExpr = result.take(); + baseObjectExpr = result.get(); baseObjectIsPointer = false; baseQuals = baseObjectExpr->getType().getQualifiers(); @@ -802,7 +802,7 @@ result = BuildFieldReferenceExpr(*this, result, baseObjectIsPointer, EmptySS, field, foundDecl, - memberNameInfo).take(); + memberNameInfo).get(); if (!result) return ExprError(); @@ -822,7 +822,7 @@ result = BuildFieldReferenceExpr(*this, result, /*isarrow*/ false, (FI == FEnd? SS : EmptySS), field, - fakeFoundDecl, memberNameInfo).take(); + fakeFoundDecl, memberNameInfo).get(); } return Owned(result); @@ -1128,7 +1128,7 @@ if (opty && !opty->getObjectType()->getInterface()) return false; - base = S.ImpCastExprToType(base.take(), redef, CK_BitCast); + base = S.ImpCastExprToType(base.get(), redef, CK_BitCast); return true; } @@ -1168,7 +1168,7 @@ assert(BaseExpr.get() && "no base expression"); // Perform default conversions. - BaseExpr = PerformMemberExprBaseConversion(BaseExpr.take(), IsArrow); + BaseExpr = PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow); if (BaseExpr.isInvalid()) return ExprError(); @@ -1246,7 +1246,7 @@ // But we only actually find it this way on objects of type 'id', // apparently. if (OTy->isObjCId() && Member->isStr("isa")) - return Owned(new (Context) ObjCIsaExpr(BaseExpr.take(), IsArrow, MemberLoc, + return Owned(new (Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc, OpLoc, Context.getObjCClassType())); if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) @@ -1365,7 +1365,7 @@ ObjCIvarRefExpr *Result = new (Context) ObjCIvarRefExpr(IV, IV->getType(), MemberLoc, OpLoc, - BaseExpr.take(), + BaseExpr.get(), IsArrow); if (getLangOpts().ObjCAutoRefCount) { @@ -1392,7 +1392,7 @@ } // This actually uses the base as an r-value. - BaseExpr = DefaultLvalueConversion(BaseExpr.take()); + BaseExpr = DefaultLvalueConversion(BaseExpr.get()); if (BaseExpr.isInvalid()) return ExprError(); @@ -1417,7 +1417,7 @@ VK_LValue, OK_ObjCProperty, MemberLoc, - BaseExpr.take())); + BaseExpr.get())); } if (ObjCMethodDecl *OMD = dyn_cast(PMDecl)) { @@ -1437,7 +1437,7 @@ return Owned(new (Context) ObjCPropertyRefExpr(OMD, SMD, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, - MemberLoc, BaseExpr.take())); + MemberLoc, BaseExpr.get())); } } // Use of id.member can only be for a property reference. Do not @@ -1492,7 +1492,7 @@ return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, - MemberLoc, BaseExpr.take())); + MemberLoc, BaseExpr.get())); } if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) @@ -1519,7 +1519,7 @@ if (ret.isNull()) return ExprError(); - return Owned(new (Context) ExtVectorElementExpr(ret, VK, BaseExpr.take(), + return Owned(new (Context) ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc)); } @@ -1528,7 +1528,7 @@ if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) && !Context.getObjCSelRedefinitionType()->isObjCSelType()) { - BaseExpr = ImpCastExprToType(BaseExpr.take(), + BaseExpr = ImpCastExprToType(BaseExpr.get(), Context.getObjCSelRedefinitionType(), CK_BitCast); return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, @@ -1567,7 +1567,7 @@ IsArrow ? &isPointerToRecordType : &isRecordType)) { if (BaseExpr.isInvalid()) return ExprError(); - BaseExpr = DefaultFunctionArrayConversion(BaseExpr.take()); + BaseExpr = DefaultFunctionArrayConversion(BaseExpr.get()); return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, ObjCImpDecl, HasTemplateArgs); } @@ -1625,7 +1625,7 @@ // This is a postfix expression, so get rid of ParenListExprs. ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); if (Result.isInvalid()) return ExprError(); - Base = Result.take(); + Base = Result.get(); if (Base->getType()->isDependentType() || Name.isDependentName() || isDependentScopeSpecifier(SS)) { @@ -1640,7 +1640,7 @@ SS, ObjCImpDecl, TemplateArgs != nullptr); if (BaseResult.isInvalid()) return ExprError(); - Base = BaseResult.take(); + Base = BaseResult.get(); if (Result.isInvalid()) { Owned(Base); @@ -1725,7 +1725,7 @@ FoundDecl, Field); if (Base.isInvalid()) return ExprError(); - return S.Owned(BuildMemberExpr(S, S.Context, Base.take(), IsArrow, SS, + return S.Owned(BuildMemberExpr(S, S.Context, Base.get(), IsArrow, SS, /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl, MemberNameInfo, MemberType, VK, OK)); Index: lib/Sema/SemaExprObjC.cpp =================================================================== --- lib/Sema/SemaExprObjC.cpp +++ lib/Sema/SemaExprObjC.cpp @@ -1296,7 +1296,7 @@ } if (result.isInvalid()) return true; - Args[i] = result.take(); + Args[i] = result.get(); } unsigned DiagID; @@ -1383,7 +1383,7 @@ if (argE.isInvalid()) { IsError = true; } else { - Args[i] = argE.take(); + Args[i] = argE.get(); // Update the parameter type in-place. param->setType(paramType); @@ -1402,7 +1402,7 @@ if (ArgE.isInvalid()) IsError = true; else - Args[i] = ArgE.takeAs(); + Args[i] = ArgE.getAs(); } // Promote additional arguments to variadic methods. @@ -1414,7 +1414,7 @@ ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, nullptr); IsError |= Arg.isInvalid(); - Args[i] = Arg.take(); + Args[i] = Arg.get(); } } else { // Check for extra arguments to non-variadic methods. @@ -2288,7 +2288,7 @@ else Result = CheckPlaceholderExpr(Receiver); if (Result.isInvalid()) return ExprError(); - Receiver = Result.take(); + Receiver = Result.get(); } if (Receiver->isTypeDependent()) { @@ -2309,7 +2309,7 @@ ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver); if (Result.isInvalid()) return ExprError(); - Receiver = Result.take(); + Receiver = Result.get(); ReceiverType = Receiver->getType(); // If the receiver is an ObjC pointer, a block pointer, or an @@ -2328,14 +2328,14 @@ << Receiver->getSourceRange(); if (ReceiverType->isPointerType()) { Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), - CK_CPointerToObjCPointerCast).take(); + CK_CPointerToObjCPointerCast).get(); } else { // TODO: specialized warning on null receivers? bool IsNull = Receiver->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull); CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer; Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), - Kind).take(); + Kind).get(); } ReceiverType = Receiver->getType(); } else if (getLangOpts().CPlusPlus) { @@ -2346,7 +2346,7 @@ ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver); if (result.isUsable()) { - Receiver = result.take(); + Receiver = result.get(); ReceiverType = Receiver->getType(); } } @@ -2733,7 +2733,7 @@ if (isa(Receiver)) { ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver); if (Result.isInvalid()) return ExprError(); - Receiver = Result.take(); + Receiver = Result.get(); } if (RespondsToSelectorSel.isNull()) { @@ -3547,7 +3547,7 @@ ClassMethod->getLocation(), ClassMethod->getSelector(), ClassMethod, MultiExprArg(args, 1)); - SrcExpr = msg.take(); + SrcExpr = msg.get(); return true; } } @@ -3584,7 +3584,7 @@ InstanceMethod->getLocation(), InstanceMethod->getSelector(), InstanceMethod, None); - SrcExpr = msg.take(); + SrcExpr = msg.get(); return true; } } @@ -3806,7 +3806,7 @@ Expr *SubExpr) { ExprResult SubResult = UsualUnaryConversions(SubExpr); if (SubResult.isInvalid()) return ExprError(); - SubExpr = SubResult.take(); + SubExpr = SubResult.get(); QualType T = TSInfo->getType(); QualType FromType = SubExpr->getType(); Index: lib/Sema/SemaInit.cpp =================================================================== --- lib/Sema/SemaInit.cpp +++ lib/Sema/SemaInit.cpp @@ -405,13 +405,13 @@ if (hadError) { // Do nothing } else if (Init < NumInits) { - ILE->setInit(Init, MemberInit.takeAs()); + ILE->setInit(Init, MemberInit.getAs()); } else if (InitSeq.isConstructorInitialization()) { // Value-initialization requires a constructor call, so // extend the initializer list to include the constructor // call and make a note that we'll need to take another pass // through the initializer list. - ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs()); + ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs()); RequiresSecondPass = true; } } else if (InitListExpr *InnerILE @@ -522,14 +522,14 @@ // For arrays, just set the expression used for value-initialization // of the "holes" in the array. if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) - ILE->setArrayFiller(ElementInit.takeAs()); + ILE->setArrayFiller(ElementInit.getAs()); else - ILE->setInit(Init, ElementInit.takeAs()); + ILE->setInit(Init, ElementInit.getAs()); } else { // For arrays, just set the expression used for value-initialization // of the rest of elements and exit. if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) { - ILE->setArrayFiller(ElementInit.takeAs()); + ILE->setArrayFiller(ElementInit.getAs()); return; } @@ -538,7 +538,7 @@ // extend the initializer list to include the constructor // call and make a note that we'll need to take another pass // through the initializer list. - ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs()); + ILE->updateInit(SemaRef.Context, Init, ElementInit.getAs()); RequiresSecondPass = true; } } @@ -878,7 +878,7 @@ hadError = true; UpdateStructuredListElement(StructuredList, StructuredIndex, - Result.takeAs()); + Result.getAs()); } ++Index; return; @@ -902,16 +902,16 @@ if (ExprRes.isInvalid()) hadError = true; else { - ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take()); + ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get()); if (ExprRes.isInvalid()) hadError = true; } UpdateStructuredListElement(StructuredList, StructuredIndex, - ExprRes.takeAs()); + ExprRes.getAs()); ++Index; return; } - ExprRes.release(); + ExprRes.get(); // Fall through for subaggregate initialization } @@ -1035,7 +1035,7 @@ if (Result.isInvalid()) hadError = true; // types weren't compatible. else { - ResultExpr = Result.takeAs(); + ResultExpr = Result.getAs(); if (ResultExpr != expr) { // The type was promoted, update initializer list. @@ -1096,7 +1096,7 @@ if (Result.isInvalid()) hadError = true; - expr = Result.takeAs(); + expr = Result.getAs(); IList->setInit(Index, expr); if (hadError) @@ -1145,7 +1145,7 @@ if (Result.isInvalid()) hadError = true; // types weren't compatible. else { - ResultExpr = Result.takeAs(); + ResultExpr = Result.getAs(); if (ResultExpr != Init) { // The type was promoted, update initializer list. @@ -2373,7 +2373,7 @@ Expr *Index = static_cast(D.getArrayIndex()); llvm::APSInt IndexValue; if (!Index->isTypeDependent() && !Index->isValueDependent()) - Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take(); + Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get(); if (!Index) Invalid = true; else { @@ -2396,9 +2396,9 @@ EndIndex->isValueDependent(); if (!StartDependent) StartIndex = - CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take(); + CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get(); if (!EndDependent) - EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take(); + EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get(); if (!StartIndex || !EndIndex) Invalid = true; @@ -2440,7 +2440,7 @@ = DesignatedInitExpr::Create(Context, Designators.data(), Designators.size(), InitExpressions, Loc, GNUSyntax, - Init.takeAs()); + Init.getAs()); if (!getLangOpts().C99) Diag(DIE->getLocStart(), diag::ext_designated_init) @@ -4433,7 +4433,7 @@ SetFailed(FK_PlaceholderType); return; } - Args[I] = result.take(); + Args[I] = result.get(); } // C++0x [dcl.init]p16: @@ -4982,7 +4982,7 @@ CXXConstructorDecl *Constructor = cast(Best->Function); SmallVector ConstructorArgs; - CurInit.release(); // Ownership transferred into MultiExprArg, below. + CurInit.get(); // Ownership transferred into MultiExprArg, below. S.CheckConstructorAccess(Loc, Constructor, Entity, Best->FoundDecl.getAccess(), IsExtraneousCopy); @@ -5030,7 +5030,7 @@ // If we're supposed to bind temporaries, do so. if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity)) - CurInit = S.MaybeBindToTemporary(CurInit.takeAs()); + CurInit = S.MaybeBindToTemporary(CurInit.getAs()); return CurInit; } @@ -5262,7 +5262,7 @@ return ExprError(); if (shouldBindAsTemporary(Entity)) - CurInit = S.MaybeBindToTemporary(CurInit.take()); + CurInit = S.MaybeBindToTemporary(CurInit.get()); return CurInit; } @@ -5825,7 +5825,7 @@ // Build a call to the selected constructor. SmallVector ConstructorArgs; SourceLocation Loc = CurInit.get()->getLocStart(); - CurInit.release(); // Ownership transferred into MultiExprArg, below. + CurInit.get(); // Ownership transferred into MultiExprArg, below. // Determine the arguments required to actually perform the constructor // call. @@ -5870,7 +5870,7 @@ // derived-to-base conversion? I believe the answer is "no", because // we don't want to turn off access control here for c-style casts. ExprResult CurInitExprRes = - S.PerformObjectArgumentInitialization(CurInit.take(), + S.PerformObjectArgumentInitialization(CurInit.get(), /*Qualifier=*/nullptr, FoundFn, Conversion); if(CurInitExprRes.isInvalid()) @@ -5910,7 +5910,7 @@ nullptr, CurInit.get()->getValueKind())); if (MaybeBindToTemp) - CurInit = S.MaybeBindToTemporary(CurInit.takeAs()); + CurInit = S.MaybeBindToTemporary(CurInit.getAs()); if (RequiresCopy) CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity, CurInit, /*IsExtraneousCopy=*/false); @@ -5927,7 +5927,7 @@ (Step->Kind == SK_QualificationConversionXValue ? VK_XValue : VK_RValue); - CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK); + CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK); break; } @@ -5935,7 +5935,7 @@ assert(CurInit.get()->isGLValue() && "cannot load from a prvalue"); CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type, CK_LValueToRValue, - CurInit.take(), + CurInit.get(), /*BasePath=*/nullptr, VK_RValue)); break; @@ -5990,7 +5990,7 @@ InitListExpr *StructuredInitList = PerformInitList.getFullyStructuredList(); - CurInit.release(); + CurInit.get(); CurInit = shouldBindAsTemporary(InitEntity) ? S.MaybeBindToTemporary(StructuredInitList) : S.Owned(StructuredInitList); @@ -6023,11 +6023,11 @@ } case SK_UnwrapInitList: - CurInit = S.Owned(cast(CurInit.take())->getInit(0)); + CurInit = S.Owned(cast(CurInit.get())->getInit(0)); break; case SK_RewrapInitList: { - Expr *E = CurInit.take(); + Expr *E = CurInit.get(); InitListExpr *Syntactic = Step->WrappingSyntacticList; InitListExpr *ILE = new (S.Context) InitListExpr(S.Context, Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc()); @@ -6127,7 +6127,7 @@ } case SK_ObjCObjectConversion: - CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, + CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_ObjCObjectLValueCast, CurInit.get()->getValueKind()); break; @@ -6166,14 +6166,14 @@ case SK_PassByIndirectRestore: checkIndirectCopyRestoreSource(S, CurInit.get()); CurInit = S.Owned(new (S.Context) - ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type, + ObjCIndirectCopyRestoreExpr(CurInit.get(), Step->Type, Step->Kind == SK_PassByIndirectCopyRestore)); break; case SK_ProduceObjCObject: CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject, - CurInit.take(), nullptr, + CurInit.get(), nullptr, VK_RValue)); break; @@ -6203,7 +6203,7 @@ // Bind the result, in case the library has given initializer_list a // non-trivial destructor. if (shouldBindAsTemporary(Entity)) - CurInit = S.MaybeBindToTemporary(CurInit.take()); + CurInit = S.MaybeBindToTemporary(CurInit.get()); break; } @@ -6227,7 +6227,7 @@ assert(Step->Type->isEventT() && "Event initialization on non-event type."); - CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, + CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_ZeroToOCLEvent, CurInit.get()->getValueKind()); break; @@ -7101,7 +7101,7 @@ EqualLoc, AllowExplicit); InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList); - Init.release(); + Init.get(); ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE); Index: lib/Sema/SemaLambda.cpp =================================================================== --- lib/Sema/SemaLambda.cpp +++ lib/Sema/SemaLambda.cpp @@ -782,7 +782,7 @@ if (Result.isInvalid()) return QualType(); - Init = Result.takeAs(); + Init = Result.getAs(); // The init-capture initialization is a full-expression that must be // processed as one before we enter the declcontext of the lambda's @@ -793,7 +793,7 @@ if (Result.isInvalid()) return QualType(); - Init = Result.takeAs(); + Init = Result.getAs(); return DeducedType; } @@ -1013,7 +1013,7 @@ if (C->InitCaptureType.get().isNull()) continue; Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(), - C->Id, C->Init.take()); + C->Id, C->Init.get()); // C++1y [expr.prim.lambda]p11: // An init-capture behaves as if it declares and explicitly // captures a variable [...] whose declarative region is the @@ -1572,7 +1572,7 @@ /*NRVO=*/false), CurrentLocation, Src); if (!Init.isInvalid()) - Init = ActOnFinishFullExpr(Init.take()); + Init = ActOnFinishFullExpr(Init.get()); if (Init.isInvalid()) return ExprError(); @@ -1612,7 +1612,7 @@ Src->getType(), CapVarTSI, SC_None); BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false, - /*Nested=*/false, /*Copy=*/Init.take()); + /*Nested=*/false, /*Copy=*/Init.get()); Block->setCaptures(Context, &Capture, &Capture + 1, /*CapturesCXXThis=*/false); Index: lib/Sema/SemaObjCProperty.cpp =================================================================== --- lib/Sema/SemaObjCProperty.cpp +++ lib/Sema/SemaObjCProperty.cpp @@ -1158,7 +1158,7 @@ /*NRVO=*/false), PropertyDiagLoc, Owned(IvarRefExpr)); if (!Res.isInvalid()) { - Expr *ResExpr = Res.takeAs(); + Expr *ResExpr = Res.getAs(); if (ResExpr) ResExpr = MaybeCreateExprWithCleanups(ResExpr); PIDecl->setGetterCXXConstructor(ResExpr); @@ -1212,7 +1212,7 @@ BO_Assign, lhs, rhs); if (property->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_atomic) { - Expr *callExpr = Res.takeAs(); + Expr *callExpr = Res.getAs(); if (const CXXOperatorCallExpr *CXXCE = dyn_cast_or_null(callExpr)) if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee()) @@ -1225,7 +1225,7 @@ diag::note_callee_decl) << FuncDecl; } } - PIDecl->setSetterCXXAssignment(Res.takeAs()); + PIDecl->setSetterCXXAssignment(Res.getAs()); } } Index: lib/Sema/SemaOpenMP.cpp =================================================================== --- lib/Sema/SemaOpenMP.cpp +++ lib/Sema/SemaOpenMP.cpp @@ -837,7 +837,7 @@ if (Val.isInvalid()) return nullptr; - ValExpr = Val.take(); + ValExpr = Val.get(); } return new (Context) OMPIfClause(ValExpr, StartLoc, LParenLoc, EndLoc); @@ -901,7 +901,7 @@ if (Val.isInvalid()) return nullptr; - ValExpr = Val.take(); + ValExpr = Val.get(); // OpenMP [2.5, Restrictions] // The num_threads expression must evaluate to a positive integer value. @@ -947,7 +947,7 @@ if (Safelen.isInvalid()) return nullptr; return new (Context) - OMPSafelenClause(Safelen.take(), StartLoc, LParenLoc, EndLoc); + OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc); } OMPClause *Sema::ActOnOpenMPSimpleClause(OpenMPClauseKind Kind, @@ -1578,7 +1578,7 @@ ExprResult Val = PerformImplicitIntegerConversion(StepLoc, Step); if (Val.isInvalid()) return nullptr; - StepExpr = Val.take(); + StepExpr = Val.get(); // Warn about zero linear step (it would be probably better specified as // making corresponding variables 'const'). Index: lib/Sema/SemaOverload.cpp =================================================================== --- lib/Sema/SemaOverload.cpp +++ lib/Sema/SemaOverload.cpp @@ -62,7 +62,7 @@ S.MarkDeclRefReferenced(DRE); ExprResult E = S.Owned(DRE); - E = S.DefaultFunctionArrayConversion(E.take()); + E = S.DefaultFunctionArrayConversion(E.get()); if (E.isInvalid()) return ExprError(); return E; @@ -851,7 +851,7 @@ if (result.isInvalid()) return true; - E = result.take(); + E = result.get(); return false; } @@ -4878,12 +4878,12 @@ PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method); if (FromRes.isInvalid()) return ExprError(); - From = FromRes.take(); + From = FromRes.get(); } if (!Context.hasSameType(From->getType(), DestType)) From = ImpCastExprToType(From, DestType, CK_NoOp, - From->getValueKind()).take(); + From->getValueKind()).get(); return Owned(From); } @@ -5306,7 +5306,7 @@ ExprResult result = CheckPlaceholderExpr(From); if (result.isInvalid()) return result; - From = result.take(); + From = result.get(); } // If the expression already has a matching type, we're golden. @@ -5708,7 +5708,7 @@ InitializationFailed = true; break; } - ConvertedArgs.push_back(R.take()); + ConvertedArgs.push_back(R.get()); } else { ExprResult R = PerformCopyInitialization(InitializedEntity::InitializeParameter( @@ -5720,7 +5720,7 @@ InitializationFailed = true; break; } - ConvertedArgs.push_back(R.take()); + ConvertedArgs.push_back(R.get()); } } @@ -10153,12 +10153,12 @@ // Fix the expression to refer to 'fn'. SingleFunctionExpression = - Owned(FixOverloadedFunctionReference(SrcExpr.take(), found, fn)); + Owned(FixOverloadedFunctionReference(SrcExpr.get(), found, fn)); // If desired, do function-to-pointer decay. if (doFunctionPointerConverion) { SingleFunctionExpression = - DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.take()); + DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get()); if (SingleFunctionExpression.isInvalid()) { SrcExpr = ExprError(); return true; @@ -10490,7 +10490,7 @@ // This shouldn't cause an infinite loop because we're giving it // an expression with viable lookup results, which should never // end up here. - return SemaRef.ActOnCallExpr(/*Scope*/ nullptr, NewFn.take(), LParenLoc, + return SemaRef.ActOnCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc, MultiExprArg(Args.data(), Args.size()), RParenLoc); } @@ -10770,7 +10770,7 @@ Best->FoundDecl, Method); if (InputRes.isInvalid()) return ExprError(); - Input = InputRes.take(); + Input = InputRes.get(); } else { // Convert the arguments. ExprResult InputInit @@ -10781,7 +10781,7 @@ Input); if (InputInit.isInvalid()) return ExprError(); - Input = InputInit.take(); + Input = InputInit.get(); } // Build the actual expression node. @@ -10797,7 +10797,7 @@ Args[0] = Input; CallExpr *TheCall = - new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(), ArgsArray, + new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc, false); if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl)) @@ -10813,7 +10813,7 @@ Best->Conversions[0], AA_Passing); if (InputRes.isInvalid()) return ExprError(); - Input = InputRes.take(); + Input = InputRes.get(); break; } } @@ -10994,8 +10994,8 @@ Best->FoundDecl, Method); if (Arg0.isInvalid()) return ExprError(); - Args[0] = Arg0.takeAs(); - Args[1] = RHS = Arg1.takeAs(); + Args[0] = Arg0.getAs(); + Args[1] = RHS = Arg1.getAs(); } else { // Convert the arguments. ExprResult Arg0 = PerformCopyInitialization( @@ -11012,8 +11012,8 @@ SourceLocation(), Owned(Args[1])); if (Arg1.isInvalid()) return ExprError(); - Args[0] = LHS = Arg0.takeAs(); - Args[1] = RHS = Arg1.takeAs(); + Args[0] = LHS = Arg0.getAs(); + Args[1] = RHS = Arg1.getAs(); } // Build the actual expression node. @@ -11029,7 +11029,7 @@ ResultTy = ResultTy.getNonLValueExprType(Context); CXXOperatorCallExpr *TheCall = - new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(), + new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(), Args, ResultTy, VK, OpLoc, FPFeatures.fp_contract); @@ -11054,14 +11054,14 @@ Best->Conversions[0], AA_Passing); if (ArgsRes0.isInvalid()) return ExprError(); - Args[0] = ArgsRes0.take(); + Args[0] = ArgsRes0.get(); ExprResult ArgsRes1 = PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], Best->Conversions[1], AA_Passing); if (ArgsRes1.isInvalid()) return ExprError(); - Args[1] = ArgsRes1.take(); + Args[1] = ArgsRes1.get(); break; } } @@ -11214,7 +11214,7 @@ Best->FoundDecl, Method); if (Arg0.isInvalid()) return ExprError(); - Args[0] = Arg0.take(); + Args[0] = Arg0.get(); // Convert the arguments. ExprResult InputInit @@ -11226,7 +11226,7 @@ if (InputInit.isInvalid()) return ExprError(); - Args[1] = InputInit.takeAs(); + Args[1] = InputInit.getAs(); // Build the actual expression node. DeclarationNameInfo OpLocInfo(OpName, LLoc); @@ -11246,7 +11246,7 @@ CXXOperatorCallExpr *TheCall = new (Context) CXXOperatorCallExpr(Context, OO_Subscript, - FnExpr.take(), Args, + FnExpr.get(), Args, ResultTy, VK, RLoc, false); @@ -11263,14 +11263,14 @@ Best->Conversions[0], AA_Passing); if (ArgsRes0.isInvalid()) return ExprError(); - Args[0] = ArgsRes0.take(); + Args[0] = ArgsRes0.get(); ExprResult ArgsRes1 = PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], Best->Conversions[1], AA_Passing); if (ArgsRes1.isInvalid()) return ExprError(); - Args[1] = ArgsRes1.take(); + Args[1] = ArgsRes1.get(); break; } @@ -11531,7 +11531,7 @@ FoundDecl, Method); if (ObjectArg.isInvalid()) return ExprError(); - MemExpr->setBase(ObjectArg.take()); + MemExpr->setBase(ObjectArg.get()); } // Convert the rest of the arguments @@ -11774,7 +11774,7 @@ ResultTy = ResultTy.getNonLValueExprType(Context); CXXOperatorCallExpr *TheCall = new (Context) - CXXOperatorCallExpr(Context, OO_Call, NewFn.take(), + CXXOperatorCallExpr(Context, OO_Call, NewFn.get(), llvm::makeArrayRef(MethodArgs.get(), Args.size() + 1), ResultTy, VK, RParenLoc, false); MethodArgs.reset(); @@ -11797,7 +11797,7 @@ IsError = true; else Object = ObjRes; - TheCall->setArg(0, Object.take()); + TheCall->setArg(0, Object.get()); // Check the argument types. for (unsigned i = 0; i != NumParams; i++) { @@ -11814,7 +11814,7 @@ SourceLocation(), Arg); IsError |= InputInit.isInvalid(); - Arg = InputInit.takeAs(); + Arg = InputInit.getAs(); } else { ExprResult DefArg = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i)); @@ -11823,7 +11823,7 @@ break; } - Arg = DefArg.takeAs(); + Arg = DefArg.getAs(); } TheCall->setArg(i + 1, Arg); @@ -11836,7 +11836,7 @@ ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, nullptr); IsError |= Arg.isInvalid(); - TheCall->setArg(i + 1, Arg.take()); + TheCall->setArg(i + 1, Arg.get()); } } @@ -11944,7 +11944,7 @@ Best->FoundDecl, Method); if (BaseResult.isInvalid()) return ExprError(); - Base = BaseResult.take(); + Base = BaseResult.get(); // Build the operator call. ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl, @@ -11956,7 +11956,7 @@ ExprValueKind VK = Expr::getValueKindForType(ResultTy); ResultTy = ResultTy.getNonLValueExprType(Context); CXXOperatorCallExpr *TheCall = - new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.take(), + new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.get(), Base, ResultTy, VK, OpLoc, false); if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method)) @@ -12018,7 +12018,7 @@ SourceLocation(), Args[ArgIdx]); if (InputInit.isInvalid()) return true; - ConvArgs[ArgIdx] = InputInit.take(); + ConvArgs[ArgIdx] = InputInit.get(); } QualType ResultTy = FD->getReturnType(); @@ -12026,7 +12026,7 @@ ResultTy = ResultTy.getNonLValueExprType(Context); UserDefinedLiteral *UDL = - new (Context) UserDefinedLiteral(Context, Fn.take(), + new (Context) UserDefinedLiteral(Context, Fn.get(), llvm::makeArrayRef(ConvArgs, Args.size()), ResultTy, VK, LitEndLoc, UDSuffixLoc); Index: lib/Sema/SemaPseudoObject.cpp =================================================================== --- lib/Sema/SemaPseudoObject.cpp +++ lib/Sema/SemaPseudoObject.cpp @@ -393,7 +393,7 @@ ExprResult getExpr = buildGet(); if (getExpr.isInvalid()) return ExprError(); - addResultSemanticExpr(getExpr.take()); + addResultSemanticExpr(getExpr.get()); return complete(syntacticBase); } @@ -426,7 +426,7 @@ BinaryOperatorKind nonCompound = BinaryOperator::getOpForCompoundAssignment(opcode); result = S.BuildBinOp(Sc, opcLoc, nonCompound, - opLHS.take(), capturedRHS); + opLHS.get(), capturedRHS); if (result.isInvalid()) return ExprError(); syntactic = @@ -441,9 +441,9 @@ // The result of the assignment, if not void, is the value set into // the l-value. - result = buildSet(result.take(), opcLoc, /*captureSetValueAsResult*/ true); + result = buildSet(result.get(), opcLoc, /*captureSetValueAsResult*/ true); if (result.isInvalid()) return ExprError(); - addSemanticExpr(result.take()); + addSemanticExpr(result.get()); return complete(syntactic); } @@ -467,7 +467,7 @@ // That's the postfix result. if (UnaryOperator::isPostfix(opcode) && (result.get()->isTypeDependent() || CanCaptureValue(result.get()))) { - result = capture(result.take()); + result = capture(result.get()); setResultToLastSemantic(); } @@ -477,17 +477,17 @@ GenericLoc); if (UnaryOperator::isIncrementOp(opcode)) { - result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.take(), one); + result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one); } else { - result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.take(), one); + result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), one); } if (result.isInvalid()) return ExprError(); // Store that back into the result. The value stored is the result // of a prefix operation. - result = buildSet(result.take(), opcLoc, UnaryOperator::isPrefix(opcode)); + result = buildSet(result.get(), opcLoc, UnaryOperator::isPrefix(opcode)); if (result.isInvalid()) return ExprError(); - addSemanticExpr(result.take()); + addSemanticExpr(result.get()); UnaryOperator *syntactic = new (S.Context) UnaryOperator(syntacticOp, opcode, resultType, @@ -733,7 +733,7 @@ Sema::AA_Assigning)) return ExprError(); - op = opResult.take(); + op = opResult.get(); assert(op && "successful assignment left argument invalid?"); } else if (OpaqueValueExpr *OVE = dyn_cast(op)) { @@ -841,7 +841,7 @@ ExprResult result; if (tryBuildGetOfReference(LHS, result)) { if (result.isInvalid()) return ExprError(); - return S.BuildBinOp(Sc, opcLoc, opcode, result.take(), RHS); + return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS); } // Otherwise, it's an error. @@ -885,7 +885,7 @@ ExprResult result; if (tryBuildGetOfReference(op, result)) { if (result.isInvalid()) return ExprError(); - return S.BuildUnaryOp(Sc, opcLoc, opcode, result.take()); + return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get()); } // Otherwise, it's an error. @@ -1419,7 +1419,7 @@ } MultiExprArg ArgExprs; - return S.ActOnCallExpr(S.getCurScope(), GetterExpr.take(), + return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(), RefExpr->getSourceRange().getBegin(), ArgExprs, RefExpr->getSourceRange().getEnd()); } @@ -1450,7 +1450,7 @@ SmallVector ArgExprs; ArgExprs.push_back(op); - return S.ActOnCallExpr(S.getCurScope(), SetterExpr.take(), + return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(), RefExpr->getSourceRange().getBegin(), ArgExprs, op->getSourceRange().getEnd()); } @@ -1517,7 +1517,7 @@ if (RHS->getType()->isNonOverloadPlaceholderType()) { ExprResult result = CheckPlaceholderExpr(RHS); if (result.isInvalid()) return ExprError(); - RHS = result.take(); + RHS = result.get(); } Expr *opaqueRef = LHS->IgnoreParens(); Index: lib/Sema/SemaStmt.cpp =================================================================== --- lib/Sema/SemaStmt.cpp +++ lib/Sema/SemaStmt.cpp @@ -49,7 +49,7 @@ // operand, even incomplete types. // Same thing in for stmt first clause (when expr) and third clause. - return Owned(static_cast(FE.take())); + return Owned(static_cast(FE.get())); } @@ -362,7 +362,7 @@ // C99 6.8.4.2p3: The expression shall be an integer constant. // However, GCC allows any evaluatable integer expression. if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent()) { - LHSVal = VerifyIntegerConstantExpression(LHSVal).take(); + LHSVal = VerifyIntegerConstantExpression(LHSVal).get(); if (!LHSVal) return StmtError(); } @@ -370,16 +370,16 @@ // GCC extension: The expression shall be an integer constant. if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent()) { - RHSVal = VerifyIntegerConstantExpression(RHSVal).take(); + RHSVal = VerifyIntegerConstantExpression(RHSVal).get(); // Recover from an error by just forgetting about it. } } LHSVal = ActOnFinishFullExpr(LHSVal, LHSVal->getExprLoc(), false, - getLangOpts().CPlusPlus11).take(); + getLangOpts().CPlusPlus11).get(); if (RHSVal) RHSVal = ActOnFinishFullExpr(RHSVal, RHSVal->getExprLoc(), false, - getLangOpts().CPlusPlus11).take(); + getLangOpts().CPlusPlus11).get(); CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc, ColonLoc); @@ -458,7 +458,7 @@ if (CondResult.isInvalid()) return StmtError(); } - Expr *ConditionExpr = CondResult.takeAs(); + Expr *ConditionExpr = CondResult.getAs(); if (!ConditionExpr) return StmtError(); @@ -587,7 +587,7 @@ if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.release(); + Cond = CondResult.get(); } if (!Cond) @@ -643,18 +643,18 @@ CondResult = PerformContextualImplicitConversion(SwitchLoc, Cond, SwitchDiagnoser); if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.take(); + Cond = CondResult.get(); // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr. CondResult = UsualUnaryConversions(Cond); if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.take(); + Cond = CondResult.get(); if (!CondVar) { CondResult = ActOnFinishFullExpr(Cond, SwitchLoc); if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.take(); + Cond = CondResult.get(); } getCurFunction()->setHasBranchIntoScope(); @@ -798,7 +798,7 @@ CaseListIsErroneous = true; continue; } - Lo = ConvLo.take(); + Lo = ConvLo.get(); } else { // We already verified that the expression has a i-c-e value (C99 // 6.8.4.2p3) - get that value now. @@ -806,8 +806,8 @@ // If the LHS is not the same type as the condition, insert an implicit // cast. - Lo = DefaultLvalueConversion(Lo).take(); - Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take(); + Lo = DefaultLvalueConversion(Lo).get(); + Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).get(); } // Convert the value to the same width/sign as the condition had prior to @@ -919,14 +919,14 @@ CaseListIsErroneous = true; continue; } - Hi = ConvHi.take(); + Hi = ConvHi.get(); } else { HiVal = Hi->EvaluateKnownConstInt(Context); // If the RHS is not the same type as the condition, insert an // implicit cast. - Hi = DefaultLvalueConversion(Hi).take(); - Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take(); + Hi = DefaultLvalueConversion(Hi).get(); + Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).get(); } // Convert the value to the same width/sign as the condition. @@ -1215,7 +1215,7 @@ if (CondResult.isInvalid()) return StmtError(); } - Expr *ConditionExpr = CondResult.take(); + Expr *ConditionExpr = CondResult.get(); if (!ConditionExpr) return StmtError(); CheckBreakContinueBinding(ConditionExpr); @@ -1239,12 +1239,12 @@ ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc); if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.take(); + Cond = CondResult.get(); CondResult = ActOnFinishFullExpr(Cond, DoLoc); if (CondResult.isInvalid()) return StmtError(); - Cond = CondResult.take(); + Cond = CondResult.get(); DiagnoseUnusedExprResult(Body); @@ -1623,7 +1623,7 @@ return StmtError(); } - Expr *Third = third.release().takeAs(); + Expr *Third = third.release().getAs(); DiagnoseUnusedExprResult(First); DiagnoseUnusedExprResult(Third); @@ -1633,7 +1633,7 @@ getCurCompoundScope().setHasEmptyLoopBodies(); return Owned(new (Context) ForStmt(Context, First, - SecondResult.take(), ConditionVar, + SecondResult.get(), ConditionVar, Third, Body, ForLoc, LParenLoc, RParenLoc)); } @@ -1647,12 +1647,12 @@ // use of pseudo-object l-values in this position. ExprResult result = CheckPlaceholderExpr(E); if (result.isInvalid()) return StmtError(); - E = result.take(); + E = result.get(); ExprResult FullExpr = ActOnFinishFullExpr(E); if (FullExpr.isInvalid()) return StmtError(); - return StmtResult(static_cast(FullExpr.take())); + return StmtResult(static_cast(FullExpr.get())); } ExprResult @@ -1667,7 +1667,7 @@ ExprResult result = DefaultFunctionArrayLvalueConversion(collection); if (result.isInvalid()) return ExprError(); - collection = result.take(); + collection = result.get(); // The operand needs to have object-pointer type. // TODO: should we do a contextual conversion? @@ -1798,12 +1798,12 @@ if (CollectionExprResult.isInvalid()) return StmtError(); - CollectionExprResult = ActOnFinishFullExpr(CollectionExprResult.take()); + CollectionExprResult = ActOnFinishFullExpr(CollectionExprResult.get()); if (CollectionExprResult.isInvalid()) return StmtError(); return Owned(new (Context) ObjCForCollectionStmt(First, - CollectionExprResult.take(), + CollectionExprResult.get(), nullptr, ForLoc, RParenLoc)); } @@ -2334,7 +2334,7 @@ return Owned(new (Context) CXXForRangeStmt(RangeDS, cast_or_null(BeginEndDecl.get()), - NotEqExpr.take(), IncrExpr.take(), + NotEqExpr.get(), IncrExpr.get(), LoopVarDS, /*Body=*/nullptr, ForLoc, ColonLoc, RParenLoc)); } @@ -2390,7 +2390,7 @@ CheckSingleAssignmentConstraints(DestTy, ExprRes); if (ExprRes.isInvalid()) return StmtError(); - E = ExprRes.take(); + E = ExprRes.get(); if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing)) return StmtError(); } @@ -2398,7 +2398,7 @@ ExprResult ExprRes = ActOnFinishFullExpr(E); if (ExprRes.isInvalid()) return StmtError(); - E = ExprRes.take(); + E = ExprRes.get(); getCurFunction()->setHasIndirectGoto(); @@ -2620,7 +2620,7 @@ ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp); if (Result.isInvalid()) return StmtError(); - RetValExp = Result.take(); + RetValExp = Result.get(); if (!CurContext->isDependentContext()) FnRetType = RetValExp->getType(); @@ -2704,7 +2704,7 @@ // FIXME: Cleanup temporaries here, anyway? return StmtError(); } - RetValExp = Res.take(); + RetValExp = Res.get(); CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc); } else { NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false); @@ -2714,7 +2714,7 @@ ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); if (ER.isInvalid()) return StmtError(); - RetValExp = ER.take(); + RetValExp = ER.get(); } ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate); @@ -2922,12 +2922,12 @@ } else { ExprResult Result = Owned(RetValExp); - Result = IgnoredValueConversions(Result.take()); + Result = IgnoredValueConversions(Result.get()); if (Result.isInvalid()) return StmtError(); - RetValExp = Result.take(); + RetValExp = Result.get(); RetValExp = ImpCastExprToType(RetValExp, - Context.VoidTy, CK_ToVoid).take(); + Context.VoidTy, CK_ToVoid).get(); } // return of void in constructor/destructor is illegal in C++. if (D == diag::err_ctor_dtor_returns_void) { @@ -2959,7 +2959,7 @@ ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); if (ER.isInvalid()) return StmtError(); - RetValExp = ER.take(); + RetValExp = ER.get(); } } @@ -2999,7 +2999,7 @@ // FIXME: Clean up temporaries here anyway? return StmtError(); } - RetValExp = Res.takeAs(); + RetValExp = Res.getAs(); // If we have a related result type, we need to implicitly // convert back to the formal result type. We can't pretend to @@ -3013,7 +3013,7 @@ // FIXME: Clean up temporaries here anyway? return StmtError(); } - RetValExp = Res.takeAs(); + RetValExp = Res.getAs(); } CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc, isObjCMethod, Attrs, @@ -3024,7 +3024,7 @@ ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); if (ER.isInvalid()) return StmtError(); - RetValExp = ER.take(); + RetValExp = ER.get(); } Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate); } @@ -3073,10 +3073,10 @@ if (Result.isInvalid()) return StmtError(); - Result = ActOnFinishFullExpr(Result.take()); + Result = ActOnFinishFullExpr(Result.get()); if (Result.isInvalid()) return StmtError(); - Throw = Result.take(); + Throw = Result.get(); QualType ThrowType = Throw->getType(); // Make sure the expression type is an ObjC pointer or "void *". @@ -3115,7 +3115,7 @@ ExprResult result = DefaultLvalueConversion(operand); if (result.isInvalid()) return ExprError(); - operand = result.take(); + operand = result.get(); // Make sure the expression type is an ObjC pointer or "void *". QualType type = operand->getType(); Index: lib/Sema/SemaStmtAsm.cpp =================================================================== --- lib/Sema/SemaStmtAsm.cpp +++ lib/Sema/SemaStmtAsm.cpp @@ -166,7 +166,7 @@ if (Result.isInvalid()) return StmtError(); - Exprs[i] = Result.take(); + Exprs[i] = Result.get(); InputConstraintInfos.push_back(Info); const Type *Ty = Exprs[i]->getType().getTypePtr(); @@ -351,7 +351,7 @@ InputExpr->isEvaluatable(Context)) { CastKind castKind = (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast); - InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take(); + InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).get(); Exprs[InputOpNo] = InputExpr; NS->setInputExpr(i, InputExpr); continue; @@ -389,7 +389,7 @@ if (!Result.isUsable()) return Result; - Result = CheckPlaceholderExpr(Result.take()); + Result = CheckPlaceholderExpr(Result.get()); if (!Result.isUsable()) return Result; QualType T = Result.get()->getType(); Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp +++ lib/Sema/SemaTemplate.cpp @@ -731,7 +731,7 @@ Param->setInvalidDecl(); return Param; } - Default = DefaultRes.take(); + Default = DefaultRes.get(); Param->setDefaultArgument(Default, false); } @@ -3310,7 +3310,7 @@ if (Arg.isInvalid()) return TemplateArgumentLoc(); - Expr *ArgE = Arg.takeAs(); + Expr *ArgE = Arg.getAs(); return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE); } @@ -3461,13 +3461,13 @@ // If we parsed the template argument as a pack expansion, create a // pack expansion expression. if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){ - E = ActOnPackExpansion(E.take(), Arg.getTemplateEllipsisLoc()); + E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc()); if (E.isInvalid()) return true; } TemplateArgument Result; - E = CheckTemplateArgument(NTTP, NTTPType, E.take(), Result); + E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result); if (E.isInvalid()) return true; @@ -3817,7 +3817,7 @@ if (E.isInvalid()) return true; - Expr *Ex = E.takeAs(); + Expr *Ex = E.getAs(); Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex); } else { TemplateTemplateParmDecl *TempParm @@ -4168,7 +4168,7 @@ ExprResult ArgRV = S.DefaultFunctionArrayConversion(Arg); if (ArgRV.isInvalid()) return NPV_Error; - Arg = ArgRV.take(); + Arg = ArgRV.get(); Expr::EvalResult EvalResult; SmallVector Notes; @@ -4611,7 +4611,7 @@ ParamType.getNonReferenceType(), false, ObjCLifetimeConversion)) { Arg = S.ImpCastExprToType(Arg, ParamType, CK_NoOp, - Arg->getValueKind()).take(); + Arg->getValueKind()).get(); ResultArg = Arg; } else if (!S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType.getNonReferenceType())) { @@ -4809,7 +4809,7 @@ ExprResult ArgResult = DefaultLvalueConversion(Arg); if (ArgResult.isInvalid()) return ExprError(); - Arg = ArgResult.take(); + Arg = ArgResult.get(); QualType ArgType = Arg->getType(); @@ -4842,7 +4842,7 @@ } Diagnoser(ArgType); Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser, - false).take(); + false).get(); if (!Arg) return ExprError(); } @@ -4857,11 +4857,11 @@ // Okay: no conversion necessary } else if (ParamType->isBooleanType()) { // This is an integral-to-boolean conversion. - Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).take(); + Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get(); } else if (IsIntegralPromotion(Arg, ArgType, ParamType) || !ParamType->isEnumeralType()) { // This is an integral promotion or conversion. - Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).take(); + Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get(); } else { // We can't perform this conversion. Diag(Arg->getLocStart(), @@ -5192,7 +5192,7 @@ if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType(), false, ObjCLifetimeConversion)) - RefExpr = ImpCastExprToType(RefExpr.take(), ParamType.getUnqualifiedType(), CK_NoOp); + RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp); assert(!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), @@ -5212,7 +5212,7 @@ if (T->isFunctionType() || T->isArrayType()) { // Decay functions and arrays. - RefExpr = DefaultFunctionArrayConversion(RefExpr.take()); + RefExpr = DefaultFunctionArrayConversion(RefExpr.get()); if (RefExpr.isInvalid()) return ExprError(); Index: lib/Sema/SemaTemplateDeduction.cpp =================================================================== --- lib/Sema/SemaTemplateDeduction.cpp +++ lib/Sema/SemaTemplateDeduction.cpp @@ -2020,21 +2020,21 @@ case TemplateArgument::Declaration: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) - .takeAs(); + .getAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::NullPtr: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) - .takeAs(); + .getAs(); return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), E); } case TemplateArgument::Integral: { Expr *E - = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs(); + = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } @@ -3982,7 +3982,7 @@ ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); if (NonPlaceholder.isInvalid()) return DAR_FailedAlreadyDiagnosed; - Init = NonPlaceholder.take(); + Init = NonPlaceholder.get(); } if (Init->isTypeDependent() || Type.getType()->isDependentType()) { Index: lib/Sema/SemaTemplateInstantiate.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiate.cpp +++ lib/Sema/SemaTemplateInstantiate.cpp @@ -1185,7 +1185,7 @@ } if (result.isInvalid()) return ExprError(); - Expr *resultExpr = result.take(); + Expr *resultExpr = result.get(); return SemaRef.Owned(new (SemaRef.Context) SubstNonTypeTemplateParmExpr(type, resultExpr->getValueKind(), @@ -2035,7 +2035,7 @@ ActOnStartCXXInClassMemberInitializer(); ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs, /*CXXDirectInit=*/false); - Expr *Init = NewInit.take(); + Expr *Init = NewInit.get(); assert((!Init || !isa(Init)) && "call-style init in class"); ActOnFinishCXXInClassMemberInitializer(NewField, Init->getLocStart(), Index: lib/Sema/SemaTemplateInstantiateDecl.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiateDecl.cpp +++ lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -79,7 +79,7 @@ EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated); ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs); if (!Result.isInvalid()) - S.AddAlignedAttr(Aligned->getLocation(), New, Result.takeAs(), + S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs(), Aligned->getSpellingListIndex(), IsPackExpansion); } else { TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(), @@ -138,13 +138,13 @@ ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs); if (Result.isInvalid()) return; - Cond = Result.takeAs(); + Cond = Result.getAs(); } if (A->getCond()->isTypeDependent() && !Cond->isTypeDependent()) { ExprResult Converted = S.PerformContextuallyConvertToBool(Cond); if (Converted.isInvalid()) return; - Cond = Converted.take(); + Cond = Converted.get(); } SmallVector Diags; @@ -473,7 +473,7 @@ Invalid = true; BitWidth = nullptr; } else - BitWidth = InstantiatedBitWidth.takeAs(); + BitWidth = InstantiatedBitWidth.getAs(); } FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), @@ -2313,7 +2313,7 @@ OMPThreadPrivateDecl *D) { SmallVector Vars; for (auto *I : D->varlists()) { - Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).take(); + Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get(); assert(isa(Var) && "threadprivate arg is not a DeclRefExpr"); Vars.push_back(Var); } @@ -3129,13 +3129,13 @@ E = SemaRef.CheckBooleanCondition(E.get(), E.get()->getLocStart()); if (E.isUsable()) { - NoexceptExpr = E.take(); + NoexceptExpr = E.get(); if (!NoexceptExpr->isTypeDependent() && !NoexceptExpr->isValueDependent()) NoexceptExpr = SemaRef.VerifyIntegerConstantExpression(NoexceptExpr, nullptr, diag::err_noexcept_needs_constant_expression, - /*AllowFold*/ false).take(); + /*AllowFold*/ false).get(); } } @@ -3679,7 +3679,7 @@ bool TypeMayContainAuto = true; if (Init.get()) { bool DirectInit = OldVar->isDirectInit(); - AddInitializerToDecl(Var, Init.take(), DirectInit, TypeMayContainAuto); + AddInitializerToDecl(Var, Init.get(), DirectInit, TypeMayContainAuto); } else ActOnUninitializedDecl(Var, TypeMayContainAuto); } else { @@ -4058,7 +4058,7 @@ // Build the initializer. MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(), - BaseTInfo, TempInit.take(), + BaseTInfo, TempInit.get(), New->getParent(), SourceLocation()); if (NewInit.isInvalid()) { @@ -4093,10 +4093,10 @@ } if (Init->isBaseInitializer()) - NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.take(), + NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(), New->getParent(), EllipsisLoc); else - NewInit = BuildDelegatingInitializer(TInfo, TempInit.take(), + NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(), cast(CurContext->getParent())); } else if (Init->isMemberInitializer()) { FieldDecl *Member = cast_or_null(FindInstantiatedDecl( @@ -4109,7 +4109,7 @@ continue; } - NewInit = BuildMemberInitializer(Member, TempInit.take(), + NewInit = BuildMemberInitializer(Member, TempInit.get(), Init->getSourceLocation()); } else if (Init->isIndirectMemberInitializer()) { IndirectFieldDecl *IndirectMember = @@ -4123,7 +4123,7 @@ continue; } - NewInit = BuildMemberInitializer(IndirectMember, TempInit.take(), + NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(), Init->getSourceLocation()); } Index: lib/Sema/SemaType.cpp =================================================================== --- lib/Sema/SemaType.cpp +++ lib/Sema/SemaType.cpp @@ -1566,7 +1566,7 @@ if (ArraySize && ArraySize->hasPlaceholderType()) { ExprResult Result = CheckPlaceholderExpr(ArraySize); if (Result.isInvalid()) return QualType(); - ArraySize = Result.take(); + ArraySize = Result.get(); } // Do lvalue-to-rvalue conversions on the array size expression. @@ -1575,7 +1575,7 @@ if (Result.isInvalid()) return QualType(); - ArraySize = Result.take(); + ArraySize = Result.get(); } // C99 6.7.5.2p1: The size expression shall have integer type. @@ -5461,7 +5461,7 @@ QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) { ExprResult ER = CheckPlaceholderExpr(E); if (ER.isInvalid()) return QualType(); - E = ER.take(); + E = ER.get(); if (!E->isTypeDependent()) { QualType T = E->getType(); @@ -5541,7 +5541,7 @@ QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc) { ExprResult ER = CheckPlaceholderExpr(E); if (ER.isInvalid()) return QualType(); - E = ER.take(); + E = ER.get(); return Context.getDecltypeType(E, getDecltypeForExpr(*this, E)); } Index: lib/Sema/TreeTransform.h =================================================================== --- lib/Sema/TreeTransform.h +++ lib/Sema/TreeTransform.h @@ -1463,7 +1463,7 @@ if (ForEachStmt.isInvalid()) return StmtError(); - return getSema().FinishObjCForCollectionStmt(ForEachStmt.take(), Body); + return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body); } /// \brief Build a new C++ exception declaration. @@ -1718,12 +1718,12 @@ "unnamed member not of record type?"); BaseResult = - getSema().PerformObjectMemberConversion(BaseResult.take(), + getSema().PerformObjectMemberConversion(BaseResult.get(), QualifierLoc.getNestedNameSpecifier(), FoundDecl, Member); if (BaseResult.isInvalid()) return ExprError(); - Base = BaseResult.take(); + Base = BaseResult.get(); ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind(); MemberExpr *ME = new (getSema().Context) MemberExpr(Base, isArrow, @@ -1736,7 +1736,7 @@ CXXScopeSpec SS; SS.Adopt(QualifierLoc); - Base = BaseResult.take(); + Base = BaseResult.get(); QualType BaseType = Base->getType(); // FIXME: this involves duplicating earlier analysis in a lot of @@ -2605,7 +2605,7 @@ VK_RValue, BuiltinLoc); QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType()); Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy, - CK_BuiltinFnToFnPtr).take(); + CK_BuiltinFnToFnPtr).get(); // Build the CallExpr ExprResult TheCall = SemaRef.Owned(new (SemaRef.Context) CallExpr( @@ -2613,7 +2613,7 @@ Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc)); // Type-check the __builtin_shufflevector expression. - return SemaRef.SemaBuiltinShuffleVector(cast(TheCall.take())); + return SemaRef.SemaBuiltinShuffleVector(cast(TheCall.get())); } /// \brief Build a new convert vector expression. @@ -3293,7 +3293,7 @@ ExprResult E = getDerived().TransformExpr(InputExpr); E = SemaRef.ActOnConstantExpression(E); if (E.isInvalid()) return true; - Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); + Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get()); return false; } } @@ -3940,8 +3940,8 @@ if (Size) { EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::ConstantEvaluated); - Size = getDerived().TransformExpr(Size).template takeAs(); - Size = SemaRef.ActOnConstantExpression(Size).take(); + Size = getDerived().TransformExpr(Size).template getAs(); + Size = SemaRef.ActOnConstantExpression(Size).get(); } NewTL.setSizeExpr(Size); @@ -3990,7 +3990,7 @@ if (SizeResult.isInvalid()) return QualType(); - Expr *Size = SizeResult.take(); + Expr *Size = SizeResult.get(); QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || @@ -4088,7 +4088,7 @@ ElementType != T->getElementType() || Size.get() != T->getSizeExpr()) { Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, - Size.take(), + Size.get(), T->getAttributeLoc()); if (Result.isNull()) return QualType(); @@ -4577,7 +4577,7 @@ if (Result.isNull()) return QualType(); } - else E.take(); + else E.get(); TypeOfExprTypeLoc NewTL = TLB.push(Result); NewTL.setTypeofLoc(TL.getTypeofLoc()); @@ -4624,7 +4624,7 @@ if (E.isInvalid()) return QualType(); - E = getSema().ActOnDecltypeExpression(E.take()); + E = getSema().ActOnDecltypeExpression(E.get()); if (E.isInvalid()) return QualType(); @@ -4635,7 +4635,7 @@ if (Result.isNull()) return QualType(); } - else E.take(); + else E.get(); DecltypeTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); @@ -5334,7 +5334,7 @@ } SubStmtChanged = SubStmtChanged || Result.get() != B; - Statements.push_back(Result.takeAs()); + Statements.push_back(Result.getAs()); } if (SubStmtInvalid) @@ -5470,7 +5470,7 @@ } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5565,7 +5565,7 @@ } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5644,7 +5644,7 @@ } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5693,7 +5693,7 @@ ExprResult Target = getDerived().TransformExpr(S->getTarget()); if (Target.isInvalid()) return StmtError(); - Target = SemaRef.MaybeCreateExprWithCleanups(Target.take()); + Target = SemaRef.MaybeCreateExprWithCleanups(Target.get()); if (!getDerived().AlwaysRebuild() && Target.get() == S->getTarget()) @@ -5831,7 +5831,7 @@ HadError = true; } else { HadChange |= (Result.get() != SrcExprs[i]); - TransformedExprs.push_back(Result.take()); + TransformedExprs.push_back(Result.get()); } } @@ -5863,7 +5863,7 @@ return StmtError(); if (Catch.get() != S->getCatchStmt(I)) AnyCatchChanged = true; - CatchStmts.push_back(Catch.release()); + CatchStmts.push_back(Catch.get()); } // Transform the @finally statement (if present). @@ -6085,7 +6085,7 @@ return StmtError(); HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); - Handlers.push_back(Handler.takeAs()); + Handlers.push_back(Handler.getAs()); } if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && @@ -6111,17 +6111,17 @@ if (Cond.isInvalid()) return StmtError(); if (Cond.get()) - Cond = SemaRef.CheckBooleanCondition(Cond.take(), S->getColonLoc()); + Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc()); if (Cond.isInvalid()) return StmtError(); if (Cond.get()) - Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.take()); + Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get()); ExprResult Inc = getDerived().TransformExpr(S->getInc()); if (Inc.isInvalid()) return StmtError(); if (Inc.get()) - Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.take()); + Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get()); StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); if (LoopVar.isInvalid()) @@ -6275,7 +6275,7 @@ return SemaRef.Owned(S); return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(), - TryBlock.take(), Handler.take()); + TryBlock.get(), Handler.get()); } template @@ -6284,7 +6284,7 @@ if (Block.isInvalid()) return StmtError(); - return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.take()); + return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get()); } template @@ -6297,8 +6297,8 @@ if (Block.isInvalid()) return StmtError(); - return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.take(), - Block.take()); + return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(), + Block.get()); } template @@ -6342,7 +6342,7 @@ return getDerived().RebuildOMPExecutableDirective(D->getDirectiveKind(), TClauses, - AssociatedStmt.take(), + AssociatedStmt.get(), D->getLocStart(), D->getLocEnd()); } @@ -6373,7 +6373,7 @@ ExprResult Cond = getDerived().TransformExpr(C->getCondition()); if (Cond.isInvalid()) return nullptr; - return getDerived().RebuildOMPIfClause(Cond.take(), C->getLocStart(), + return getDerived().RebuildOMPIfClause(Cond.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); } @@ -6383,7 +6383,7 @@ ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads()); if (NumThreads.isInvalid()) return nullptr; - return getDerived().RebuildOMPNumThreadsClause(NumThreads.take(), + return getDerived().RebuildOMPNumThreadsClause(NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); @@ -6396,7 +6396,7 @@ if (E.isInvalid()) return nullptr; return getDerived().RebuildOMPSafelenClause( - E.take(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); + E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); } template @@ -6428,7 +6428,7 @@ ExprResult EVar = getDerived().TransformExpr(cast(VE)); if (EVar.isInvalid()) return nullptr; - Vars.push_back(EVar.take()); + Vars.push_back(EVar.get()); } return getDerived().RebuildOMPPrivateClause(Vars, C->getLocStart(), @@ -6446,7 +6446,7 @@ ExprResult EVar = getDerived().TransformExpr(cast(VE)); if (EVar.isInvalid()) return nullptr; - Vars.push_back(EVar.take()); + Vars.push_back(EVar.get()); } return getDerived().RebuildOMPFirstprivateClause(Vars, C->getLocStart(), @@ -6463,7 +6463,7 @@ ExprResult EVar = getDerived().TransformExpr(cast(VE)); if (EVar.isInvalid()) return nullptr; - Vars.push_back(EVar.take()); + Vars.push_back(EVar.get()); } return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(), @@ -6480,13 +6480,13 @@ ExprResult EVar = getDerived().TransformExpr(cast(VE)); if (EVar.isInvalid()) return nullptr; - Vars.push_back(EVar.take()); + Vars.push_back(EVar.get()); } ExprResult Step = getDerived().TransformExpr(C->getStep()); if (Step.isInvalid()) return nullptr; return getDerived().RebuildOMPLinearClause( - Vars, Step.take(), C->getLocStart(), C->getLParenLoc(), C->getColonLoc(), + Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getColonLoc(), C->getLocEnd()); } @@ -6499,7 +6499,7 @@ ExprResult EVar = getDerived().TransformExpr(cast(VE)); if (EVar.isInvalid()) return nullptr; - Vars.push_back(EVar.take()); + Vars.push_back(EVar.get()); } return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(), @@ -6630,13 +6630,13 @@ ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); if (AssocExpr.isInvalid()) return ExprError(); - AssocExprs.push_back(AssocExpr.release()); + AssocExprs.push_back(AssocExpr.get()); } return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(), - ControllingExpr.release(), + ControllingExpr.get(), AssocTypes, AssocExprs); } @@ -6777,7 +6777,7 @@ // expression must have been an lvalue-to-rvalue conversion which we // should reapply. if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) - result = SemaRef.checkPseudoObjectRValue(result.take()); + result = SemaRef.checkPseudoObjectRValue(result.get()); return result; } @@ -6999,7 +6999,7 @@ rhs.get() == e->getFalseExpr()) return SemaRef.Owned(e); - return getDerived().RebuildConditionalOperator(commonExpr.take(), + return getDerived().RebuildConditionalOperator(commonExpr.get(), e->getQuestionLoc(), nullptr, e->getColonLoc(), @@ -7159,7 +7159,7 @@ D->getLBracketLoc())); ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); - ArrayExprs.push_back(Index.release()); + ArrayExprs.push_back(Index.get()); continue; } @@ -7181,8 +7181,8 @@ ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || End.get() != E->getArrayRangeEnd(*D); - ArrayExprs.push_back(Start.release()); - ArrayExprs.push_back(End.release()); + ArrayExprs.push_back(Start.get()); + ArrayExprs.push_back(End.get()); } if (!getDerived().AlwaysRebuild() && @@ -7799,7 +7799,7 @@ AllocTypeInfo, ArraySize.get(), E->getDirectInitRange(), - NewInit.take()); + NewInit.get()); } template @@ -8633,7 +8633,7 @@ return ExprError(); } - return getSema().ActOnLambdaExpr(E->getLocStart(), Body.take(), + return getSema().ActOnLambdaExpr(E->getLocStart(), Body.get(), /*CurScope=*/nullptr, /*IsInstantiation=*/true); } @@ -8776,7 +8776,7 @@ Base = getDerived().TransformExpr(Old->getBase()); if (Base.isInvalid()) return ExprError(); - Base = getSema().PerformMemberExprBaseConversion(Base.take(), + Base = getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow()); if (Base.isInvalid()) return ExprError(); @@ -9937,7 +9937,7 @@ return StmtError(); } - return getSema().ActOnCapturedRegionEnd(Body.take()); + return getSema().ActOnCapturedRegionEnd(Body.get()); } } // end namespace clang Index: utils/TableGen/ClangAttrEmitter.cpp =================================================================== --- utils/TableGen/ClangAttrEmitter.cpp +++ utils/TableGen/ClangAttrEmitter.cpp @@ -859,7 +859,7 @@ OS << " ExprResult " << "Result = S.SubstExpr(" << "A->get" << getUpperName() << "(), TemplateArgs);\n"; OS << " tempInst" << getUpperName() << " = " - << "Result.takeAs();\n"; + << "Result.getAs();\n"; OS << " }\n"; } @@ -911,7 +911,7 @@ << "_end();\n"; OS << " for (; I != E; ++I, ++TI) {\n"; OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n"; - OS << " *TI = Result.takeAs();\n"; + OS << " *TI = Result.getAs();\n"; OS << " }\n"; OS << " }\n"; }