Skip to content

Commit 9956e81

Browse files
borsbors
committed
Auto merge of #41729 - ubsan:master, r=nrc
Delete features which are easily removed, in libsyntax
2 parents d985625 + 0be8758 commit 9956e81

File tree

6 files changed

+30
-31
lines changed

6 files changed

+30
-31
lines changed

‎src/Cargo.lock‎

Lines changed: 1 addition & 1 deletion
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎src/libsyntax/Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ crate-type = ["dylib"]
1111
[dependencies]
1212
serialize = { path = "../libserialize" }
1313
log = "0.3"
14-
rustc_bitflags = { path = "../librustc_bitflags" }
14+
bitflags = "0.8"
1515
syntax_pos = { path = "../libsyntax_pos" }
1616
rustc_errors = { path = "../librustc_errors" }
1717
rustc_data_structures = { path = "../librustc_data_structures" }

‎src/libsyntax/lib.rs‎

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -24,20 +24,15 @@
2424
test(attr(deny(warnings))))]
2525
#![deny(warnings)]
2626

27-
#![feature(associated_consts)]
28-
#![feature(const_fn)]
29-
#![feature(optin_builtin_traits)]
3027
#![feature(rustc_private)]
3128
#![feature(staged_api)]
32-
#![feature(str_escape)]
3329
#![feature(unicode)]
3430
#![feature(rustc_diagnostic_macros)]
35-
#![feature(specialization)]
3631
#![feature(i128_type)]
3732

3833
extern crate serialize;
3934
#[macro_use] extern crate log;
40-
#[macro_use] #[no_link] extern crate rustc_bitflags;
35+
#[macro_use] extern crate bitflags;
4136
extern crate std_unicode;
4237
pub extern crate rustc_errors as errors;
4338
extern crate syntax_pos;

‎src/libsyntax/parse/mod.rs‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -261,10 +261,14 @@ pub fn char_lit(lit: &str) -> (char, isize) {
261261
}
262262
}
263263

