From 07a4adf46bb5e110154c545a30a3488b7127cdef Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 12 Feb 2016 17:21:14 +0100 Subject: [PATCH] rustup --- src/attr.rs | 29 +++-- src/block.rs | 4 +- src/expr.rs | 232 +++++++++++++++++++++---------------- src/fn_decl.rs | 6 +- src/item.rs | 64 +++++----- src/lit.rs | 56 +++++---- src/method.rs | 42 +++---- src/pat.rs | 8 +- src/stmt.rs | 15 ++- src/struct_field.rs | 8 +- src/ty.rs | 20 ++-- tests/test_attr.rs | 2 +- tests/test_expr.rs | 72 ++++++------ tests/test_fn_decl.rs | 8 +- tests/test_item.rs | 72 ++++++------ tests/test_lit.rs | 49 +++----- tests/test_stmt.rs | 20 ++-- tests/test_struct_field.rs | 11 +- tests/test_ty.rs | 20 ++-- 19 files changed, 379 insertions(+), 359 deletions(-) diff --git a/src/attr.rs b/src/attr.rs index 2b2018a13..a3338c899 100644 --- a/src/attr.rs +++ b/src/attr.rs @@ -57,7 +57,7 @@ impl AttrBuilder self.callback.invoke(attr) } - pub fn build_meta_item_(self, item: ast::MetaItem_) -> F::Result { + pub fn build_meta_item_(self, item: ast::MetaItemKind) -> F::Result { let item = P(respan(self.span, item)); self.build_meta_item(item) } @@ -65,7 +65,7 @@ impl AttrBuilder pub fn word(self, word: T) -> F::Result where T: ToInternedString { - self.build_meta_item_(ast::MetaWord(word.to_interned_string())) + self.build_meta_item_(ast::MetaItemKind::Word(word.to_interned_string())) } pub fn list(self, word: T) -> AttrListBuilder @@ -153,12 +153,12 @@ impl Invoke> for AttrBuilder } } -impl Invoke for AttrBuilder +impl Invoke for AttrBuilder where F: Invoke, { type Result = F::Result; - fn invoke(self, item: ast::MetaItem_) -> F::Result { + fn invoke(self, item: ast::MetaItemKind) -> F::Result { self.build_meta_item_(item) } } @@ -199,7 +199,7 @@ impl AttrListBuilder } pub fn with_meta_items_(self, iter: I) -> Self - where I: IntoIterator, + where I: IntoIterator, { let iter = iter.into_iter(); let span = self.span; @@ -211,7 +211,7 @@ impl AttrListBuilder self } - pub fn with_meta_item_(self, item: ast::MetaItem_) -> Self { + pub fn with_meta_item_kind(self, item: ast::MetaItemKind) -> Self { let span = self.span; self.with_meta_item(P(respan(span, item))) } @@ -221,13 +221,13 @@ impl AttrListBuilder T: ToInternedString, { let iter = iter.into_iter(); - self.with_meta_items_(iter.map(|word| ast::MetaWord(word.to_interned_string()))) + self.with_meta_items_(iter.map(|word| ast::MetaItemKind::Word(word.to_interned_string()))) } pub fn word(self, word: T) -> Self where T: ToInternedString, { - self.with_meta_item_(ast::MetaWord(word.to_interned_string())) + self.with_meta_item_kind(ast::MetaItemKind::Word(word.to_interned_string())) } pub fn list(self, name: T) -> AttrListBuilder @@ -246,7 +246,7 @@ impl AttrListBuilder } pub fn build(self) -> F::Result { - let item = respan(self.span, ast::MetaList(self.name, self.items)); + let item = respan(self.span, ast::MetaItemKind::List(self.name, self.items)); self.callback.invoke(P(item)) } } @@ -261,13 +261,13 @@ impl Invoke> for AttrListBuilder } } -impl Invoke for AttrListBuilder +impl Invoke for AttrListBuilder where F: Invoke>, { type Result = Self; - fn invoke(self, item: ast::MetaItem_) -> Self { - self.with_meta_item_(item) + fn invoke(self, item: ast::MetaItemKind) -> Self { + self.with_meta_item_kind(item) } } @@ -278,12 +278,11 @@ pub struct AttrNameValueBuilder { name: token::InternedString, } -impl> Invoke> for AttrNameValueBuilder { +impl> Invoke> for AttrNameValueBuilder { type Result = F::Result; fn invoke(self, value: P) -> F::Result { - let item = ast::MetaNameValue(self.name, (*value).clone()); + let item = ast::MetaItemKind::NameValue(self.name, (*value).clone()); self.callback.invoke(item) } } - diff --git a/src/block.rs b/src/block.rs index e081d3598..7013fd10a 100644 --- a/src/block.rs +++ b/src/block.rs @@ -31,7 +31,7 @@ impl BlockBuilder callback: callback, span: DUMMY_SP, stmts: Vec::new(), - block_check_mode: ast::BlockCheckMode::DefaultBlock, + block_check_mode: ast::BlockCheckMode::Default, } } @@ -42,7 +42,7 @@ impl BlockBuilder pub fn unsafe_(mut self) -> Self { let source = ast::UnsafeSource::CompilerGenerated; - self.block_check_mode = ast::BlockCheckMode::UnsafeBlock(source); + self.block_check_mode = ast::BlockCheckMode::Unsafe(source); self } diff --git a/src/expr.rs b/src/expr.rs index 34d141722..d3d6476f4 100644 --- a/src/expr.rs +++ b/src/expr.rs @@ -62,7 +62,7 @@ impl ExprBuilder AttrBuilder::with_callback(self) } - pub fn build_expr_(self, expr: ast::Expr_) -> F::Result { + pub fn build_expr_kind(self, expr: ast::ExprKind) -> F::Result { let expr = P(ast::Expr { id: ast::DUMMY_NODE_ID, node: expr, @@ -73,11 +73,11 @@ impl ExprBuilder } pub fn build_path(self, path: ast::Path) -> F::Result { - self.build_expr_(ast::Expr_::ExprPath(None, path)) + self.build_expr_kind(ast::ExprKind::Path(None, path)) } pub fn build_qpath(self, qself: ast::QSelf, path: ast::Path) -> F::Result { - self.build_expr_(ast::Expr_::ExprPath(Some(qself), path)) + self.build_expr_kind(ast::ExprKind::Path(Some(qself), path)) } pub fn path(self) -> PathBuilder { @@ -95,7 +95,7 @@ impl ExprBuilder } pub fn build_lit(self, lit: P) -> F::Result { - self.build_expr_(ast::Expr_::ExprLit(lit)) + self.build_expr_kind(ast::ExprKind::Lit(lit)) } pub fn lit(self) -> LitBuilder { @@ -115,27 +115,55 @@ impl ExprBuilder } pub fn int(self, value: i64) -> F::Result { - self.lit().int(value) + if value < 0 { + self.neg().lit().int(-value) + } else { + self.lit().int(value) + } + } + + pub fn uint(self, value: u64) -> F::Result { + self.lit().uint(value as u64) } pub fn isize(self, value: isize) -> F::Result { - self.lit().isize(value) + if value < 0 { + self.neg().lit().isize(-value) + } else { + self.lit().isize(value) + } } pub fn i8(self, value: i8) -> F::Result { - self.lit().i8(value) + if value < 0 { + self.neg().lit().i8(-value) + } else { + self.lit().i8(value) + } } pub fn i16(self, value: i16) -> F::Result { - self.lit().i16(value) + if value < 0 { + self.neg().lit().i16(-value) + } else { + self.lit().i16(value) + } } pub fn i32(self, value: i32) -> F::Result { - self.lit().i32(value) + if value < 0 { + self.neg().lit().i32(-value) + } else { + self.lit().i32(value) + } } pub fn i64(self, value: i64) -> F::Result { - self.lit().i64(value) + if value < 0 { + self.neg().lit().i64(-value) + } else { + self.lit().i64(value) + } } pub fn usize(self, value: usize) -> F::Result { @@ -177,19 +205,19 @@ impl ExprBuilder } pub fn build_unary(self, unop: ast::UnOp, expr: P) -> F::Result { - self.build_expr_(ast::ExprUnary(unop, expr)) + self.build_expr_kind(ast::ExprKind::Unary(unop, expr)) } pub fn build_deref(self, expr: P) -> F::Result { - self.build_unary(ast::UnDeref, expr) + self.build_unary(ast::UnOp::Deref, expr) } pub fn build_not(self, expr: P) -> F::Result { - self.build_unary(ast::UnNot, expr) + self.build_unary(ast::UnOp::Not, expr) } pub fn build_neg(self, expr: P) -> F::Result { - self.build_unary(ast::UnNeg, expr) + self.build_unary(ast::UnOp::Neg, expr) } pub fn unary(self, unop: ast::UnOp) -> ExprBuilder> { @@ -200,98 +228,98 @@ impl ExprBuilder } pub fn deref(self) -> ExprBuilder> { - self.unary(ast::UnDeref) + self.unary(ast::UnOp::Deref) } pub fn not(self) -> ExprBuilder> { - self.unary(ast::UnNot) + self.unary(ast::UnOp::Not) } pub fn neg(self) -> ExprBuilder> { - self.unary(ast::UnNeg) + self.unary(ast::UnOp::Neg) } pub fn build_binary(self, - binop: ast::BinOp_, + binop: ast::BinOpKind, lhs: P, rhs: P) -> F::Result { let binop = respan(self.span, binop); - self.build_expr_(ast::Expr_::ExprBinary(binop, lhs, rhs)) + self.build_expr_kind(ast::ExprKind::Binary(binop, lhs, rhs)) } pub fn build_add(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiAdd, lhs, rhs) + self.build_binary(ast::BinOpKind::Add, lhs, rhs) } pub fn build_sub(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiSub, lhs, rhs) + self.build_binary(ast::BinOpKind::Sub, lhs, rhs) } pub fn build_mul(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiMul, lhs, rhs) + self.build_binary(ast::BinOpKind::Mul, lhs, rhs) } pub fn build_div(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiDiv, lhs, rhs) + self.build_binary(ast::BinOpKind::Div, lhs, rhs) } pub fn build_rem(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiRem, lhs, rhs) + self.build_binary(ast::BinOpKind::Rem, lhs, rhs) } pub fn build_and(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiAnd, lhs, rhs) + self.build_binary(ast::BinOpKind::And, lhs, rhs) } pub fn build_or(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiOr, lhs, rhs) + self.build_binary(ast::BinOpKind::Or, lhs, rhs) } pub fn build_bit_xor(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiBitXor, lhs, rhs) + self.build_binary(ast::BinOpKind::BitXor, lhs, rhs) } pub fn build_bit_and(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiBitAnd, lhs, rhs) + self.build_binary(ast::BinOpKind::BitAnd, lhs, rhs) } pub fn build_bit_or(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiBitOr, lhs, rhs) + self.build_binary(ast::BinOpKind::BitOr, lhs, rhs) } pub fn build_shl(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiShl, lhs, rhs) + self.build_binary(ast::BinOpKind::Shl, lhs, rhs) } pub fn build_shr(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiShr, lhs, rhs) + self.build_binary(ast::BinOpKind::Shr, lhs, rhs) } pub fn build_eq(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiEq, lhs, rhs) + self.build_binary(ast::BinOpKind::Eq, lhs, rhs) } pub fn build_lt(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiLt, lhs, rhs) + self.build_binary(ast::BinOpKind::Lt, lhs, rhs) } pub fn build_le(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiLe, lhs, rhs) + self.build_binary(ast::BinOpKind::Le, lhs, rhs) } pub fn build_ne(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiNe, lhs, rhs) + self.build_binary(ast::BinOpKind::Ne, lhs, rhs) } pub fn build_ge(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiGe, lhs, rhs) + self.build_binary(ast::BinOpKind::Ge, lhs, rhs) } pub fn build_gt(self, lhs: P, rhs: P) -> F::Result { - self.build_binary(ast::BinOp_::BiGt, lhs, rhs) + self.build_binary(ast::BinOpKind::Gt, lhs, rhs) } - pub fn binary(self, binop: ast::BinOp_) -> ExprBuilder> { + pub fn binary(self, binop: ast::BinOpKind) -> ExprBuilder> { ExprBuilder::with_callback(ExprBinaryLhsBuilder { builder: self, binop: binop, @@ -299,115 +327,115 @@ impl ExprBuilder } pub fn add(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiAdd) + self.binary(ast::BinOpKind::Add) } pub fn sub(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiSub) + self.binary(ast::BinOpKind::Sub) } pub fn mul(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiMul) + self.binary(ast::BinOpKind::Mul) } pub fn div(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiDiv) + self.binary(ast::BinOpKind::Div) } pub fn rem(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiRem) + self.binary(ast::BinOpKind::Rem) } pub fn and(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiAnd) + self.binary(ast::BinOpKind::And) } pub fn or(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiOr) + self.binary(ast::BinOpKind::Or) } pub fn bit_xor(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiBitXor) + self.binary(ast::BinOpKind::BitXor) } pub fn bit_and(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiBitAnd) + self.binary(ast::BinOpKind::BitAnd) } pub fn bit_or(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiBitOr) + self.binary(ast::BinOpKind::BitOr) } pub fn shl(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiShl) + self.binary(ast::BinOpKind::Shl) } pub fn shr(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiShr) + self.binary(ast::BinOpKind::Shr) } pub fn eq(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiEq) + self.binary(ast::BinOpKind::Eq) } pub fn lt(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiLt) + self.binary(ast::BinOpKind::Lt) } pub fn le(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiLe) + self.binary(ast::BinOpKind::Le) } pub fn ne(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiNe) + self.binary(ast::BinOpKind::Ne) } pub fn ge(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiGe) + self.binary(ast::BinOpKind::Ge) } pub fn gt(self) -> ExprBuilder> { - self.binary(ast::BinOp_::BiGt) + self.binary(ast::BinOpKind::Gt) } pub fn addr_of(self) -> ExprBuilder> { ExprBuilder::with_callback(ExprAddrOfBuilder { builder: self, - mutability: ast::Mutability::MutImmutable, + mutability: ast::Mutability::Immutable, }) } pub fn mut_addr_of(self) -> ExprBuilder> { ExprBuilder::with_callback(ExprAddrOfBuilder { builder: self, - mutability: ast::Mutability::MutMutable, + mutability: ast::Mutability::Mutable, }) } pub fn break_(self) -> F::Result { - self.build_expr_(ast::Expr_::ExprBreak(None)) + self.build_expr_kind(ast::ExprKind::Break(None)) } pub fn break_to(self, label: I) -> F::Result where I: ToIdent, { let label = respan(self.span, label.to_ident()); - self.build_expr_(ast::Expr_::ExprBreak(Some(label))) + self.build_expr_kind(ast::ExprKind::Break(Some(label))) } pub fn continue_(self) -> F::Result { - self.build_expr_(ast::Expr_::ExprAgain(None)) + self.build_expr_kind(ast::ExprKind::Again(None)) } pub fn continue_to(self, label: I) -> F::Result where I: ToIdent, { let label = respan(self.span, label.to_ident()); - self.build_expr_(ast::Expr_::ExprAgain(Some(label))) + self.build_expr_kind(ast::ExprKind::Again(Some(label))) } pub fn return_(self) -> F::Result { - self.build_expr_(ast::Expr_::ExprRet(None)) + self.build_expr_kind(ast::ExprKind::Ret(None)) } pub fn return_expr(self) -> ExprBuilder> { @@ -517,7 +545,7 @@ impl ExprBuilder } pub fn build_block(self, block: P) -> F::Result { - self.build_expr_(ast::ExprBlock(block)) + self.build_expr_kind(ast::ExprKind::Block(block)) } pub fn block(self) -> BlockBuilder { @@ -525,7 +553,7 @@ impl ExprBuilder } pub fn build_assign(self, lhs: P, rhs: P) -> F::Result { - self.build_expr_(ast::ExprAssign(lhs, rhs)) + self.build_expr_kind(ast::ExprKind::Assign(lhs, rhs)) } pub fn assign(self) -> ExprBuilder> { @@ -535,14 +563,14 @@ impl ExprBuilder } pub fn build_assign_op(self, - binop: ast::BinOp_, + binop: ast::BinOpKind, lhs: P, rhs: P) -> F::Result { let binop = respan(self.span, binop); - self.build_expr_(ast::ExprAssignOp(binop, lhs, rhs)) + self.build_expr_kind(ast::ExprKind::AssignOp(binop, lhs, rhs)) } - pub fn assign_op(self, binop: ast::BinOp_) -> ExprBuilder> { + pub fn assign_op(self, binop: ast::BinOpKind) -> ExprBuilder> { ExprBuilder::with_callback(ExprAssignOpBuilder { builder: self, binop: binop, @@ -550,51 +578,51 @@ impl ExprBuilder } pub fn add_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiAdd) + self.assign_op(ast::BinOpKind::Add) } pub fn sub_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiSub) + self.assign_op(ast::BinOpKind::Sub) } pub fn mul_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiMul) + self.assign_op(ast::BinOpKind::Mul) } pub fn rem_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiRem) + self.assign_op(ast::BinOpKind::Rem) } pub fn and_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiAnd) + self.assign_op(ast::BinOpKind::And) } pub fn or_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiOr) + self.assign_op(ast::BinOpKind::Or) } pub fn bit_xor_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiBitXor) + self.assign_op(ast::BinOpKind::BitXor) } pub fn bit_and_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiBitAnd) + self.assign_op(ast::BinOpKind::BitAnd) } pub fn bit_or_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiBitOr) + self.assign_op(ast::BinOpKind::BitOr) } pub fn bit_shl_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiShl) + self.assign_op(ast::BinOpKind::Shl) } pub fn bit_shr_assign(self) -> ExprBuilder> { - self.assign_op(ast::BinOp_::BiShr) + self.assign_op(ast::BinOpKind::Shr) } pub fn build_index(self, lhs: P, rhs: P) -> F::Result { - self.build_expr_(ast::ExprIndex(lhs, rhs)) + self.build_expr_kind(ast::ExprKind::Index(lhs, rhs)) } pub fn index(self) -> ExprBuilder> { @@ -604,7 +632,7 @@ impl ExprBuilder } pub fn build_repeat(self, lhs: P, rhs: P) -> F::Result { - self.build_expr_(ast::ExprRepeat(lhs, rhs)) + self.build_expr_kind(ast::ExprKind::Repeat(lhs, rhs)) } pub fn repeat(self) -> ExprBuilder> { @@ -797,7 +825,7 @@ impl Invoke> for ExprUnaryBuilder pub struct ExprBinaryLhsBuilder { builder: ExprBuilder, - binop: ast::BinOp_, + binop: ast::BinOpKind, } impl Invoke> for ExprBinaryLhsBuilder @@ -816,7 +844,7 @@ impl Invoke> for ExprBinaryLhsBuilder pub struct ExprBinaryRhsBuilder { builder: ExprBuilder, - binop: ast::BinOp_, + binop: ast::BinOpKind, lhs: P, } @@ -842,7 +870,7 @@ impl Invoke> for ExprReturnBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.builder.build_expr_(ast::Expr_::ExprRet(Some(expr))) + self.builder.build_expr_kind(ast::ExprKind::Ret(Some(expr))) } } @@ -868,7 +896,7 @@ impl>> ExprTupleBuilder } pub fn build(self) -> F::Result { - self.builder.build_expr_(ast::ExprTup(self.exprs)) + self.builder.build_expr_kind(ast::ExprKind::Tup(self.exprs)) } } @@ -947,8 +975,8 @@ impl ExprStructPathBuilder } pub fn build(self) -> F::Result { - let expr_ = ast::ExprStruct(self.path, self.fields, None); - self.builder.build_expr_(expr_) + let expr_kind = ast::ExprKind::Struct(self.path, self.fields, None); + self.builder.build_expr_kind(expr_kind) } } @@ -958,8 +986,8 @@ impl Invoke> for ExprStructPathBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - let expr_ = ast::ExprStruct(self.path, self.fields, Some(expr)); - self.builder.build_expr_(expr_) + let expr_kind = ast::ExprKind::Struct(self.path, self.fields, Some(expr)); + self.builder.build_expr_kind(expr_kind) } } @@ -1033,7 +1061,7 @@ impl ExprCallArgsBuilder } pub fn build(self) -> F::Result { - self.builder.build_expr_(ast::ExprCall(self.fn_, self.args)) + self.builder.build_expr_kind(ast::ExprKind::Call(self.fn_, self.args)) } } @@ -1114,7 +1142,7 @@ impl ExprMethodCallArgsBuilder } pub fn build(self) -> F::Result { - self.builder.build_expr_(ast::ExprMethodCall(self.id, self.tys, self.args)) + self.builder.build_expr_kind(ast::ExprKind::MethodCall(self.id, self.tys, self.args)) } } @@ -1151,7 +1179,7 @@ impl Invoke> for ExprAddrOfBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.builder.build_expr_(ast::ExprAddrOf(self.mutability, expr)) + self.builder.build_expr_kind(ast::ExprKind::AddrOf(self.mutability, expr)) } } @@ -1215,7 +1243,7 @@ impl Invoke> for ExprAssignLhsBuilder pub struct ExprAssignOpBuilder { builder: ExprBuilder, - binop: ast::BinOp_, + binop: ast::BinOpKind, } impl Invoke> for ExprAssignOpBuilder @@ -1236,7 +1264,7 @@ impl Invoke> for ExprAssignOpBuilder pub struct ExprAssignOpLhsBuilder { builder: ExprBuilder, - binop: ast::BinOp_, + binop: ast::BinOpKind, lhs: P, } @@ -1350,7 +1378,7 @@ impl Invoke> for ExprLoopBuilder type Result = F::Result; fn invoke(self, block: P) -> F::Result { - self.builder.build_expr_(ast::ExprLoop(block, self.label)) + self.builder.build_expr_kind(ast::ExprKind::Loop(block, self.label)) } } @@ -1433,7 +1461,7 @@ impl ExprIfThenElseBuilder .build_else_expr(else_); } - self.builder.build_expr_(ast::ExprIf(self.condition, self.then, Some(else_))) + self.builder.build_expr_kind(ast::ExprKind::If(self.condition, self.then, Some(else_))) } pub fn build_else(self, block: P) -> F::Result { @@ -1467,7 +1495,7 @@ impl ExprIfThenElseBuilder None => None }; - self.builder.build_expr_(ast::ExprIf(self.condition, self.then, else_)) + self.builder.build_expr_kind(ast::ExprKind::If(self.condition, self.then, else_)) } } @@ -1578,7 +1606,7 @@ impl ExprMatchArmBuilder } pub fn build(self) -> F::Result { - self.builder.build_expr_(ast::ExprMatch(self.expr, self.arms)) + self.builder.build_expr_kind(ast::ExprKind::Match(self.expr, self.arms)) } } @@ -1604,7 +1632,7 @@ impl Invoke> for ExprParenBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.builder.build_expr_(ast::ExprParen(expr)) + self.builder.build_expr_kind(ast::ExprKind::Paren(expr)) } } @@ -1621,7 +1649,7 @@ impl Invoke> for ExprFieldBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.builder.build_expr_(ast::ExprField(expr, self.id)) + self.builder.build_expr_kind(ast::ExprKind::Field(expr, self.id)) } } @@ -1638,7 +1666,7 @@ impl Invoke> for ExprTupFieldBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.builder.build_expr_(ast::ExprTupField(expr, self.index)) + self.builder.build_expr_kind(ast::ExprKind::TupField(expr, self.index)) } } @@ -1664,7 +1692,7 @@ impl>> ExprSliceBuilder } pub fn build(self) -> F::Result { - self.builder.build_expr_(ast::ExprVec(self.exprs)) + self.builder.build_expr_kind(ast::ExprKind::Vec(self.exprs)) } } diff --git a/src/fn_decl.rs b/src/fn_decl.rs index d08d70423..e1b640056 100644 --- a/src/fn_decl.rs +++ b/src/fn_decl.rs @@ -85,17 +85,17 @@ impl FnDeclBuilder } pub fn no_return(self) -> F::Result { - let ret_ty = ast::FunctionRetTy::NoReturn(self.span); + let ret_ty = ast::FunctionRetTy::None(self.span); self.build(ret_ty) } pub fn default_return(self) -> F::Result { - let ret_ty = ast::FunctionRetTy::DefaultReturn(self.span); + let ret_ty = ast::FunctionRetTy::Default(self.span); self.build(ret_ty) } pub fn build_return(self, ty: P) -> F::Result { - self.build(ast::FunctionRetTy::Return(ty)) + self.build(ast::FunctionRetTy::Ty(ty)) } pub fn return_(self) -> TyBuilder { diff --git a/src/item.rs b/src/item.rs index f9f620597..b6a37f358 100644 --- a/src/item.rs +++ b/src/item.rs @@ -78,14 +78,14 @@ impl ItemBuilder self } - pub fn build_item_(self, id: T, item_: ast::Item_) -> F::Result + pub fn build_item_kind(self, id: T, item_kind: ast::ItemKind) -> F::Result where T: ToIdent, { let item = ast::Item { ident: id.to_ident(), attrs: self.attrs, id: ast::DUMMY_NODE_ID, - node: item_, + node: item_kind, vis: self.vis, span: self.span, }; @@ -103,8 +103,8 @@ impl ItemBuilder } pub fn build_use(self, view_path: ast::ViewPath_) -> F::Result { - let item = ast::ItemUse(P(respan(self.span, view_path))); - self.build_item_(token::special_idents::invalid, item) + let item = ast::ItemKind::Use(P(respan(self.span, view_path))); + self.build_item_kind(token::special_idents::invalid, item) } pub fn use_(self) -> PathBuilder> { @@ -133,8 +133,8 @@ impl ItemBuilder let data = VariantDataBuilder::new().unit(); let generics = GenericsBuilder::new().build(); - let struct_ = ast::ItemStruct(data, generics); - self.build_item_(id, struct_) + let struct_ = ast::ItemKind::Struct(data, generics); + self.build_item_kind(id, struct_) } pub fn tuple_struct(self, id: T) -> ItemTupleStructBuilder @@ -303,7 +303,7 @@ impl ItemFnBuilder } pub fn build(self, block: P) -> F::Result { - self.builder.build_item_(self.id, ast::Item_::ItemFn( + self.builder.build_item_kind(self.id, ast::ItemKind::Fn( self.fn_decl, self.unsafety, self.constness, @@ -415,7 +415,7 @@ impl ItemUsePathListBuilder } pub fn self_(mut self) -> Self { - self.idents.push(respan(self.span, ast::PathListMod { + self.idents.push(respan(self.span, ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: None, })); @@ -425,7 +425,7 @@ impl ItemUsePathListBuilder pub fn id(mut self, id: T) -> Self where T: ToIdent, { - self.idents.push(respan(self.span, ast::PathListIdent { + self.idents.push(respan(self.span, ast::PathListItemKind::Ident { name: id.to_ident(), rename: None, id: ast::DUMMY_NODE_ID, @@ -494,8 +494,8 @@ impl Invoke for ItemStructBuilder type Result = F::Result; fn invoke(self, data: ast::VariantData) -> F::Result { - let struct_ = ast::ItemStruct(data, self.generics); - self.builder.build_item_(self.id, struct_) + let struct_ = ast::ItemKind::Struct(data, self.generics); + self.builder.build_item_kind(self.id, struct_) } } @@ -535,8 +535,8 @@ impl ItemTupleStructBuilder pub fn build(self) -> F::Result { let data = ast::VariantData::Tuple(self.fields, ast::DUMMY_NODE_ID); - let struct_ = ast::ItemStruct(data, self.generics); - self.builder.build_item_(self.id, struct_) + let struct_ = ast::ItemKind::Struct(data, self.generics); + self.builder.build_item_kind(self.id, struct_) } } @@ -643,8 +643,8 @@ impl ItemEnumBuilder let enum_def = ast::EnumDef { variants: self.variants, }; - let enum_ = ast::ItemEnum(enum_def, self.generics); - self.builder.build_item_(self.id, enum_) + let enum_ = ast::ItemKind::Enum(enum_def, self.generics); + self.builder.build_item_kind(self.id, enum_) } } @@ -681,13 +681,13 @@ impl ItemExternCrateBuilder where F: Invoke>, { pub fn with_name(self, name: ast::Name) -> F::Result { - let extern_ = ast::ItemExternCrate(Some(name)); - self.builder.build_item_(self.id, extern_) + let extern_ = ast::ItemKind::ExternCrate(Some(name)); + self.builder.build_item_kind(self.id, extern_) } pub fn build(self) -> F::Result { - let extern_ = ast::ItemExternCrate(None); - self.builder.build_item_(self.id, extern_) + let extern_ = ast::ItemKind::ExternCrate(None); + self.builder.build_item_kind(self.id, extern_) } } @@ -709,8 +709,8 @@ impl ItemMacBuilder } pub fn build(self, mac: ast::Mac) -> F::Result { - let item_mac = ast::ItemMac(mac); - self.builder.build_item_(ast::Name(0).to_ident(), item_mac) + let item_mac = ast::ItemKind::Mac(mac); + self.builder.build_item_kind(ast::Name(0).to_ident(), item_mac) } } @@ -754,8 +754,8 @@ impl ItemTyBuilder } pub fn build_ty(self, ty: P) -> F::Result { - let ty_ = ast::ItemTy(ty, self.generics); - self.builder.build_item_(self.id, ty_) + let ty_ = ast::ItemKind::Ty(ty, self.generics); + self.builder.build_item_kind(self.id, ty_) } } @@ -861,7 +861,7 @@ impl ItemTraitBuilder } pub fn build(self) -> F::Result { - self.builder.build_item_(self.id, ast::ItemTrait( + self.builder.build_item_kind(self.id, ast::ItemKind::Trait( self.unsafety, self.generics, P::from_vec(self.bounds), @@ -953,7 +953,7 @@ impl ItemTraitItemBuilder } } - pub fn build_item(self, node: ast::TraitItem_) -> F::Result { + pub fn build_item(self, node: ast::TraitItemKind) -> F::Result { let item = ast::TraitItem { id: ast::DUMMY_NODE_ID, ident: self.id, @@ -981,7 +981,7 @@ impl Invoke for ItemTraitItemBuilder type Result = F::Result; fn invoke(self, const_: Const) -> F::Result { - let node = ast::TraitItem_::ConstTraitItem( + let node = ast::TraitItemKind::Const( const_.ty, const_.expr); self.build_item(node) @@ -1012,7 +1012,7 @@ impl ItemTraitMethodBuilder where F: Invoke>, { pub fn build_option_block(self, block: Option>) -> F::Result { - let node = ast::TraitItem_::MethodTraitItem(self.method, block); + let node = ast::TraitItemKind::Method(self.method, block); self.builder.build_item(node) } @@ -1063,7 +1063,7 @@ impl ItemTraitTypeBuilder pub fn build_option_ty(self, ty: Option>) -> F::Result { let bounds = P::from_vec(self.bounds); - let node = ast::TraitItem_::TypeTraitItem(bounds, ty); + let node = ast::TraitItemKind::Type(bounds, ty); self.builder.build_item(node) } @@ -1147,14 +1147,14 @@ impl ItemImplBuilder } pub fn build_ty(self, ty: P) -> F::Result { - let ty_ = ast::ItemImpl( + let ty_ = ast::ItemKind::Impl( self.unsafety, self.polarity, self.generics, self.trait_ref, ty, self.items); - self.builder.build_item_(token::special_idents::invalid, ty_) + self.builder.build_item_kind(token::special_idents::invalid, ty_) } pub fn with_items(mut self, items: I) -> Self @@ -1410,7 +1410,7 @@ impl Invoke for ItemConstBuilder type Result = F::Result; fn invoke(self, const_: Const) -> F::Result { - let ty = ast::ItemConst(const_.ty, const_.expr.expect("an expr is required for a const item")); - self.builder.build_item_(self.id, ty) + let ty = ast::ItemKind::Const(const_.ty, const_.expr.expect("an expr is required for a const item")); + self.builder.build_item_kind(self.id, ty) } } diff --git a/src/lit.rs b/src/lit.rs index 27f512b22..c317016c6 100644 --- a/src/lit.rs +++ b/src/lit.rs @@ -37,7 +37,7 @@ impl LitBuilder self } - pub fn build_lit(self, lit: ast::Lit_) -> F::Result { + pub fn build_lit(self, lit: ast::LitKind) -> F::Result { self.callback.invoke(P(ast::Lit { span: self.span, node: lit, @@ -45,7 +45,7 @@ impl LitBuilder } pub fn bool(self, value: bool) -> F::Result { - self.build_lit(ast::LitBool(value)) + self.build_lit(ast::LitKind::Bool(value)) } pub fn true_(self) -> F::Result { @@ -57,95 +57,103 @@ impl LitBuilder } pub fn int(self, value: i64) -> F::Result { - let sign = ast::Sign::new(value); - self.build_lit(ast::LitInt(value as u64, ast::UnsuffixedIntLit(sign))) + assert!(value >= 0); + self.build_lit(ast::LitKind::Int(value as u64, ast::LitIntType::Unsuffixed)) } fn build_int(self, value: i64, ty: ast::IntTy) -> F::Result { - let sign = ast::Sign::new(value); - self.build_lit(ast::LitInt(value as u64, ast::LitIntType::SignedIntLit(ty, sign))) + assert!(value >= 0); + self.build_lit(ast::LitKind::Int(value as u64, ast::LitIntType::Signed(ty))) } pub fn isize(self, value: isize) -> F::Result { - self.build_int(value as i64, ast::IntTy::TyIs) + self.build_int(value as i64, ast::IntTy::Is) } pub fn i8(self, value: i8) -> F::Result { - self.build_int(value as i64, ast::IntTy::TyI8) + assert!(value >= 0); + self.build_int(value as i64, ast::IntTy::I8) } pub fn i16(self, value: i16) -> F::Result { - self.build_int(value as i64, ast::IntTy::TyI16) + assert!(value >= 0); + self.build_int(value as i64, ast::IntTy::I16) } pub fn i32(self, value: i32) -> F::Result { - self.build_int(value as i64, ast::IntTy::TyI32) + assert!(value >= 0); + self.build_int(value as i64, ast::IntTy::I32) } pub fn i64(self, value: i64) -> F::Result { - self.build_int(value, ast::IntTy::TyI64) + assert!(value >= 0); + self.build_int(value, ast::IntTy::I64) + } + + pub fn uint(self, value: u64) -> F::Result { + self.build_lit(ast::LitKind::Int(value, ast::LitIntType::Unsuffixed)) } fn build_uint(self, value: u64, ty: ast::UintTy) -> F::Result { - self.build_lit(ast::LitInt(value, ast::LitIntType::UnsignedIntLit(ty))) + self.build_lit(ast::LitKind::Int(value, ast::LitIntType::Unsigned(ty))) } pub fn usize(self, value: usize) -> F::Result { - self.build_uint(value as u64, ast::UintTy::TyUs) + self.build_uint(value as u64, ast::UintTy::Us) } pub fn u8(self, value: u8) -> F::Result { - self.build_uint(value as u64, ast::UintTy::TyU8) + self.build_uint(value as u64, ast::UintTy::U8) } pub fn u16(self, value: u16) -> F::Result { - self.build_uint(value as u64, ast::UintTy::TyU16) + self.build_uint(value as u64, ast::UintTy::U16) } pub fn u32(self, value: u32) -> F::Result { - self.build_uint(value as u64, ast::UintTy::TyU32) + self.build_uint(value as u64, ast::UintTy::U32) } pub fn u64(self, value: u64) -> F::Result { - self.build_uint(value, ast::UintTy::TyU64) + self.build_uint(value, ast::UintTy::U64) } fn build_float(self, value: S, ty: ast::FloatTy) -> F::Result where S: ToInternedString, { - self.build_lit(ast::LitFloat(value.to_interned_string(), ty)) + self.build_lit(ast::LitKind::Float(value.to_interned_string(), ty)) } pub fn f32(self, value: S) -> F::Result where S: ToInternedString, { - self.build_float(value, ast::FloatTy::TyF32) + self.build_float(value, ast::FloatTy::F32) } pub fn f64(self, value: S) -> F::Result where S: ToInternedString, { - self.build_float(value, ast::FloatTy::TyF64) + self.build_float(value, ast::FloatTy::F64) } pub fn char(self, value: char) -> F::Result { - self.build_lit(ast::LitChar(value)) + self.build_lit(ast::LitKind::Char(value)) } pub fn byte(self, value: u8) -> F::Result { - self.build_lit(ast::LitByte(value)) + self.build_lit(ast::LitKind::Byte(value)) } pub fn str(self, value: S) -> F::Result where S: ToInternedString, { let value = value.to_interned_string(); - self.build_lit(ast::LitStr(value, ast::CookedStr)) + self.build_lit(ast::LitKind::Str(value, ast::StrStyle::Cooked)) } pub fn byte_str(self, value: T) -> F::Result where T: Into>, { - self.build_lit(ast::LitByteStr(Rc::new(value.into()))) + self.build_lit(ast::LitKind::ByteStr(Rc::new(value.into()))) } } diff --git a/src/method.rs b/src/method.rs index e41ed8525..54c6e85ab 100644 --- a/src/method.rs +++ b/src/method.rs @@ -40,8 +40,8 @@ impl MethodSigBuilder generics: GenericsBuilder::new().build(), unsafety: ast::Unsafety::Normal, constness: ast::Constness::NotConst, - explicit_self: respan(DUMMY_SP, ast::ExplicitSelf_::SelfStatic), - self_mutable: ast::MutImmutable, + explicit_self: respan(DUMMY_SP, ast::SelfKind::Static), + self_mutable: ast::Mutability::Immutable, } } @@ -87,10 +87,10 @@ impl MethodSigBuilder pub fn build_fn_decl(self, mut fn_decl: P) -> F::Result { // Add `self` to the decl. match self.explicit_self.node { - ast::SelfStatic => { } - ast::SelfValue(id) - | ast::SelfRegion(_, _, id) - | ast::SelfExplicit(_, id) => { + ast::SelfKind::Static => { } + ast::SelfKind::Value(id) + | ast::SelfKind::Region(_, _, id) + | ast::SelfKind::Explicit(_, id) => { fn_decl = fn_decl.map(|mut fn_decl| { let arg = ast::Arg::new_self(self.span, self.self_mutable, id); fn_decl.inputs.insert(0, arg); @@ -165,7 +165,7 @@ impl SelfBuilder SelfBuilder { callback: callback, span: DUMMY_SP, - mutable: ast::MutImmutable, + mutable: ast::Mutability::Immutable, } } @@ -178,32 +178,32 @@ impl SelfBuilder self } - pub fn build_self_(self, self_: ast::ExplicitSelf_) -> F::Result { + pub fn build_self_kind(self, self_: ast::SelfKind) -> F::Result { let self_ = respan(self.span, self_); self.build(self_) } pub fn mut_(mut self) -> Self { - self.mutable = ast::MutMutable; + self.mutable = ast::Mutability::Mutable; self } pub fn static_(self) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfStatic) + self.build_self_kind(ast::SelfKind::Static) } pub fn mut_static(self) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfStatic) + self.build_self_kind(ast::SelfKind::Static) } pub fn value(self) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfValue("self".to_ident())) + self.build_self_kind(ast::SelfKind::Value("self".to_ident())) } pub fn ref_(self) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfRegion( + self.build_self_kind(ast::SelfKind::Region( None, - ast::Mutability::MutImmutable, + ast::Mutability::Immutable, "self".to_ident(), )) } @@ -211,17 +211,17 @@ impl SelfBuilder pub fn ref_lifetime(self, lifetime: L) -> F::Result where L: IntoLifetime, { - self.build_self_(ast::ExplicitSelf_::SelfRegion( + self.build_self_kind(ast::SelfKind::Region( Some(lifetime.into_lifetime()), - ast::Mutability::MutImmutable, + ast::Mutability::Immutable, "self".to_ident(), )) } pub fn ref_mut(self) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfRegion( + self.build_self_kind(ast::SelfKind::Region( None, - ast::Mutability::MutMutable, + ast::Mutability::Mutable, "self".to_ident(), )) } @@ -229,9 +229,9 @@ impl SelfBuilder pub fn ref_mut_lifetime(self, lifetime: L) -> F::Result where L: IntoLifetime, { - self.build_self_(ast::ExplicitSelf_::SelfRegion( + self.build_self_kind(ast::SelfKind::Region( Some(lifetime.into_lifetime()), - ast::Mutability::MutMutable, + ast::Mutability::Mutable, "self".to_ident(), )) } @@ -247,6 +247,6 @@ impl Invoke> for SelfBuilder type Result = F::Result; fn invoke(self, ty: P) -> F::Result { - self.build_self_(ast::ExplicitSelf_::SelfExplicit(ty, "self".to_ident())) + self.build_self_kind(ast::SelfKind::Explicit(ty, "self".to_ident())) } } diff --git a/src/pat.rs b/src/pat.rs index d0deaeeb7..46b979679 100644 --- a/src/pat.rs +++ b/src/pat.rs @@ -67,28 +67,28 @@ impl PatBuilder pub fn id(self, id: I) -> F::Result where I: ToIdent { - let mode = ast::BindingMode::ByValue(ast::Mutability::MutImmutable); + let mode = ast::BindingMode::ByValue(ast::Mutability::Immutable); self.build_id(mode, id, None) } pub fn mut_id(self, id: I) -> F::Result where I: ToIdent { - let mode = ast::BindingMode::ByValue(ast::Mutability::MutMutable); + let mode = ast::BindingMode::ByValue(ast::Mutability::Mutable); self.build_id(mode, id, None) } pub fn ref_id(self, id: I) -> F::Result where I: ToIdent { - let mode = ast::BindingMode::ByRef(ast::Mutability::MutImmutable); + let mode = ast::BindingMode::ByRef(ast::Mutability::Immutable); self.build_id(mode, id, None) } pub fn ref_mut_id(self, id: I) -> F::Result where I: ToIdent { - let mode = ast::BindingMode::ByRef(ast::Mutability::MutMutable); + let mode = ast::BindingMode::ByRef(ast::Mutability::Mutable); self.build_id(mode, id, None) } diff --git a/src/stmt.rs b/src/stmt.rs index bbfc4c0c3..e132d2535 100644 --- a/src/stmt.rs +++ b/src/stmt.rs @@ -45,7 +45,7 @@ impl StmtBuilder self } - pub fn build_stmt_(self, stmt_: ast::Stmt_) -> F::Result { + pub fn build_stmt_kind(self, stmt_: ast::StmtKind) -> F::Result { let stmt = P(respan(self.span, stmt_)); self.build(stmt) } @@ -63,9 +63,9 @@ impl StmtBuilder attrs: self.attrs.clone().into_thin_attrs(), }; - let decl = respan(self.span, ast::Decl_::DeclLocal(P(local))); + let decl = respan(self.span, ast::DeclKind::Local(P(local))); - self.build_stmt_(ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)) + self.build_stmt_kind(ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)) } pub fn let_(self) -> PatBuilder { @@ -80,7 +80,7 @@ impl StmtBuilder } pub fn build_expr(self, expr: P) -> F::Result { - self.build_stmt_(ast::Stmt_::StmtExpr(expr, ast::DUMMY_NODE_ID)) + self.build_stmt_kind(ast::StmtKind::Expr(expr, ast::DUMMY_NODE_ID)) } pub fn expr(self) -> ExprBuilder> { @@ -94,8 +94,8 @@ impl StmtBuilder } pub fn build_item(self, item: P) -> F::Result { - let decl = respan(self.span, ast::Decl_::DeclItem(item)); - self.build_stmt_(ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)) + let decl = respan(self.span, ast::DeclKind::Item(item)); + self.build_stmt_kind(ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)) } pub fn item(self) -> ItemBuilder> { @@ -155,7 +155,7 @@ impl Invoke> for StmtSemiBuilder type Result = F::Result; fn invoke(self, expr: P) -> F::Result { - self.0.build_stmt_(ast::Stmt_::StmtSemi(expr, ast::DUMMY_NODE_ID)) + self.0.build_stmt_kind(ast::StmtKind::Semi(expr, ast::DUMMY_NODE_ID)) } } @@ -257,4 +257,3 @@ impl Invoke> for StmtItemBuilder self.0.build_item(item) } } - diff --git a/src/struct_field.rs b/src/struct_field.rs index 74cfd0ec2..c925e363c 100644 --- a/src/struct_field.rs +++ b/src/struct_field.rs @@ -38,7 +38,7 @@ impl StructFieldBuilder StructFieldBuilder { callback: callback, span: DUMMY_SP, - kind: ast::StructFieldKind::NamedField(id, ast::Inherited), + kind: ast::StructFieldKind::NamedField(id, ast::Visibility::Inherited), attrs: vec![], } } @@ -47,7 +47,7 @@ impl StructFieldBuilder StructFieldBuilder { callback: callback, span: DUMMY_SP, - kind: ast::StructFieldKind::UnnamedField(ast::Inherited), + kind: ast::StructFieldKind::UnnamedField(ast::Visibility::Inherited), attrs: vec![], } } @@ -59,8 +59,8 @@ impl StructFieldBuilder pub fn pub_(mut self) -> Self { match self.kind { - ast::StructFieldKind::NamedField(_, ref mut vis) => { *vis = ast::Public; } - ast::StructFieldKind::UnnamedField(ref mut vis) => { *vis = ast::Public; } + ast::StructFieldKind::NamedField(_, ref mut vis) => { *vis = ast::Visibility::Public; } + ast::StructFieldKind::UnnamedField(ref mut vis) => { *vis = ast::Visibility::Public; } } self } diff --git a/src/ty.rs b/src/ty.rs index 1553739dd..008f5849d 100644 --- a/src/ty.rs +++ b/src/ty.rs @@ -44,7 +44,7 @@ impl TyBuilder self } - pub fn build_ty_(self, ty_: ast::Ty_) -> F::Result { + pub fn build_ty_kind(self, ty_: ast::TyKind) -> F::Result { let span = self.span; self.build(P(ast::Ty { id: ast::DUMMY_NODE_ID, @@ -60,11 +60,11 @@ impl TyBuilder } pub fn build_path(self, path: ast::Path) -> F::Result { - self.build_ty_(ast::Ty_::TyPath(None, path)) + self.build_ty_kind(ast::TyKind::Path(None, path)) } pub fn build_qpath(self, qself: ast::QSelf, path: ast::Path) -> F::Result { - self.build_ty_(ast::Ty_::TyPath(Some(qself), path)) + self.build_ty_kind(ast::TyKind::Path(Some(qself), path)) } pub fn path(self) -> PathBuilder> { @@ -139,7 +139,7 @@ impl TyBuilder } pub fn build_slice(self, ty: P) -> F::Result { - self.build_ty_(ast::Ty_::TyVec(ty)) + self.build_ty_kind(ast::TyKind::Vec(ty)) } pub fn slice(self) -> TyBuilder> { @@ -150,12 +150,12 @@ impl TyBuilder TyRefBuilder { builder: self, lifetime: None, - mutability: ast::MutImmutable, + mutability: ast::Mutability::Immutable, } } pub fn infer(self) -> F::Result { - self.build_ty_(ast::TyInfer) + self.build_ty_kind(ast::TyKind::Infer) } pub fn option(self) -> TyBuilder> { @@ -239,7 +239,7 @@ impl TyRefBuilder where F: Invoke>, { pub fn mut_(mut self) -> Self { - self.mutability = ast::MutMutable; + self.mutability = ast::Mutability::Mutable; self } @@ -259,7 +259,7 @@ impl TyRefBuilder ty: ty, mutbl: self.mutability, }; - self.builder.build_ty_(ast::TyRptr(self.lifetime, ty)) + self.builder.build_ty_kind(ast::TyKind::Rptr(self.lifetime, ty)) } pub fn ty(self) -> TyBuilder { @@ -476,7 +476,7 @@ impl TyObjectSumTyBuilder pub fn build(self) -> F::Result { let bounds = P::from_vec(self.bounds); - self.builder.build_ty_(ast::Ty_::TyObjectSum(self.ty, bounds)) + self.builder.build_ty_kind(ast::TyKind::ObjectSum(self.ty, bounds)) } } @@ -517,7 +517,7 @@ impl TyTupleBuilder } pub fn build(self) -> F::Result { - self.builder.build_ty_(ast::TyTup(self.tys)) + self.builder.build_ty_kind(ast::TyKind::Tup(self.tys)) } } diff --git a/tests/test_attr.rs b/tests/test_attr.rs index 0cbc531cf..51b4fabd6 100644 --- a/tests/test_attr.rs +++ b/tests/test_attr.rs @@ -16,7 +16,7 @@ fn test_doc() { style: ast::AttrStyle::Outer, value: P(respan( DUMMY_SP, - ast::MetaNameValue( + ast::MetaItemKind::NameValue( builder.interned_string("doc"), (*builder.lit().str("/// doc string")).clone(), ), diff --git a/tests/test_expr.rs b/tests/test_expr.rs index da09ff908..9edf4d858 100644 --- a/tests/test_expr.rs +++ b/tests/test_expr.rs @@ -13,7 +13,7 @@ fn test_lit() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprLit(lit), + node: ast::ExprKind::Lit(lit), span: DUMMY_SP, attrs: None, }) @@ -53,7 +53,7 @@ fn test_path() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprPath( + node: ast::ExprKind::Path( None, builder.path().id("x").build(), ), @@ -75,7 +75,7 @@ fn test_qpath() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprPath( + node: ast::ExprKind::Path( Some(ast::QSelf { ty: builder.ty().slice().infer(), position: 0, @@ -96,7 +96,7 @@ fn test_qpath() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprPath( + node: ast::ExprKind::Path( Some(ast::QSelf { ty: builder.ty().slice().infer(), position: 1, @@ -121,10 +121,10 @@ fn test_bin() { builder.expr().add().i8(1).i8(2), P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprBinary( + node: ast::ExprKind::Binary( Spanned { span: DUMMY_SP, - node: ast::BiAdd, + node: ast::BinOpKind::Add, }, builder.expr().i8(1), builder.expr().i8(2), @@ -143,7 +143,7 @@ fn test_unit() { builder.expr().unit(), P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprTup(vec![]), + node: ast::ExprKind::Tup(vec![]), span: DUMMY_SP, attrs: None, }) @@ -153,7 +153,7 @@ fn test_unit() { builder.expr().tuple().build(), P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprTup(vec![]), + node: ast::ExprKind::Tup(vec![]), span: DUMMY_SP, attrs: None, }) @@ -176,11 +176,11 @@ fn test_tuple() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprTup(vec![ + node: ast::ExprKind::Tup(vec![ builder.expr().i8(1), P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprTup(vec![ + node: ast::ExprKind::Tup(vec![ builder.expr().unit(), builder.expr().isize(2), ]), @@ -208,7 +208,7 @@ fn test_slice() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprVec(vec![ + node: ast::ExprKind::Vec(vec![ builder.expr().i8(1), builder.expr().i8(2), builder.expr().i8(3), @@ -250,7 +250,7 @@ fn test_break() { assert_eq!( expr, - builder.expr().build_expr_(ast::ExprBreak(None)) + builder.expr().build_expr_kind(ast::ExprKind::Break(None)) ); let expr = builder.expr().break_to("'a"); @@ -258,7 +258,7 @@ fn test_break() { assert_eq!( expr, - builder.expr().build_expr_(ast::ExprBreak(Some(id))) + builder.expr().build_expr_kind(ast::ExprKind::Break(Some(id))) ); } @@ -270,7 +270,7 @@ fn test_continue() { assert_eq!( expr, - builder.expr().build_expr_(ast::ExprAgain(None)) + builder.expr().build_expr_kind(ast::ExprKind::Again(None)) ); let expr = builder.expr().continue_to("'a"); @@ -278,7 +278,7 @@ fn test_continue() { assert_eq!( expr, - builder.expr().build_expr_(ast::ExprAgain(Some(id))) + builder.expr().build_expr_kind(ast::ExprKind::Again(Some(id))) ); } @@ -290,14 +290,14 @@ fn test_return() { assert_eq!( expr, - builder.expr().build_expr_(ast::ExprRet(None)) + builder.expr().build_expr_kind(ast::ExprKind::Ret(None)) ); let expr = builder.expr().return_expr().unit(); assert_eq!( expr, - builder.expr().build_expr_(ast::ExprRet(Some(builder.expr().unit()))) + builder.expr().build_expr_kind(ast::ExprKind::Ret(Some(builder.expr().unit()))) ); } @@ -311,8 +311,8 @@ fn test_loop() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprLoop( + builder.expr().build_expr_kind( + ast::ExprKind::Loop( builder.block().build(), None, ) @@ -326,8 +326,8 @@ fn test_loop() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprLoop( + builder.expr().build_expr_kind( + ast::ExprKind::Loop( builder.block().build(), Some(builder.id("'a")), ) @@ -346,8 +346,8 @@ fn test_if() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprIf( + builder.expr().build_expr_kind( + ast::ExprKind::If( builder.expr().true_(), builder.block().expr().u32(1), None, @@ -362,8 +362,8 @@ fn test_if() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprIf( + builder.expr().build_expr_kind( + ast::ExprKind::If( builder.expr().true_(), builder.block().expr().u32(1), Some(builder.expr().block().expr().u32(2)) @@ -389,15 +389,15 @@ fn test_if() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprIf( + builder.expr().build_expr_kind( + ast::ExprKind::If( builder.expr() .eq().id("x").u32(1), builder.block() .expr().u32(1), Some( - builder.expr().build_expr_( - ast::ExprIf( + builder.expr().build_expr_kind( + ast::ExprKind::If( builder.expr() .eq().id("x").u32(2), builder.block() @@ -437,8 +437,8 @@ fn test_match() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprMatch( + builder.expr().build_expr_kind( + ast::ExprKind::Match( builder.expr().u32(0), vec![ builder.arm() @@ -466,15 +466,15 @@ fn test_index() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprIndex( + builder.expr().build_expr_kind( + ast::ExprKind::Index( builder.expr().id("x"), builder.expr().usize(2) ) ) ); } - + #[test] fn test_repeat() { let builder = AstBuilder::new(); @@ -485,8 +485,8 @@ fn test_repeat() { assert_eq!( expr, - builder.expr().build_expr_( - ast::ExprRepeat( + builder.expr().build_expr_kind( + ast::ExprKind::Repeat( builder.expr().u16(1024), builder.expr().usize(16) ) diff --git a/tests/test_fn_decl.rs b/tests/test_fn_decl.rs index 087372bb7..a5ac08882 100644 --- a/tests/test_fn_decl.rs +++ b/tests/test_fn_decl.rs @@ -13,7 +13,7 @@ fn test_no_args_return_isize() { fn_decl, P(ast::FnDecl { inputs: vec![], - output: ast::Return(builder.ty().isize()), + output: ast::FunctionRetTy::Ty(builder.ty().isize()), variadic: false, }) ); @@ -42,7 +42,7 @@ fn test_args_return_isize() { id: ast::DUMMY_NODE_ID, }, ], - output: ast::Return(builder.ty().isize()), + output: ast::FunctionRetTy::Ty(builder.ty().isize()), variadic: false, }) ); @@ -57,7 +57,7 @@ fn test_no_return() { fn_decl, P(ast::FnDecl { inputs: vec![], - output: ast::NoReturn(DUMMY_SP), + output: ast::FunctionRetTy::None(DUMMY_SP), variadic: false, }) ); @@ -72,7 +72,7 @@ fn test_default_return() { fn_decl, P(ast::FnDecl { inputs: vec![], - output: ast::DefaultReturn(DUMMY_SP), + output: ast::FunctionRetTy::Default(DUMMY_SP), variadic: false, }) ); diff --git a/tests/test_item.rs b/tests/test_item.rs index 4c1dd87d8..031414b10 100644 --- a/tests/test_item.rs +++ b/tests/test_item.rs @@ -28,7 +28,7 @@ fn test_fn() { ident: builder.id("foo"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemFn( + node: ast::ItemKind::Fn( builder.fn_decl().return_().isize(), ast::Unsafety::Normal, ast::Constness::NotConst, @@ -36,7 +36,7 @@ fn test_fn() { builder.generics().build(), block ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -66,7 +66,7 @@ fn test_generic_fn() { ident: builder.id("foo"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemFn( + node: ast::ItemKind::Fn( builder.fn_decl().return_().isize(), ast::Unsafety::Normal, ast::Constness::NotConst, @@ -78,7 +78,7 @@ fn test_generic_fn() { .build(), block ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -95,11 +95,11 @@ fn test_empty_struct() { ident: builder.id("Struct"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemStruct( + node: ast::ItemKind::Struct( builder.variant_data().struct_().build(), builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -119,14 +119,14 @@ fn test_struct() { ident: builder.id("Struct"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemStruct( + node: ast::ItemKind::Struct( builder.variant_data().struct_() .field("x").ty().isize() .field("y").ty().isize() .build(), builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -167,14 +167,14 @@ fn test_tuple_struct() { ident: builder.id("Struct"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemStruct( + node: ast::ItemKind::Struct( builder.variant_data().tuple() .ty().isize() .ty().isize() .build(), builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -191,13 +191,13 @@ fn test_empty_enum() { ident: builder.id("Enum"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemEnum( + node: ast::ItemKind::Enum( ast::EnumDef { variants: vec![], }, builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -232,7 +232,7 @@ fn test_enum() { ident: builder.id("Enum"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemEnum( + node: ast::ItemKind::Enum( ast::EnumDef { variants: vec![ builder.variant("A").unit(), @@ -256,7 +256,7 @@ fn test_enum() { }, builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -271,10 +271,10 @@ fn test_use() { ident: token::special_idents::invalid, attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemUse( + node: ast::ItemKind::Use( P(respan(DUMMY_SP, view_path)) ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -343,16 +343,16 @@ fn test_use() { ast::ViewPathList( builder.path().ids(&["std", "vec"]).build(), vec![ - respan(DUMMY_SP, ast::PathListMod { + respan(DUMMY_SP, ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: None }), - respan(DUMMY_SP, ast::PathListIdent { + respan(DUMMY_SP, ast::PathListItemKind::Ident { name: "Vec".to_ident(), id: ast::DUMMY_NODE_ID, rename: None }), - respan(DUMMY_SP, ast::PathListIdent { + respan(DUMMY_SP, ast::PathListItemKind::Ident { name: "IntoIter".to_ident(), id: ast::DUMMY_NODE_ID, rename: None @@ -384,7 +384,7 @@ fn test_attr() { style: ast::AttrStyle::Outer, value: P(respan( DUMMY_SP, - ast::MetaNameValue( + ast::MetaItemKind::NameValue( builder.interned_string("doc"), (*builder.lit().str("/// doc string")).clone(), ), @@ -394,14 +394,14 @@ fn test_attr() { ), ], id: ast::DUMMY_NODE_ID, - node: ast::ItemStruct( + node: ast::ItemKind::Struct( builder.variant_data().struct_() .field("x").ty().isize() .field("y").ty().isize() .build(), builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -420,8 +420,8 @@ fn test_extern_crate() { ident: builder.id("aster"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemExternCrate(None), - vis: ast::Inherited, + node: ast::ItemKind::ExternCrate(None), + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -436,8 +436,8 @@ fn test_extern_crate() { ident: builder.id("aster"), attrs: vec![], id: ast::DUMMY_NODE_ID, - node: ast::ItemExternCrate(Some("aster1".to_name())), - vis: ast::Inherited, + node: ast::ItemKind::ExternCrate(Some("aster1".to_name())), + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -487,11 +487,11 @@ fn test_type() { ident: builder.id("MyT"), id: ast::DUMMY_NODE_ID, attrs: vec![], - node: ast::ItemTy( + node: ast::ItemKind::Ty( builder.ty().isize(), builder.generics().build(), ), - vis: ast::Inherited, + vis: ast::Visibility::Inherited, span: DUMMY_SP, }) ); @@ -522,7 +522,7 @@ fn test_trait() { ident: builder.id("Serialize"), id: ast::DUMMY_NODE_ID, attrs: vec![], - node: ast::ItemTrait( + node: ast::ItemKind::Trait( ast::Unsafety::Normal, builder.generics().build(), P::from_vec(vec![ @@ -532,7 +532,7 @@ fn test_trait() { id: ast::DUMMY_NODE_ID, ident: builder.id("MyFloat"), attrs: vec![], - node: ast::TraitItem_::TypeTraitItem( + node: ast::TraitItemKind::Type( P::from_vec(vec![]), None, ), @@ -543,7 +543,7 @@ fn test_trait() { id: ast::DUMMY_NODE_ID, ident: builder.id("PI"), attrs: vec![], - node: ast::TraitItem_::ConstTraitItem( + node: ast::TraitItemKind::Const( builder.ty().f64(), None, ), @@ -554,14 +554,14 @@ fn test_trait() { id: ast::DUMMY_NODE_ID, ident: builder.id("serialize"), attrs: vec![], - node: ast::TraitItem_::MethodTraitItem( + node: ast::TraitItemKind::Method( ast::MethodSig { unsafety: ast::Unsafety::Normal, constness: ast::Constness::NotConst, abi: Abi::Rust, decl: builder.fn_decl().default_return(), generics: builder.generics().build(), - explicit_self: respan(DUMMY_SP, ast::ExplicitSelf_::SelfStatic), + explicit_self: respan(DUMMY_SP, ast::SelfKind::Static), }, None ), @@ -605,7 +605,7 @@ fn test_impl() { ident: builder.id(""), id: ast::DUMMY_NODE_ID, attrs: vec![], - node: ast::ItemImpl( + node: ast::ItemKind::Impl( ast::Unsafety::Normal, ast::ImplPolarity::Positive, builder.generics().build(), @@ -648,7 +648,7 @@ fn test_impl() { abi: Abi::Rust, decl: builder.fn_decl().default_return(), generics: builder.generics().build(), - explicit_self: respan(DUMMY_SP, ast::ExplicitSelf_::SelfStatic), + explicit_self: respan(DUMMY_SP, ast::SelfKind::Static), }, builder.block().build() ), @@ -675,7 +675,7 @@ fn test_const() { ident: builder.id("PI"), id: ast::DUMMY_NODE_ID, attrs: vec![], - node: ast::ItemConst( + node: ast::ItemKind::Const( builder.ty().f64(), builder.expr().f64("3.14159265358979323846264338327950288") ), diff --git a/tests/test_lit.rs b/tests/test_lit.rs index 0705be7cb..3bcc72dcc 100644 --- a/tests/test_lit.rs +++ b/tests/test_lit.rs @@ -15,31 +15,18 @@ fn test_int() { lit, P(Spanned { span: DUMMY_SP, - node: ast::LitInt(value, lit_int_ty), + node: ast::LitKind::Int(value, lit_int_ty), }) ); } - - check(builder.lit().i8(1), 1, ast::SignedIntLit(ast::TyI8, ast::Plus)); - check(builder.lit().i16(1), 1, ast::SignedIntLit(ast::TyI16, ast::Plus)); - check(builder.lit().i32(1), 1, ast::SignedIntLit(ast::TyI32, ast::Plus)); - check(builder.lit().i64(1), 1, ast::SignedIntLit(ast::TyI64, ast::Plus)); - check(builder.lit().isize(1), 1, ast::SignedIntLit(ast::TyIs, ast::Plus)); - - check(builder.lit().i8(-1), !0, ast::SignedIntLit(ast::TyI8, ast::Minus)); - check(builder.lit().i16(-1), !0, ast::SignedIntLit(ast::TyI16, ast::Minus)); - check(builder.lit().i32(-1), !0, ast::SignedIntLit(ast::TyI32, ast::Minus)); - check(builder.lit().i64(-1), !0, ast::SignedIntLit(ast::TyI64, ast::Minus)); - check(builder.lit().isize(-1), !0, ast::SignedIntLit(ast::TyIs, ast::Minus)); - - check(builder.lit().u8(1), 1, ast::UnsignedIntLit(ast::TyU8)); - check(builder.lit().u16(1), 1, ast::UnsignedIntLit(ast::TyU16)); - check(builder.lit().u32(1), 1, ast::UnsignedIntLit(ast::TyU32)); - check(builder.lit().u64(1), 1, ast::UnsignedIntLit(ast::TyU64)); - check(builder.lit().usize(1), 1, ast::UnsignedIntLit(ast::TyUs)); - - check(builder.lit().int(1), 1, ast::UnsuffixedIntLit(ast::Plus)); - check(builder.lit().int(-1), !0, ast::UnsuffixedIntLit(ast::Minus)); + check(builder.lit().u8(1), 1, ast::LitIntType::Unsigned(ast::UintTy::U8)); + check(builder.lit().u16(1), 1, ast::LitIntType::Unsigned(ast::UintTy::U16)); + check(builder.lit().u32(1), 1, ast::LitIntType::Unsigned(ast::UintTy::U32)); + check(builder.lit().u64(1), 1, ast::LitIntType::Unsigned(ast::UintTy::U64)); + check(builder.lit().usize(1), 1, ast::LitIntType::Unsigned(ast::UintTy::Us)); + check(builder.lit().uint(1), 1, ast::LitIntType::Unsuffixed); + + check(builder.lit().int(1), 1, ast::LitIntType::Unsuffixed); } #[test] @@ -49,28 +36,28 @@ fn test_bool() { assert_eq!(builder.lit().bool(true), P(Spanned { span: DUMMY_SP, - node: ast::LitBool(true) + node: ast::LitKind::Bool(true) }) ); assert_eq!(builder.lit().bool(false), P(Spanned { span: DUMMY_SP, - node: ast::LitBool(false) + node: ast::LitKind::Bool(false) }) ); assert_eq!(builder.lit().true_(), P(Spanned { span: DUMMY_SP, - node: ast::LitBool(true) + node: ast::LitKind::Bool(true) }) ); assert_eq!(builder.lit().false_(), P(Spanned { span: DUMMY_SP, - node: ast::LitBool(false) + node: ast::LitKind::Bool(false) }) ); } @@ -82,7 +69,7 @@ fn test_char() { assert_eq!(builder.lit().char('a'), P(Spanned { span: DUMMY_SP, - node: ast::LitChar('a') + node: ast::LitKind::Char('a') }) ); } @@ -94,7 +81,7 @@ fn test_byte() { assert_eq!(builder.lit().byte(b'a'), P(Spanned { span: DUMMY_SP, - node: ast::LitByte(b'a') + node: ast::LitKind::Byte(b'a') }) ); } @@ -106,9 +93,9 @@ fn test_str() { assert_eq!(builder.lit().str("string"), P(Spanned { span: DUMMY_SP, - node: ast::LitStr( + node: ast::LitKind::Str( builder.interned_string("string"), - ast::CookedStr, + ast::StrStyle::Cooked, ), }) ); @@ -121,7 +108,7 @@ fn test_byte_str() { assert_eq!(builder.lit().byte_str(&b"string"[..]), P(Spanned { span: DUMMY_SP, - node: ast::LitByteStr(Rc::new(Vec::from(&b"string"[..]))), + node: ast::LitKind::ByteStr(Rc::new(Vec::from(&b"string"[..]))), }) ); } diff --git a/tests/test_stmt.rs b/tests/test_stmt.rs index 4a582afd0..8086d33f4 100644 --- a/tests/test_stmt.rs +++ b/tests/test_stmt.rs @@ -13,10 +13,10 @@ fn test_let() { .let_().id("x").build(), P(respan( DUMMY_SP, - ast::StmtDecl( + ast::StmtKind::Decl( P(respan( DUMMY_SP, - ast::DeclLocal(P(ast::Local { + ast::DeclKind::Local(P(ast::Local { pat: builder.pat().id("x"), ty: None, init: None, @@ -35,10 +35,10 @@ fn test_let() { .let_().id("x").ty().i8().build(), P(respan( DUMMY_SP, - ast::StmtDecl( + ast::StmtKind::Decl( P(respan( DUMMY_SP, - ast::DeclLocal(P(ast::Local { + ast::DeclKind::Local(P(ast::Local { pat: builder.pat().id("x"), ty: Some(builder.ty().i8()), init: None, @@ -57,10 +57,10 @@ fn test_let() { .let_().id("x").expr().i8(5), P(respan( DUMMY_SP, - ast::StmtDecl( + ast::StmtKind::Decl( P(respan( DUMMY_SP, - ast::DeclLocal(P(ast::Local { + ast::DeclKind::Local(P(ast::Local { pat: builder.pat().id("x"), ty: None, init: Some(builder.expr().i8(5)), @@ -79,10 +79,10 @@ fn test_let() { .let_().id("x").ty().i8().expr().i8(5), P(respan( DUMMY_SP, - ast::StmtDecl( + ast::StmtKind::Decl( P(respan( DUMMY_SP, - ast::DeclLocal(P(ast::Local { + ast::DeclKind::Local(P(ast::Local { pat: builder.pat().id("x"), ty: Some(builder.ty().i8()), init: Some(builder.expr().i8(5)), @@ -108,10 +108,10 @@ fn test_let() { .build(), P(respan( DUMMY_SP, - ast::StmtDecl( + ast::StmtKind::Decl( P(respan( DUMMY_SP, - ast::DeclLocal(P(ast::Local { + ast::DeclKind::Local(P(ast::Local { pat: builder.pat().tuple() .pat().id("x") .pat().id("y") diff --git a/tests/test_struct_field.rs b/tests/test_struct_field.rs index 944137b0e..223b97424 100644 --- a/tests/test_struct_field.rs +++ b/tests/test_struct_field.rs @@ -15,7 +15,7 @@ fn test_named() { ast::StructField_ { kind: ast::NamedField( builder.id("x"), - ast::Inherited, + ast::Visibility::Inherited, ), id: ast::DUMMY_NODE_ID, ty: builder.ty().isize(), @@ -34,7 +34,7 @@ fn test_unnamed() { respan( DUMMY_SP, ast::StructField_ { - kind: ast::UnnamedField(ast::Inherited), + kind: ast::UnnamedField(ast::Visibility::Inherited), id: ast::DUMMY_NODE_ID, ty: builder.ty().isize(), attrs: vec![], @@ -57,7 +57,7 @@ fn test_attrs() { ast::StructField_ { kind: ast::NamedField( builder.id("x"), - ast::Inherited, + ast::Visibility::Inherited, ), id: ast::DUMMY_NODE_ID, ty: builder.ty().isize(), @@ -69,7 +69,7 @@ fn test_attrs() { style: ast::AttrStyle::Outer, value: P(respan( DUMMY_SP, - ast::MetaNameValue( + ast::MetaItemKind::NameValue( builder.interned_string("doc"), (*builder.lit().str("/// doc string")).clone(), ), @@ -84,7 +84,7 @@ fn test_attrs() { style: ast::AttrStyle::Outer, value: P(respan( DUMMY_SP, - ast::MetaWord(builder.interned_string("automatically_derived")), + ast::MetaItemKind::Word(builder.interned_string("automatically_derived")), )), is_sugared_doc: false, } @@ -94,4 +94,3 @@ fn test_attrs() { ) ); } - diff --git a/tests/test_ty.rs b/tests/test_ty.rs index 8c3c26d87..f1632c7d4 100644 --- a/tests/test_ty.rs +++ b/tests/test_ty.rs @@ -13,7 +13,7 @@ fn test_path() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyPath(None, builder.path().id("isize").build()), + node: ast::TyKind::Path(None, builder.path().id("isize").build()), span: DUMMY_SP, }) ); @@ -31,7 +31,7 @@ fn test_qpath() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprPath( + node: ast::ExprKind::Path( Some(ast::QSelf { ty: builder.ty().slice().infer(), position: 0, @@ -52,7 +52,7 @@ fn test_qpath() { expr, P(ast::Expr { id: ast::DUMMY_NODE_ID, - node: ast::ExprPath( + node: ast::ExprKind::Path( Some(ast::QSelf { ty: builder.ty().slice().infer(), position: 1, @@ -77,7 +77,7 @@ fn test_option() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyPath( + node: ast::TyKind::Path( None, builder.path().global() .id("std") @@ -101,7 +101,7 @@ fn test_result() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyPath( + node: ast::TyKind::Path( None, builder.path().global() .id("std") @@ -126,7 +126,7 @@ fn test_unit() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyTup(vec![]), + node: ast::TyKind::Tup(vec![]), span: DUMMY_SP, }) ); @@ -137,7 +137,7 @@ fn test_unit() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyTup(vec![]), + node: ast::TyKind::Tup(vec![]), span: DUMMY_SP, }) ); @@ -159,11 +159,11 @@ fn test_tuple() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyTup(vec![ + node: ast::TyKind::Tup(vec![ builder.ty().isize(), P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyTup(vec![ + node: ast::TyKind::Tup(vec![ builder.ty().unit(), builder.ty().isize(), ]), @@ -185,7 +185,7 @@ fn test_slice() { ty, P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyVec(builder.ty().isize()), + node: ast::TyKind::Vec(builder.ty().isize()), span: DUMMY_SP, }) );