bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Rename Unsafe to Safety

Browse source
This commit is contained in:
Santiago Pastorino 2024-05-17 14:17:48 -03:00
parent 2d89cee625
commit 6b46a919e1
No known key found for this signature in database
GPG key ID: 8131A24E0C79EFAF
115 changed files with 460 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

46
compiler/rustc_parse/src/parser/item.rs
View file

@ -33,7 +33,7 @@ impl<'a> Parser<'a> {
/// Parses a `mod <foo> { ... }` or `mod <foo>;` item.
fn parse_item_mod(&mut self, attrs: &mut AttrVec) -> PResult<'a, ItemInfo> {
let unsafety = self.parse_unsafety(Case::Sensitive);
let safety = self.parse_safety(Case::Sensitive);
self.expect_keyword(kw::Mod)?;
let id = self.parse_ident()?;
let mod_kind = if self.eat(&token::Semi) {
@ -45,7 +45,7 @@ impl<'a> Parser<'a> {
attrs.extend(inner_attrs);
ModKind::Loaded(items, Inline::Yes, inner_span)
};
Ok((id, ItemKind::Mod(unsafety, mod_kind)))
Ok((id, ItemKind::Mod(safety, mod_kind)))
}
/// Parses the contents of a module (inner attributes followed by module items).
@ -210,13 +210,13 @@ impl<'a> Parser<'a> {
self.parse_item_extern_crate()?
} else {
// EXTERN BLOCK
self.parse_item_foreign_mod(attrs, Unsafe::No)?
self.parse_item_foreign_mod(attrs, Safety::Default)?
}
} else if self.is_unsafe_foreign_mod() {
// EXTERN BLOCK
let unsafety = self.parse_unsafety(Case::Sensitive);
let safety = self.parse_safety(Case::Sensitive);
self.expect_keyword(kw::Extern)?;
self.parse_item_foreign_mod(attrs, unsafety)?
self.parse_item_foreign_mod(attrs, safety)?
} else if self.is_static_global() {
// STATIC ITEM
self.bump(); // `static`
@ -540,7 +540,7 @@ impl<'a> Parser<'a> {
attrs: &mut AttrVec,
defaultness: Defaultness,
) -> PResult<'a, ItemInfo> {
let unsafety = self.parse_unsafety(Case::Sensitive);
let safety = self.parse_safety(Case::Sensitive);
self.expect_keyword(kw::Impl)?;
// First, parse generic parameters if necessary.
@ -646,7 +646,7 @@ impl<'a> Parser<'a> {
let trait_ref = TraitRef { path, ref_id: ty_first.id };
ItemKind::Impl(Box::new(Impl {
unsafety,
safety,
polarity,
defaultness,
constness,
@ -659,7 +659,7 @@ impl<'a> Parser<'a> {
None => {
// impl Type
ItemKind::Impl(Box::new(Impl {
unsafety,
safety,
polarity,
defaultness,
constness,
@ -864,7 +864,7 @@ impl<'a> Parser<'a> {
/// Parses `unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemInfo> {
let unsafety = self.parse_unsafety(Case::Sensitive);
let safety = self.parse_safety(Case::Sensitive);
// Parse optional `auto` prefix.
let is_auto = if self.eat_keyword(kw::Auto) {
self.psess.gated_spans.gate(sym::auto_traits, self.prev_token.span);
@ -898,7 +898,7 @@ impl<'a> Parser<'a> {
if is_auto == IsAuto::Yes {
self.dcx().emit_err(errors::TraitAliasCannotBeAuto { span: whole_span });
}
if let Unsafe::Yes(_) = unsafety {
if let Safety::Unsafe(_) = safety {
self.dcx().emit_err(errors::TraitAliasCannotBeUnsafe { span: whole_span });
}
@ -911,7 +911,7 @@ impl<'a> Parser<'a> {
let items = self.parse_item_list(attrs, |p| p.parse_trait_item(ForceCollect::No))?;
Ok((
ident,
ItemKind::Trait(Box::new(Trait { is_auto, unsafety, generics, bounds, items })),
ItemKind::Trait(Box::new(Trait { is_auto, safety, generics, bounds, items })),
))
}
}
@ -1172,19 +1172,19 @@ impl<'a> Parser<'a> {
fn parse_item_foreign_mod(
&mut self,
attrs: &mut AttrVec,
mut unsafety: Unsafe,
mut safety: Safety,
) -> PResult<'a, ItemInfo> {
let abi = self.parse_abi(); // ABI?
if unsafety == Unsafe::No
if safety == Safety::Default
&& self.token.is_keyword(kw::Unsafe)
&& self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Brace))
{
self.expect(&token::OpenDelim(Delimiter::Brace)).unwrap_err().emit();
unsafety = Unsafe::Yes(self.token.span);
safety = Safety::Unsafe(self.token.span);
self.eat_keyword(kw::Unsafe);
}
let module = ast::ForeignMod {
unsafety,
safety,
abi,
items: self.parse_item_list(attrs, |p| p.parse_foreign_item(ForceCollect::No))?,
};
@ -2456,7 +2456,7 @@ impl<'a> Parser<'a> {
let coroutine_kind = self.parse_coroutine_kind(case);
let unsafe_start_sp = self.token.span;
let unsafety = self.parse_unsafety(case);
let safety = self.parse_safety(case);
let ext_start_sp = self.token.span;
let ext = self.parse_extern(case);
@ -2494,7 +2494,7 @@ impl<'a> Parser<'a> {
// We may be able to recover
let mut recover_constness = constness;
let mut recover_coroutine_kind = coroutine_kind;
let mut recover_unsafety = unsafety;
let mut recover_safety = safety;
// This will allow the machine fix to directly place the keyword in the correct place or to indicate
// that the keyword is already present and the second instance should be removed.
let wrong_kw = if self.check_keyword(kw::Const) {
@ -2532,10 +2532,10 @@ impl<'a> Parser<'a> {
}
}
} else if self.check_keyword(kw::Unsafe) {
match unsafety {
Unsafe::Yes(sp) => Some(WrongKw::Duplicated(sp)),
Unsafe::No => {
recover_unsafety = Unsafe::Yes(self.token.span);
match safety {
Safety::Unsafe(sp) => Some(WrongKw::Duplicated(sp)),
Safety::Default => {
recover_safety = Safety::Unsafe(self.token.span);
Some(WrongKw::Misplaced(ext_start_sp))
}
}
@ -2620,7 +2620,7 @@ impl<'a> Parser<'a> {
err.emit();
return Ok(FnHeader {
constness: recover_constness,
unsafety: recover_unsafety,
safety: recover_safety,
coroutine_kind: recover_coroutine_kind,
ext,
});
@ -2631,7 +2631,7 @@ impl<'a> Parser<'a> {
}
}
Ok(FnHeader { constness, unsafety, coroutine_kind, ext })
Ok(FnHeader { constness, safety, coroutine_kind, ext })
}
/// Parses the parameter list and result type of a function declaration.

10
compiler/rustc_parse/src/parser/mod.rs
View file

@ -26,7 +26,7 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree, TokenTreeCursor};
use rustc_ast::util::case::Case;
use rustc_ast::{
self as ast, AnonConst, AttrArgs, AttrArgsEq, AttrId, ByRef, Const, CoroutineKind, DelimArgs,
Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, StrLit, Unsafe, Visibility,
Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, Safety, StrLit, Visibility,
VisibilityKind, DUMMY_NODE_ID,
};
use rustc_ast_pretty::pprust;
@ -1217,12 +1217,12 @@ impl<'a> Parser<'a> {
}
}
/// Parses unsafety: `unsafe` or nothing.
fn parse_unsafety(&mut self, case: Case) -> Unsafe {
/// Parses fn unsafety: `unsafe`, `safe` or nothing.
fn parse_safety(&mut self, case: Case) -> Safety {
if self.eat_keyword_case(kw::Unsafe, case) {
Unsafe::Yes(self.prev_token.uninterpolated_span())
Safety::Unsafe(self.prev_token.uninterpolated_span())
} else {
Unsafe::No
Safety::Default
}
}

4
compiler/rustc_parse/src/parser/ty.rs
View file

@ -590,7 +590,7 @@ impl<'a> Parser<'a> {
tokens: None,
};
let span_start = self.token.span;
let ast::FnHeader { ext, unsafety, constness, coroutine_kind } =
let ast::FnHeader { ext, safety, constness, coroutine_kind } =
self.parse_fn_front_matter(&inherited_vis, Case::Sensitive)?;
if self.may_recover() && self.token.kind == TokenKind::Lt {
self.recover_fn_ptr_with_generics(lo, &mut params, param_insertion_point)?;
@ -608,7 +608,7 @@ impl<'a> Parser<'a> {
}
// FIXME(gen_blocks): emit a similar error for `gen fn()`
let decl_span = span_start.to(self.token.span);
Ok(TyKind::BareFn(P(BareFnTy { ext, unsafety, generic_params: params, decl, decl_span })))
Ok(TyKind::BareFn(P(BareFnTy { ext, safety, generic_params: params, decl, decl_span })))
}
/// Recover from function pointer types with a generic parameter list (e.g. `fn<'a>(&'a str)`).