Eliminate word_or_empty methods.

To get rid of the `Ident::empty` uses.
This requires introducing `PathParser::word_sym`, as an alternative to
`PathParser::word`.

Author: nnethercote

compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs

@@ -53,7 +53,7 @@ fn parse_unstable<'a>(
 
 for param in list.mixed(){
 let param_span = param.span();
-ifletSome(ident) = param.meta_item().and_then(|i| i.word_without_args()){
+ifletSome(ident) = param.meta_item().and_then(|i| i.path_without_args().word()){
  res.push(ident.name);
 }else{
  cx.emit_err(session_diagnostics::ExpectsFeatures{

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -1,5 +1,4 @@
 use rustc_attr_data_structures::{AttributeKind,DeprecatedSince,Deprecation};
-use rustc_span::symbol::Ident;
 use rustc_span::{Span,Symbol, sym};
 
 usesuper::SingleAttributeParser;
@@ -13,16 +12,13 @@ pub(crate) struct DeprecationParser;
 
 fnget(
 cx:&AcceptContext<'_>,
-ident:Ident,
+name:Symbol,
 param_span:Span,
 arg:&ArgParser<'_>,
 item:&Option<Symbol>,
 ) -> Option<Symbol>{
 if item.is_some(){
- cx.emit_err(session_diagnostics::MultipleItem{
-span: param_span,
-item: ident.to_string(),
-});
+ cx.emit_err(session_diagnostics::MultipleItem{span: param_span,item: name.to_string()});
 returnNone;
 }
 ifletSome(v) = arg.name_value(){
@@ -83,16 +79,16 @@ impl SingleAttributeParser for DeprecationParser {
 returnNone;
 };
 
-let(ident, arg)= param.word_or_empty();
+letident_name = param.path_without_args().word_sym();
 
-matchident.name{
- sym::since => {
- since = Some(get(cx,ident, param_span,arg,&since)?);
+matchident_name{
+Some(name @ sym::since) => {
+ since = Some(get(cx,name, param_span,param.args(),&since)?);
 }
- sym::note => {
- note = Some(get(cx,ident, param_span,arg,&note)?);
+Some(name @ sym::note) => {
+ note = Some(get(cx,name, param_span,param.args(),&note)?);
 }
- sym::suggestion => {
+Some(name @ sym::suggestion) => {
 if !features.deprecated_suggestion(){
  cx.emit_err(session_diagnostics::DeprecatedItemSuggestion{
 span: param_span,
@@ -101,12 +97,12 @@ impl SingleAttributeParser for DeprecationParser {
 });
 }
 
- suggestion = Some(get(cx,ident, param_span,arg,&suggestion)?);
+ suggestion = Some(get(cx,name, param_span,param.args(),&suggestion)?);
 }
  _ => {
  cx.emit_err(session_diagnostics::UnknownMetaItem{
 span: param_span,
-item:ident.to_string(),
+item:param.path_without_args().to_string(),
 expected:if features.deprecated_suggestion(){
 &["since","note","suggestion"]
 }else{

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -96,57 +96,65 @@ fn parse_repr(cx: &AcceptContext<'_>, param: &MetaItemParser<'_>) -> Option<Repr
 
 // FIXME(jdonszelmann): invert the parsing here to match on the word first and then the
 // structure.
-let(ident, args) = param.word_or_empty();
-
-match(ident.name, args){
-(sym::align,ArgParser::NoArgs) => {
- cx.emit_err(session_diagnostics::InvalidReprAlignNeedArg{span: ident.span});
+let ident = param.path_without_args().word();
+let ident_span = ident.map_or(rustc_span::DUMMY_SP, |ident| ident.span);
+let name = ident.map(|ident| ident.name);
+let args = param.args();
+
+match(name, args){
+(Some(sym::align),ArgParser::NoArgs) => {
+ cx.emit_err(session_diagnostics::InvalidReprAlignNeedArg{span: ident_span });
 None
 }
-(sym::align,ArgParser::List(l)) => parse_repr_align(cx, l, param.span(),AlignKind::Align),
+(Some(sym::align),ArgParser::List(l)) => {
+parse_repr_align(cx, l, param.span(),AlignKind::Align)
+}
 
-(sym::packed,ArgParser::NoArgs) => Some(ReprPacked(Align::ONE)),
-(sym::packed,ArgParser::List(l)) => {
+(Some(sym::packed),ArgParser::NoArgs) => Some(ReprPacked(Align::ONE)),
+(Some(sym::packed),ArgParser::List(l)) => {
 parse_repr_align(cx, l, param.span(),AlignKind::Packed)
 }
 
-(sym::align | sym::packed,ArgParser::NameValue(l)) => {
+(Some(sym::align | sym::packed),ArgParser::NameValue(l)) => {
  cx.emit_err(session_diagnostics::IncorrectReprFormatGeneric{
 span: param.span(),
 // FIXME(jdonszelmann) can just be a string in the diag type
-repr_arg:&ident.to_string(),
+repr_arg:&ident.unwrap().to_string(),
 cause:IncorrectReprFormatGenericCause::from_lit_kind(
  param.span(),
 &l.value_as_lit().kind,
- ident.name.as_str(),
+ ident.unwrap().as_str(),
 ),
 });
 None
 }
 
-(sym::Rust,ArgParser::NoArgs) => Some(ReprRust),
-(sym::C,ArgParser::NoArgs) => Some(ReprC),
-(sym::simd,ArgParser::NoArgs) => Some(ReprSimd),
-(sym::transparent,ArgParser::NoArgs) => Some(ReprTransparent),
-(i @ int_pat!(),ArgParser::NoArgs) => {
+(Some(sym::Rust),ArgParser::NoArgs) => Some(ReprRust),
+(Some(sym::C),ArgParser::NoArgs) => Some(ReprC),
+(Some(sym::simd),ArgParser::NoArgs) => Some(ReprSimd),
+(Some(sym::transparent),ArgParser::NoArgs) => Some(ReprTransparent),
+(Some(i @ int_pat!()),ArgParser::NoArgs) => {
 // int_pat!() should make sure it always parses
 Some(ReprInt(int_type_of_word(i).unwrap()))
 }
 
 (
- sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!(),
+Some(sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!()),
 ArgParser::NameValue(_),
 ) => {
  cx.emit_err(session_diagnostics::InvalidReprHintNoValue{
 span: param.span(),
-name: ident.to_string(),
+name: ident.unwrap().to_string(),
 });
 None
 }
-(sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!(),ArgParser::List(_)) => {
+(
+Some(sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!()),
+ArgParser::List(_),
+) => {
  cx.emit_err(session_diagnostics::InvalidReprHintNoParen{
 span: param.span(),
-name: ident.to_string(),
+name: ident.unwrap().to_string(),
 });
 None
 }

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -242,9 +242,9 @@ pub(crate) fn parse_stability(
 returnNone;
 };
 
-match param.word_or_empty_without_args().name{
- sym::feature => insert_value_into_option_or_error(cx,&param,&mut feature)?,
- sym::since => insert_value_into_option_or_error(cx,&param,&mut since)?,
+match param.path_without_args().word_sym(){
+Some(sym::feature) => insert_value_into_option_or_error(cx,&param,&mut feature)?,
+Some(sym::since) => insert_value_into_option_or_error(cx,&param,&mut since)?,
  _ => {
  cx.emit_err(session_diagnostics::UnknownMetaItem{
 span: param_span,
@@ -310,11 +310,10 @@ pub(crate) fn parse_unstability(
 returnNone;
 };
 
-let(word, args) = param.word_or_empty();
-match word.name{
- sym::feature => insert_value_into_option_or_error(cx,&param,&mut feature)?,
- sym::reason => insert_value_into_option_or_error(cx,&param,&mut reason)?,
- sym::issue => {
+match param.path_without_args().word_sym(){
+Some(sym::feature) => insert_value_into_option_or_error(cx,&param,&mut feature)?,
+Some(sym::reason) => insert_value_into_option_or_error(cx,&param,&mut reason)?,
+Some(sym::issue) => {
 insert_value_into_option_or_error(cx,&param,&mut issue)?;
 
 // These unwraps are safe because `insert_value_into_option_or_error` ensures the meta item
@@ -328,7 +327,7 @@ pub(crate) fn parse_unstability(
  session_diagnostics::InvalidIssueString{
 span: param.span(),
 cause: session_diagnostics::InvalidIssueStringCause::from_int_error_kind(
- args.name_value().unwrap().value_span,
+param.args().name_value().unwrap().value_span,
  err.kind(),
 ),
 },
@@ -338,13 +337,15 @@ pub(crate) fn parse_unstability(
 },
 };
 }
- sym::soft => {
-if !args.no_args(){
+Some(sym::soft) => {
+if !param.args().no_args(){
  cx.emit_err(session_diagnostics::SoftNoArgs{span: param.span()});
 }
  is_soft = true;
 }
- sym::implied_by => insert_value_into_option_or_error(cx,&param,&mut implied_by)?,
+Some(sym::implied_by) => {
+insert_value_into_option_or_error(cx,&param,&mut implied_by)?
+}
  _ => {
  cx.emit_err(session_diagnostics::UnknownMetaItem{
 span: param.span(),

compiler/rustc_attr_parsing/src/parser.rs

@@ -78,8 +78,8 @@ impl<'a> PathParser<'a> {
 (self.len() == 1).then(|| **self.segments().next().as_ref().unwrap())
 }
 
-pubfnword_or_empty(&self) -> Ident{
-self.word().unwrap_or_else(Ident::empty)
+pubfnword_sym(&self) -> Option<Symbol>{
+self.word().map(|ident| ident.name)
 }
 
 /// Asserts that this MetaItem is some specific word.
@@ -284,11 +284,6 @@ impl<'a> MetaItemParser<'a> {
 Some(self.word()?.0)
 }
 
-/// Like [`word`](Self::word), but returns an empty symbol instead of None
-pubfnword_or_empty_without_args(&self) -> Ident{
-self.word_or_empty().0
-}
-
 /// Asserts that this MetaItem starts with a word, or single segment path.
 ///
 /// Some examples:
@@ -300,12 +295,6 @@ impl<'a> MetaItemParser<'a> {
 Some((path.word()?, args))
 }
 
-/// Like [`word`](Self::word), but returns an empty symbol instead of None
-pubfnword_or_empty(&self) -> (Ident,&ArgParser<'a>){
-let(path, args) = self.deconstruct();
-(path.word().unwrap_or(Ident::empty()), args)
-}
-
 /// Asserts that this MetaItem starts with some specific word.
 ///
 /// See [`word`](Self::word) for examples of what a word is.