diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 92fcf865042..bf790e6143a 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -1842,7 +1842,8 @@ mod tests { tok: token::Ident(id, false), sp: Span::new(BytePos(21), BytePos(23), NO_EXPANSION), }; - assert_eq!(tok1, tok2); + assert_eq!(tok1.tok, tok2.tok); + assert_eq!(tok1.sp, tok2.sp); assert_eq!(string_reader.next_token().tok, token::Whitespace); // the 'main' id is already read: assert_eq!(string_reader.pos.clone(), BytePos(28)); @@ -1852,7 +1853,8 @@ mod tests { tok: mk_ident("main"), sp: Span::new(BytePos(24), BytePos(28), NO_EXPANSION), }; - assert_eq!(tok3, tok4); + assert_eq!(tok3.tok, tok4.tok); + assert_eq!(tok3.sp, tok4.sp); // the lparen is already read: assert_eq!(string_reader.pos.clone(), BytePos(29)) }) diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c443f240780..1754e5f1b9a 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -673,22 +673,40 @@ fn integer_lit(s: &str, suffix: Option, diag: Option<(Span, &Handler)>) }) } +/// `SeqSep` : a sequence separator (token) +/// and whether a trailing separator is allowed. +pub struct SeqSep { + pub sep: Option, + pub trailing_sep_allowed: bool, +} + +impl SeqSep { + pub fn trailing_allowed(t: token::Token) -> SeqSep { + SeqSep { + sep: Some(t), + trailing_sep_allowed: true, + } + } + + pub fn none() -> SeqSep { + SeqSep { + sep: None, + trailing_sep_allowed: false, + } + } +} + #[cfg(test)] mod tests { use super::*; - use syntax_pos::{self, Span, BytePos, Pos, NO_EXPANSION}; - use codemap::{respan, Spanned}; + use syntax_pos::{Span, BytePos, Pos, NO_EXPANSION}; use ast::{self, Ident, PatKind}; - use rustc_target::spec::abi::Abi; use attr::first_attr_value_str_by_name; use parse; - use parse::parser::Parser; use print::pprust::item_to_string; - use ptr::P; use tokenstream::{self, TokenTree}; - use util::parser_testing::{string_to_stream, string_to_parser}; - use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt}; - use util::ThinVec; + use util::parser_testing::string_to_stream; + use util::parser_testing::{string_to_expr, string_to_item}; use with_globals; // produce a syntax_pos::span @@ -696,42 +714,6 @@ mod tests { Span::new(BytePos(a), BytePos(b), NO_EXPANSION) } - fn str2seg(s: &str, lo: u32, hi: u32) -> ast::PathSegment { - ast::PathSegment::from_ident(Ident::new(Symbol::intern(s), sp(lo, hi))) - } - - #[test] fn path_exprs_1() { - with_globals(|| { - assert!(string_to_expr("a".to_string()) == - P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span: sp(0, 1), - segments: vec![str2seg("a", 0, 1)], - }), - span: sp(0, 1), - attrs: ThinVec::new(), - })) - }) - } - - #[test] fn path_exprs_2 () { - with_globals(|| { - assert!(string_to_expr("::a::b".to_string()) == - P(ast::Expr { - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span: sp(0, 6), - segments: vec![ast::PathSegment::crate_root(sp(0, 0)), - str2seg("a", 2, 3), - str2seg("b", 5, 6)] - }), - span: sp(0, 6), - attrs: ThinVec::new(), - })) - }) - } - #[should_panic] #[test] fn bad_path_expr_1() { with_globals(|| { @@ -832,143 +814,6 @@ mod tests { }) } - #[test] fn ret_expr() { - with_globals(|| { - assert!(string_to_expr("return d".to_string()) == - P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node:ast::ExprKind::Ret(Some(P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node:ast::ExprKind::Path(None, ast::Path{ - span: sp(7, 8), - segments: vec![str2seg("d", 7, 8)], - }), - span:sp(7,8), - attrs: ThinVec::new(), - }))), - span:sp(0,8), - attrs: ThinVec::new(), - })) - }) - } - - #[test] fn parse_stmt_1 () { - with_globals(|| { - assert!(string_to_stmt("b;".to_string()) == - Some(ast::Stmt { - node: ast::StmtKind::Expr(P(ast::Expr { - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span:sp(0,1), - segments: vec![str2seg("b", 0, 1)], - }), - span: sp(0,1), - attrs: ThinVec::new()})), - id: ast::DUMMY_NODE_ID, - span: sp(0,1)})) - }) - } - - fn parser_done(p: Parser){ - assert_eq!(p.token.clone(), token::Eof); - } - - #[test] fn parse_ident_pat () { - with_globals(|| { - let sess = ParseSess::new(FilePathMapping::empty()); - let mut parser = string_to_parser(&sess, "b".to_string()); - assert!(panictry!(parser.parse_pat()) - == P(ast::Pat{ - id: ast::DUMMY_NODE_ID, - node: PatKind::Ident(ast::BindingMode::ByValue(ast::Mutability::Immutable), - Ident::new(Symbol::intern("b"), sp(0, 1)), - None), - span: sp(0,1)})); - parser_done(parser); - }) - } - - // check the contents of the tt manually: - #[test] fn parse_fundecl () { - with_globals(|| { - // this test depends on the intern order of "fn" and "i32" - let item = string_to_item("fn a (b : i32) { b; }".to_string()).map(|m| { - m.map(|mut m| { - m.tokens = None; - m - }) - }); - assert_eq!(item, - Some( - P(ast::Item{ident:Ident::from_str("a"), - attrs:Vec::new(), - id: ast::DUMMY_NODE_ID, - tokens: None, - node: ast::ItemKind::Fn(P(ast::FnDecl { - inputs: vec![ast::Arg{ - ty: P(ast::Ty{id: ast::DUMMY_NODE_ID, - node: ast::TyKind::Path(None, ast::Path{ - span:sp(10,13), - segments: vec![str2seg("i32", 10, 13)], - }), - span:sp(10,13) - }), - pat: P(ast::Pat { - id: ast::DUMMY_NODE_ID, - node: PatKind::Ident( - ast::BindingMode::ByValue( - ast::Mutability::Immutable), - Ident::new(Symbol::intern("b"), sp(6, 7)), - None - ), - span: sp(6,7) - }), - id: ast::DUMMY_NODE_ID - }], - output: ast::FunctionRetTy::Default(sp(15, 15)), - variadic: false - }), - ast::FnHeader { - unsafety: ast::Unsafety::Normal, - asyncness: ast::IsAsync::NotAsync, - constness: Spanned { - span: sp(0,2), - node: ast::Constness::NotConst, - }, - abi: Abi::Rust, - }, - ast::Generics{ - params: Vec::new(), - where_clause: ast::WhereClause { - id: ast::DUMMY_NODE_ID, - predicates: Vec::new(), - span: syntax_pos::DUMMY_SP, - }, - span: syntax_pos::DUMMY_SP, - }, - P(ast::Block { - stmts: vec![ast::Stmt { - node: ast::StmtKind::Semi(P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, - ast::Path{ - span:sp(17,18), - segments: vec![str2seg("b", 17, 18)], - }), - span: sp(17,18), - attrs: ThinVec::new()})), - id: ast::DUMMY_NODE_ID, - span: sp(17,19)}], - id: ast::DUMMY_NODE_ID, - rules: ast::BlockCheckMode::Default, // no idea - span: sp(15,21), - recovered: false, - })), - vis: respan(sp(0, 0), ast::VisibilityKind::Inherited), - span: sp(0,21)}))); - }) - } - #[test] fn parse_use() { with_globals(|| { let use_s = "use foo::bar::baz;"; @@ -1133,26 +978,3 @@ mod tests { }); } } - -/// `SeqSep` : a sequence separator (token) -/// and whether a trailing separator is allowed. -pub struct SeqSep { - pub sep: Option, - pub trailing_sep_allowed: bool, -} - -impl SeqSep { - pub fn trailing_allowed(t: token::Token) -> SeqSep { - SeqSep { - sep: Some(t), - trailing_sep_allowed: true, - } - } - - pub fn none() -> SeqSep { - SeqSep { - sep: None, - trailing_sep_allowed: false, - } - } -} diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 42cd7c8faa5..46b7f2d7bda 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -63,14 +63,6 @@ pub fn string_to_item (source_str : String) -> Option> { }) } -/// Parse a string, return a stmt -pub fn string_to_stmt(source_str : String) -> Option { - let ps = ParseSess::new(FilePathMapping::empty()); - with_error_checking_parse(source_str, &ps, |p| { - p.parse_stmt() - }) -} - /// Parse a string, return a pat. Uses "irrefutable"... which doesn't /// (currently) affect parsing. pub fn string_to_pat(source_str: String) -> P { diff --git a/src/libsyntax_ext/format_foreign.rs b/src/libsyntax_ext/format_foreign.rs index 1cf21b5c3ae..ff9663cdd3c 100644 --- a/src/libsyntax_ext/format_foreign.rs +++ b/src/libsyntax_ext/format_foreign.rs @@ -12,7 +12,7 @@ pub mod printf { use super::strcursor::StrCursor as Cur; /// Represents a single `printf`-style substitution. - #[derive(Clone, Debug)] + #[derive(Clone, PartialEq, Debug)] pub enum Substitution<'a> { /// A formatted output substitution. Format(Format<'a>), @@ -40,7 +40,7 @@ pub mod printf { } } - #[derive(Clone, Debug)] + #[derive(Clone, PartialEq, Debug)] /// A single `printf`-style formatting directive. pub struct Format<'a> { /// The entire original formatting directive. @@ -213,7 +213,7 @@ pub mod printf { } /// A general number used in a `printf` formatting directive. - #[derive(Copy, Clone, Debug)] + #[derive(Copy, Clone, PartialEq, Debug)] pub enum Num { // The range of these values is technically bounded by `NL_ARGMAX`... but, at least for GNU // libc, it apparently has no real fixed limit. A `u16` is used here on the basis that it @@ -739,7 +739,7 @@ pub mod printf { pub mod shell { use super::strcursor::StrCursor as Cur; - #[derive(Clone, Debug)] + #[derive(Clone, PartialEq, Debug)] pub enum Substitution<'a> { Ordinal(u8), Name(&'a str), diff --git a/src/test/run-pass-fulldeps/issue-35829.rs b/src/test/run-pass-fulldeps/issue-35829.rs deleted file mode 100644 index 798c214bc47..00000000000 --- a/src/test/run-pass-fulldeps/issue-35829.rs +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright 2017 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// ignore-stage1 -// ignore-cross-compile -#![feature(quote, rustc_private)] - -extern crate syntax; -extern crate rustc_data_structures; - -use syntax::ext::base::{ExtCtxt, DummyResolver}; -use syntax::ext::expand::ExpansionConfig; -use syntax::parse::ParseSess; -use syntax::codemap::{FilePathMapping, dummy_spanned}; -use syntax::print::pprust::expr_to_string; -use syntax::ast::{ExprKind, LitKind, RangeLimits}; -use syntax::ptr::P; - -use rustc_data_structures::sync::Lrc; - -fn main() { - syntax::with_globals(|| run()); -} - -fn run() { - let parse_sess = ParseSess::new(FilePathMapping::empty()); - let exp_cfg = ExpansionConfig::default("issue_35829".to_owned()); - let mut resolver = DummyResolver; - let cx = ExtCtxt::new(&parse_sess, exp_cfg, &mut resolver); - - // check byte string - let byte_string = quote_expr!(&cx, b"one"); - let byte_string_lit_kind = LitKind::ByteStr(Lrc::new(b"one".to_vec())); - assert_eq!(byte_string.node, ExprKind::Lit(P(dummy_spanned(byte_string_lit_kind)))); - - // check raw byte string - let raw_byte_string = quote_expr!(&cx, br###"#"two"#"###); - let raw_byte_string_lit_kind = LitKind::ByteStr(Lrc::new(b"#\"two\"#".to_vec())); - assert_eq!(raw_byte_string.node, ExprKind::Lit(P(dummy_spanned(raw_byte_string_lit_kind)))); - - // check dotdoteq - let closed_range = quote_expr!(&cx, 0 ..= 1); - assert_eq!(closed_range.node, ExprKind::Range( - Some(quote_expr!(&cx, 0)), - Some(quote_expr!(&cx, 1)), - RangeLimits::Closed - )); - - // test case from 35829 - let expr_35829 = quote_expr!(&cx, std::io::stdout().write(b"one")); - assert_eq!(expr_to_string(&expr_35829), r#"std::io::stdout().write(b"one")"#); -}