Skip to content

Commit f97c132

Browse files
eddybeddyb
committed
rustc: use Span's allow_internal_unstable instead of hir::BlockCheckMode.
1 parent da47c2e commit f97c132

File tree

7 files changed

+52
-125
lines changed

7 files changed

+52
-125
lines changed

‎src/librustc/hir/lowering.rs

Lines changed: 44 additions & 93 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ use std::iter;
5252
use syntax::ast::*;
5353
use syntax::errors;
5454
use syntax::ptr::P;
55-
use syntax::codemap::{respan, Spanned};
55+
use syntax::codemap::{self, respan, Spanned};
5656
use syntax::std_inject;
5757
use syntax::symbol::{Symbol, keywords};
5858
use syntax::util::small_vector::SmallVector;
@@ -171,6 +171,18 @@ impl<'a> LoweringContext<'a> {
171171
Symbol::gensym(s)
172172
}
173173

174+
fn allow_internal_unstable(&self, reason: &'static str, mut span: Span) -> Span {
175+
span.expn_id = self.sess.codemap().record_expansion(codemap::ExpnInfo {
176+
call_site: span,
177+
callee: codemap::NameAndSpan {
178+
format: codemap::CompilerDesugaring(Symbol::intern(reason)),
179+
span: Some(span),
180+
allow_internal_unstable: true,
181+
},
182+
});
183+
span
184+
}
185+
174186
fn with_parent_def<T, F>(&mut self, parent_id: NodeId, f: F) -> T
175187
where F: FnOnce(&mut LoweringContext) -> T
176188
{
@@ -1156,8 +1168,9 @@ impl<'a> LoweringContext<'a> {
11561168
let move_val_init = ["intrinsics", "move_val_init"];
11571169
let inplace_finalize = ["ops", "InPlace", "finalize"];
11581170

1171+
let unstable_span = self.allow_internal_unstable("<-", e.span);
11591172
let make_call = |this: &mut LoweringContext, p, args| {
1160-
let path = this.expr_std_path(e.span, p, ThinVec::new());
1173+
let path = P(this.expr_std_path(unstable_span, p, ThinVec::new()));
11611174
P(this.expr_call(e.span, path, args))
11621175
};
11631176

@@ -1171,11 +1184,6 @@ impl<'a> LoweringContext<'a> {
11711184

11721185
// let placer = <placer_expr> ;
11731186
let (s1, placer_binding) = {
1174-
let placer_expr = P(self.signal_block_expr(hir_vec![],
1175-
placer_expr,
1176-
e.span,
1177-
hir::PopUnstableBlock,
1178-
ThinVec::new()));
11791187
mk_stmt_let(self, placer_ident, placer_expr)
11801188
};
11811189

@@ -1196,11 +1204,6 @@ impl<'a> LoweringContext<'a> {
11961204

11971205
// pop_unsafe!(EXPR));
11981206
let pop_unsafe_expr = {
1199-
let value_expr = P(self.signal_block_expr(hir_vec![],
1200-
value_expr,
1201-
e.span,
1202-
hir::PopUnstableBlock,
1203-
ThinVec::new()));
12041207
self.signal_block_expr(hir_vec![],
12051208
value_expr,
12061209
e.span,
@@ -1229,11 +1232,9 @@ impl<'a> LoweringContext<'a> {
12291232
ThinVec::new()))
12301233
};
12311234

1232-
return self.signal_block_expr(hir_vec![s1, s2, s3],
1233-
expr,
1234-
e.span,
1235-
hir::PushUnstableBlock,
1236-
e.attrs.clone());
1235+
let block = self.block_all(e.span, hir_vec![s1, s2, s3], Some(expr));
1236+
// add the attributes to the outer returned expr node
1237+
return self.expr_block(P(block), e.attrs.clone());
12371238
}
12381239

12391240
ExprKind::Vec(ref exprs) => {
@@ -1353,30 +1354,20 @@ impl<'a> LoweringContext<'a> {
13531354
fields: &[(&str, &P<Expr>)]) -> hir::Expr {
13541355
let struct_path = &iter::once(&"ops").chain(path).map(|s| *s)
13551356
.collect::<Vec<_>>();
1357+
let unstable_span = this.allow_internal_unstable("...", ast_expr.span);
13561358

1357-
let hir_expr = if fields.len() == 0 {
1358-
this.expr_std_path(ast_expr.span, struct_path,
1359+
if fields.len() == 0 {
1360+
this.expr_std_path(unstable_span, struct_path,
13591361
ast_expr.attrs.clone())
13601362
} else {
13611363
let fields = fields.into_iter().map(|&(s, e)| {
13621364
let expr = P(this.lower_expr(&e));
1363-
let signal_block = P(this.signal_block_expr(hir_vec![],
1364-
expr,
1365-
e.span,
1366-
hir::PopUnstableBlock,
1367-
ThinVec::new()));
1368-
this.field(Symbol::intern(s), signal_block, ast_expr.span)
1365+
this.field(Symbol::intern(s), expr, e.span)
13691366
}).collect();
13701367
let attrs = ast_expr.attrs.clone();
13711368

1372-
this.expr_std_struct(ast_expr.span, struct_path, fields, None, attrs)
1373-
};
1374-
1375-
this.signal_block_expr(hir_vec![],
1376-
hir_expr,
1377-
ast_expr.span,
1378-
hir::PushUnstableBlock,
1379-
ThinVec::new())
1369+
this.expr_std_struct(unstable_span, struct_path, fields, None, attrs)
1370+
}
13801371
}
13811372

13821373
use syntax::ast::RangeLimits::*;
@@ -1646,7 +1637,7 @@ impl<'a> LoweringContext<'a> {
16461637
let iter = P(self.expr_ident(e.span, iter, iter_pat.id));
16471638
let ref_mut_iter = self.expr_mut_addr_of(e.span, iter);
16481639
let next_path = &["iter", "Iterator", "next"];
1649-
let next_path = self.expr_std_path(e.span, next_path, ThinVec::new());
1640+
let next_path = P(self.expr_std_path(e.span, next_path, ThinVec::new()));
16501641
let next_expr = P(self.expr_call(e.span, next_path,
16511642
hir_vec![ref_mut_iter]));
16521643
let arms = hir_vec![pat_arm, break_arm];
@@ -1674,7 +1665,8 @@ impl<'a> LoweringContext<'a> {
16741665
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
16751666
let into_iter_expr = {
16761667
let into_iter_path = &["iter", "IntoIterator", "into_iter"];
1677-
let into_iter = self.expr_std_path(e.span, into_iter_path, ThinVec::new());
1668+
let into_iter = P(self.expr_std_path(e.span, into_iter_path,
1669+
ThinVec::new()));
16781670
P(self.expr_call(e.span, into_iter, hir_vec![head]))
16791671
};
16801672

@@ -1700,32 +1692,20 @@ impl<'a> LoweringContext<'a> {
17001692
ExprKind::Try(ref sub_expr) => {
17011693
// to:
17021694
//
1703-
// {
1704-
// match { Carrier::translate( { <expr> } ) } {
1705-
// Ok(val) => val,
1706-
// Err(err) => { return Carrier::from_error(From::from(err)); }
1707-
// }
1695+
// match Carrier::translate(<expr>) {
1696+
// Ok(val) => val,
1697+
// Err(err) => return Carrier::from_error(From::from(err))
17081698
// }
1699+
let unstable_span = self.allow_internal_unstable("?", e.span);
17091700

1710-
// { Carrier::translate( { <expr> } ) }
1701+
// Carrier::translate(<expr>)
17111702
let discr = {
17121703
// expand <expr>
1713-
let sub_expr = P(self.lower_expr(sub_expr));
1714-
let sub_expr = self.signal_block_expr(hir_vec![],
1715-
sub_expr,
1716-
e.span,
1717-
hir::PopUnstableBlock,
1718-
ThinVec::new());
1704+
let sub_expr = self.lower_expr(sub_expr);
17191705

17201706
let path = &["ops", "Carrier", "translate"];
1721-
let path = self.expr_std_path(e.span,path, ThinVec::new());
1722-
let call = P(self.expr_call(e.span, path, hir_vec![sub_expr]));
1723-
1724-
P(self.signal_block_expr(hir_vec![],
1725-
call,
1726-
e.span,
1727-
hir::PushUnstableBlock,
1728-
ThinVec::new()))
1707+
let path = P(self.expr_std_path(unstable_span, path, ThinVec::new()));
1708+
P(self.expr_call(e.span, path, hir_vec![sub_expr]))
17291709
};
17301710

17311711
// Ok(val) => val
@@ -1738,33 +1718,30 @@ impl<'a> LoweringContext<'a> {
17381718
self.arm(hir_vec![ok_pat], val_expr)
17391719
};
17401720

1741-
// Err(err) => { return Carrier::from_error(From::from(err)); }
1721+
// Err(err) => return Carrier::from_error(From::from(err))
17421722
let err_arm = {
17431723
let err_ident = self.str_to_ident("err");
17441724
let err_local = self.pat_ident(e.span, err_ident);
17451725
let from_expr = {
17461726
let path = &["convert", "From", "from"];
1747-
let from = self.expr_std_path(e.span, path, ThinVec::new());
1727+
let from = P(self.expr_std_path(e.span, path, ThinVec::new()));
17481728
let err_expr = self.expr_ident(e.span, err_ident, err_local.id);
17491729

17501730
self.expr_call(e.span, from, hir_vec![err_expr])
17511731
};
17521732
let from_err_expr = {
17531733
let path = &["ops", "Carrier", "from_error"];
1754-
let from_err = self.expr_std_path(e.span, path, ThinVec::new());
1734+
let from_err = P(self.expr_std_path(unstable_span, path,
1735+
ThinVec::new()));
17551736
P(self.expr_call(e.span, from_err, hir_vec![from_expr]))
17561737
};
17571738

17581739
let ret_expr = P(self.expr(e.span,
17591740
hir::Expr_::ExprRet(Some(from_err_expr)),
17601741
ThinVec::new()));
1761-
let ret_stmt = self.stmt_expr(ret_expr);
1762-
let block = P(self.signal_block_stmt(ret_stmt, e.span,
1763-
hir::PushUnstableBlock,
1764-
ThinVec::new()));
17651742

17661743
let err_pat = self.pat_err(e.span, err_local);
1767-
self.arm(hir_vec![err_pat], block)
1744+
self.arm(hir_vec![err_pat], ret_expr)
17681745
};
17691746

17701747
return self.expr_match(e.span, discr, hir_vec![err_arm, ok_arm],
@@ -1938,12 +1915,12 @@ impl<'a> LoweringContext<'a> {
19381915
span: Span,
19391916
components: &[&str],
19401917
attrs: ThinVec<Attribute>)
1941-
-> P<hir::Expr> {
1918+
-> hir::Expr {
19421919
let path = self.std_path(span, components, true);
19431920
let def = path.def;
19441921
let expr = self.expr(span, hir::ExprPath(hir::QPath::Resolved(None, P(path))), attrs);
19451922
self.resolver.record_resolution(expr.id, def);
1946-
P(expr)
1923+
expr
19471924
}
19481925

19491926
fn expr_match(&mut self,
@@ -1968,13 +1945,13 @@ impl<'a> LoweringContext<'a> {
19681945
components: &[&str],
19691946
fields: hir::HirVec<hir::Field>,
19701947
e: Option<P<hir::Expr>>,
1971-
attrs: ThinVec<Attribute>) -> P<hir::Expr> {
1948+
attrs: ThinVec<Attribute>) -> hir::Expr {
19721949
let path = self.std_path(span, components, false);
19731950
let def = path.def;
19741951
let qpath = hir::QPath::Resolved(None, P(path));
19751952
let expr = self.expr(span, hir::ExprStruct(qpath, fields, e), attrs);
19761953
self.resolver.record_resolution(expr.id, def);
1977-
P(expr)
1954+
expr
19781955
}
19791956

19801957
fn expr(&mut self, span: Span, node: hir::Expr_, attrs: ThinVec<Attribute>) -> hir::Expr {
@@ -2006,15 +1983,6 @@ impl<'a> LoweringContext<'a> {
20061983
(respan(sp, hir::StmtDecl(P(decl), self.next_id())), pat_id)
20071984
}
20081985

2009-
// Turns `<expr>` into `<expr>;`, note that this produces a StmtSemi, not a
2010-
// StmtExpr.
2011-
fn stmt_expr(&self, expr: P<hir::Expr>) -> hir::Stmt {
2012-
hir::Stmt {
2013-
span: expr.span,
2014-
node: hir::StmtSemi(expr, self.next_id()),
2015-
}
2016-
}
2017-
20181986
fn block_expr(&mut self, expr: P<hir::Expr>) -> hir::Block {
20191987
self.block_all(expr.span, hir::HirVec::new(), Some(expr))
20201988
}
@@ -2144,23 +2112,6 @@ impl<'a> LoweringContext<'a> {
21442112
self.expr_block(block, attrs)
21452113
}
21462114

2147-
fn signal_block_stmt(&mut self,
2148-
stmt: hir::Stmt,
2149-
span: Span,
2150-
rule: hir::BlockCheckMode,
2151-
attrs: ThinVec<Attribute>)
2152-
-> hir::Expr {
2153-
let id = self.next_id();
2154-
let block = P(hir::Block {
2155-
rules: rule,
2156-
span: span,
2157-
id: id,
2158-
stmts: hir_vec![stmt],
2159-
expr: None,
2160-
});
2161-
self.expr_block(block, attrs)
2162-
}
2163-
21642115
fn ty(&mut self, span: Span, node: hir::Ty_) -> P<hir::Ty> {
21652116
P(hir::Ty {
21662117
id: self.next_id(),

‎src/librustc/hir/mod.rs

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -838,9 +838,6 @@ pub enum BlockCheckMode {
838838
UnsafeBlock(UnsafeSource),
839839
PushUnsafeBlock(UnsafeSource),
840840
PopUnsafeBlock(UnsafeSource),
841-
// Within this block (but outside a PopUnstableBlock), we suspend checking of stability.
842-
PushUnstableBlock,
843-
PopUnstableBlock,
844841
}
845842

846843
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]

‎src/librustc/hir/print.rs

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1128,8 +1128,6 @@ impl<'a> State<'a> {
11281128
hir::UnsafeBlock(..) => self.word_space("unsafe")?,
11291129
hir::PushUnsafeBlock(..) => self.word_space("push_unsafe")?,
11301130
hir::PopUnsafeBlock(..) => self.word_space("pop_unsafe")?,
1131-
hir::PushUnstableBlock => self.word_space("push_unstable")?,
1132-
hir::PopUnstableBlock => self.word_space("pop_unstable")?,
11331131
hir::DefaultBlock => (),
11341132
}
11351133
self.maybe_print_comment(blk.span.lo)?;

‎src/librustc/middle/effect.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -147,7 +147,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
147147
self.unsafe_context.push_unsafe_count =
148148
self.unsafe_context.push_unsafe_count.checked_sub(1).unwrap();
149149
}
150-
hir::DefaultBlock | hir::PushUnstableBlock | hir:: PopUnstableBlock => {}
150+
hir::DefaultBlock => {}
151151
}
152152

153153
intravisit::walk_block(self, block);

‎src/librustc/middle/stability.rs

Lines changed: 0 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -367,7 +367,6 @@ pub fn check_unstable_api_usage<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
367367
tcx: tcx,
368368
active_features: active_features,
369369
used_features: FxHashMap(),
370-
in_skip_block: 0,
371370
};
372371
intravisit::walk_crate(&mut checker, tcx.map.krate());
373372

@@ -378,8 +377,6 @@ struct Checker<'a, 'tcx: 'a> {
378377
tcx: TyCtxt<'a, 'tcx, 'tcx>,
379378
active_features: FxHashSet<Symbol>,
380379
used_features: FxHashMap<Symbol, attr::StabilityLevel>,
381-
// Within a block where feature gate checking can be skipped.
382-
in_skip_block: u32,
383380
}
384381

385382
impl<'a, 'tcx> Checker<'a, 'tcx> {
@@ -394,11 +391,6 @@ impl<'a, 'tcx> Checker<'a, 'tcx> {
394391
return
395392
}
396393

397-
// We don't need to check for stability - presumably compiler generated code.
398-
if self.in_skip_block > 0 {
399-
return;
400-
}
401-
402394
match *stab {
403395
Some(&Stability { level: attr::Unstable {ref reason, issue}, ref feature, .. }) => {
404396
self.used_features.insert(feature.clone(),
@@ -485,21 +477,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
485477
&mut |id, sp, stab, depr| self.check(id, sp, stab, depr));
486478
intravisit::walk_ty(self, ty)
487479
}
488-
489-
fn visit_block(&mut self, b: &'tcx hir::Block) {
490-
let old_skip_count = self.in_skip_block;
491-
match b.rules {
492-
hir::BlockCheckMode::PushUnstableBlock => {
493-
self.in_skip_block += 1;
494-
}
495-
hir::BlockCheckMode::PopUnstableBlock => {
496-
self.in_skip_block = self.in_skip_block.checked_sub(1).unwrap();
497-
}
498-
_ => {}
499-
}
500-
intravisit::walk_block(self, b);
501-
self.in_skip_block = old_skip_count;
502-
}
503480
}
504481

505482
/// Helper for discovering nodes to check for stability

‎src/librustc_typeck/check/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -341,7 +341,7 @@ impl UnsafetyState {
341341
(unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
342342
hir::UnsafeBlock(..) =>
343343
(hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
344-
hir::DefaultBlock | hir::PushUnstableBlock | hir:: PopUnstableBlock =>
344+
hir::DefaultBlock =>
345345
(unsafety, self.def, self.unsafe_push_count),
346346
};
347347
UnsafetyState{ def: def,

0 commit comments

Comments
 (0)