264+
pub fn escape_default(s: &str) -> String {
265+
s.chars().map(char::escape_default).flat_map(|x| x).collect()
266+
}
267+
264268
/// Parse a string representing a string literal into its final form. Does
265269
/// unescaping.
266270
pub fn str_lit(lit: &str) -> String {
267-
debug!("parse_str_lit: given {}", lit.escape_default());
271+
debug!("parse_str_lit: given {}", escape_default(lit));
268272
let mut res = String::with_capacity(lit.len());
269273

270274
// FIXME #8372: This could be a for-loop if it didn't borrow the iterator
@@ -339,7 +343,7 @@ pub fn str_lit(lit: &str) -> String {
339343
/// Parse a string representing a raw string literal into its final form. The
340344
/// only operation this does is convert embedded CRLF into a single LF.
341345
pub fn raw_str_lit(lit: &str) -> String {
342-
debug!("raw_str_lit: given {}", lit.escape_default());
346+
debug!("raw_str_lit: given {}", escape_default(lit));
343347
let mut res = String::with_capacity(lit.len());
344348

345349
// FIXME #8372: This could be a for-loop if it didn't borrow the iterator

‎src/libsyntax/parse/parser.rs‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ use std::path::{self, Path, PathBuf};
6464
use std::slice;
6565

6666
bitflags! {
67-
flags Restrictions: u8 {
67+
pub flags Restrictions: u8 {
6868
const RESTRICTION_STMT_EXPR = 1 << 0,
6969
const RESTRICTION_NO_STRUCT_LITERAL = 1 << 1,
7070
}
@@ -2291,7 +2291,7 @@ impl<'a> Parser<'a> {
22912291
let e = if self.token.can_begin_expr()
22922292
&& !(self.token == token::OpenDelim(token::Brace)
22932293
&& self.restrictions.contains(
2294-
Restrictions::RESTRICTION_NO_STRUCT_LITERAL)) {
2294+
RESTRICTION_NO_STRUCT_LITERAL)) {
22952295
Some(self.parse_expr()?)
22962296
} else {
22972297
None
@@ -2318,7 +2318,7 @@ impl<'a> Parser<'a> {
23182318
// This is a struct literal, unless we're prohibited
23192319
// from parsing struct literals here.
23202320
let prohibited = self.restrictions.contains(
2321-
Restrictions::RESTRICTION_NO_STRUCT_LITERAL
2321+
RESTRICTION_NO_STRUCT_LITERAL
23222322
);
23232323
if !prohibited {
23242324
return self.parse_struct_expr(lo, pth, attrs);
@@ -2735,7 +2735,7 @@ impl<'a> Parser<'a> {
27352735
token::Ident(..) if self.token.is_keyword(keywords::In) => {
27362736
self.bump();
27372737
let place = self.parse_expr_res(
2738-
Restrictions::RESTRICTION_NO_STRUCT_LITERAL,
2738+
RESTRICTION_NO_STRUCT_LITERAL,
27392739
None,
27402740
)?;
27412741
let blk = self.parse_block()?;
@@ -2798,7 +2798,7 @@ impl<'a> Parser<'a> {
27982798

27992799
let cur_op_span = self.span;
28002800
let restrictions = if op.is_assign_like() {
2801-
self.restrictions & Restrictions::RESTRICTION_NO_STRUCT_LITERAL
2801+
self.restrictions & RESTRICTION_NO_STRUCT_LITERAL
28022802
} else {
28032803
self.restrictions
28042804
};
@@ -2848,21 +2848,21 @@ impl<'a> Parser<'a> {
28482848

28492849
let rhs = match op.fixity() {
28502850
Fixity::Right => self.with_res(
2851-
restrictions - Restrictions::RESTRICTION_STMT_EXPR,
2851+
restrictions - RESTRICTION_STMT_EXPR,
28522852
|this| {
28532853
this.parse_assoc_expr_with(op.precedence(),
28542854
LhsExpr::NotYetParsed)
28552855
}),
28562856
Fixity::Left => self.with_res(
2857-
restrictions - Restrictions::RESTRICTION_STMT_EXPR,
2857+
restrictions - RESTRICTION_STMT_EXPR,
28582858
|this| {
28592859
this.parse_assoc_expr_with(op.precedence() + 1,
28602860
LhsExpr::NotYetParsed)
28612861
}),
28622862
// We currently have no non-associative operators that are not handled above by
28632863
// the special cases. The code is here only for future convenience.
28642864
Fixity::None => self.with_res(
2865-
restrictions - Restrictions::RESTRICTION_STMT_EXPR,
2865+
restrictions - RESTRICTION_STMT_EXPR,
28662866
|this| {
28672867
this.parse_assoc_expr_with(op.precedence() + 1,
28682868
LhsExpr::NotYetParsed)
@@ -2972,7 +2972,7 @@ impl<'a> Parser<'a> {
29722972
if self.token.can_begin_expr() {
29732973
// parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`.
29742974
if self.token == token::OpenDelim(token::Brace) {
2975-
return !self.restrictions.contains(Restrictions::RESTRICTION_NO_STRUCT_LITERAL);
2975+
return !self.restrictions.contains(RESTRICTION_NO_STRUCT_LITERAL);
29762976
}
29772977
true
29782978
} else {
@@ -2986,7 +2986,7 @@ impl<'a> Parser<'a> {
29862986
return self.parse_if_let_expr(attrs);
29872987
}
29882988
let lo = self.prev_span;
2989-
let cond = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
2989+
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL, None)?;
29902990
let thn = self.parse_block()?;
29912991
let mut els: Option<P<Expr>> = None;
29922992
let mut hi = thn.span;
@@ -3005,7 +3005,7 @@ impl<'a> Parser<'a> {
30053005
self.expect_keyword(keywords::Let)?;
30063006
let pat = self.parse_pat()?;
30073007
self.expect(&token::Eq)?;
3008-
let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
3008+
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL, None)?;
30093009
let thn = self.parse_block()?;
30103010
let (hi, els) = if self.eat_keyword(keywords::Else) {
30113011
let expr = self.parse_else_expr()?;
@@ -3059,7 +3059,7 @@ impl<'a> Parser<'a> {
30593059

30603060
let pat = self.parse_pat()?;
30613061
self.expect_keyword(keywords::In)?;
3062-
let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
3062+
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL, None)?;
30633063
let (iattrs, loop_block) = self.parse_inner_attrs_and_block()?;
30643064
attrs.extend(iattrs);
30653065

@@ -3074,7 +3074,7 @@ impl<'a> Parser<'a> {
30743074
if self.token.is_keyword(keywords::Let) {
30753075
return self.parse_while_let_expr(opt_ident, span_lo, attrs);
30763076
}
3077-
let cond = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
3077+
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL, None)?;
30783078
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
30793079
attrs.extend(iattrs);
30803080
let span = span_lo.to(body.span);
@@ -3088,7 +3088,7 @@ impl<'a> Parser<'a> {
30883088
self.expect_keyword(keywords::Let)?;
30893089
let pat = self.parse_pat()?;
30903090
self.expect(&token::Eq)?;
3091-
let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
3091+
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL, None)?;
30923092
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
30933093
attrs.extend(iattrs);
30943094
let span = span_lo.to(body.span);
@@ -3118,7 +3118,7 @@ impl<'a> Parser<'a> {
31183118
fn parse_match_expr(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
31193119
let match_span = self.prev_span;
31203120
let lo = self.prev_span;
3121-
let discriminant = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL,
3121+
let discriminant = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL,
31223122
None)?;
31233123
if let Err(mut e) = self.expect(&token::OpenDelim(token::Brace)) {
31243124
if self.token == token::Token::Semi {
@@ -3159,7 +3159,7 @@ impl<'a> Parser<'a> {
31593159
guard = Some(self.parse_expr()?);
31603160
}
31613161
self.expect(&token::FatArrow)?;
3162-
let expr = self.parse_expr_res(Restrictions::RESTRICTION_STMT_EXPR, None)?;
3162+
let expr = self.parse_expr_res(RESTRICTION_STMT_EXPR, None)?;
31633163

31643164
let require_comma =
31653165
!classify::expr_is_simple_block(&expr)
@@ -3740,7 +3740,7 @@ impl<'a> Parser<'a> {
37403740
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace)) &&
37413741

37423742
// prevent `while catch {} {}`, `if catch {} {} else {}`, etc.
3743-
!self.restrictions.contains(Restrictions::RESTRICTION_NO_STRUCT_LITERAL)
3743+
!self.restrictions.contains(RESTRICTION_NO_STRUCT_LITERAL)
37443744
}
37453745

37463746
fn is_union_item(&self) -> bool {
@@ -3812,7 +3812,7 @@ impl<'a> Parser<'a> {
38123812
self.mk_expr(lo.to(hi), ExprKind::Path(None, pth), ThinVec::new())
38133813
};
38143814

3815-
let expr = self.with_res(Restrictions::RESTRICTION_STMT_EXPR, |this| {
3815+
let expr = self.with_res(RESTRICTION_STMT_EXPR, |this| {
38163816
let expr = this.parse_dot_or_call_expr_with(expr, lo, attrs.into())?;
38173817
this.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(expr))
38183818
})?;
@@ -3952,7 +3952,7 @@ impl<'a> Parser<'a> {
39523952

39533953
// Remainder are line-expr stmts.
39543954
let e = self.parse_expr_res(
3955-
Restrictions::RESTRICTION_STMT_EXPR, Some(attrs.into()))?;
3955+
RESTRICTION_STMT_EXPR, Some(attrs.into()))?;
39563956
Stmt {
39573957
id: ast::DUMMY_NODE_ID,
39583958
span: lo.to(e.span),
@@ -3965,7 +3965,7 @@ impl<'a> Parser<'a> {
39653965

39663966
/// Is this expression a successfully-parsed statement?
39673967
fn expr_is_complete(&mut self, e: &Expr) -> bool {
3968-
self.restrictions.contains(Restrictions::RESTRICTION_STMT_EXPR) &&
3968+
self.restrictions.contains(RESTRICTION_STMT_EXPR) &&
39693969
!classify::expr_requires_semi_to_be_stmt(e)
39703970
}
39713971

‎src/libsyntax/print/pprust.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -677,7 +677,7 @@ pub trait PrintState<'a> {
677677
style: ast::StrStyle) -> io::Result<()> {
678678
let st = match style {
679679
ast::StrStyle::Cooked => {
680-
(format!("\"{}\"", st.escape_default()))
680+
(format!("\"{}\"", parse::escape_default(st)))
681681
}
682682
ast::StrStyle::Raw(n) => {
683683
(format!("r{delim}\"{string}\"{delim}",

0 commit comments

Comments
 (0)