rename to get rid of the 'raw' concept

Author: folkertdev

compiler/rustc_builtin_macros/src/asm.rs

@@ -20,20 +20,20 @@ use crate::util::{ExprToSpannedString, expr_to_spanned_string};
 
 /// An argument to one of the `asm!` macros. The argument is syntactically valid, but is otherwise
 /// not validated at all.
-pubstructRawAsmArg{
-pubkind:RawAsmArgKind,
+pubstructAsmArg{
+pubkind:AsmArgKind,
 pubspan:Span,
 }
 
-pubenumRawAsmArgKind{
+pubenumAsmArgKind{
 Template(P<ast::Expr>),
 Operand(Option<Symbol>, ast::InlineAsmOperand),
 Options(Vec<(Symbol, ast::InlineAsmOptions,Span,Span)>),
 ClobberAbi(Vec<(Symbol,Span)>),
 }
 
 /// Validated assembly arguments, ready for macro expansion.
-structAsmArgs{
+structValidatedAsmArgs{
 pubtemplates:Vec<P<ast::Expr>>,
 puboperands:Vec<(ast::InlineAsmOperand,Span)>,
 named_args:FxIndexMap<Symbol,usize>,
@@ -145,11 +145,11 @@ fn parse_asm_operand<'a>(
 }
 
 // Public for rustfmt.
-pubfnparse_raw_asm_args<'a>(
+pubfnparse_asm_args<'a>(
 p:&mutParser<'a>,
 sp:Span,
 asm_macro:AsmMacro,
-) -> PResult<'a,Vec<RawAsmArg>>{
+) -> PResult<'a,Vec<AsmArg>>{
 let dcx = p.dcx();
 
 if p.token == token::Eof{
@@ -159,10 +159,7 @@ pub fn parse_raw_asm_args<'a>(
 letmut args = Vec::new();
 
 let first_template = p.parse_expr()?;
- args.push(RawAsmArg{
-span: first_template.span,
-kind:RawAsmArgKind::Template(first_template),
-});
+ args.push(AsmArg{span: first_template.span,kind:AsmArgKind::Template(first_template)});
 
 letmut allow_templates = true;
 
@@ -188,8 +185,8 @@ pub fn parse_raw_asm_args<'a>(
 if p.eat_keyword(exp!(ClobberAbi)){
  allow_templates = false;
 
- args.push(RawAsmArg{
-kind:RawAsmArgKind::ClobberAbi(parse_clobber_abi(p)?),
+ args.push(AsmArg{
+kind:AsmArgKind::ClobberAbi(parse_clobber_abi(p)?),
 span: span_start.to(p.prev_token.span),
 });
 
@@ -200,8 +197,8 @@ pub fn parse_raw_asm_args<'a>(
 if p.eat_keyword(exp!(Options)){
  allow_templates = false;
 
- args.push(RawAsmArg{
-kind:RawAsmArgKind::Options(parse_options(p, asm_macro)?),
+ args.push(AsmArg{
+kind:AsmArgKind::Options(parse_options(p, asm_macro)?),
 span: span_start.to(p.prev_token.span),
 });
 
@@ -222,9 +219,9 @@ pub fn parse_raw_asm_args<'a>(
 ifletSome(op) = parse_asm_operand(p, asm_macro)? {
  allow_templates = false;
 
- args.push(RawAsmArg{
+ args.push(AsmArg{
 span: span_start.to(p.prev_token.span),
-kind:RawAsmArgKind::Operand(name, op),
+kind:AsmArgKind::Operand(name, op),
 });
 }elseif allow_templates {
 let template = p.parse_expr()?;
@@ -246,7 +243,7 @@ pub fn parse_raw_asm_args<'a>(
 }
 }
 
- args.push(RawAsmArg{span: template.span,kind:RawAsmArgKind::Template(template)});
+ args.push(AsmArg{span: template.span,kind:AsmArgKind::Template(template)});
 }else{
  p.unexpected_any()?
 }
@@ -260,19 +257,19 @@ fn parse_args<'a>(
 sp:Span,
 tts:TokenStream,
 asm_macro:AsmMacro,
-) -> PResult<'a,AsmArgs>{
-letraw_args = parse_raw_asm_args(&mut ecx.new_parser_from_tts(tts), sp, asm_macro)?;
-validate_raw_asm_args(ecx, asm_macro,raw_args)
+) -> PResult<'a,ValidatedAsmArgs>{
+letargs = parse_asm_args(&mut ecx.new_parser_from_tts(tts), sp, asm_macro)?;
+validate_asm_args(ecx, asm_macro,args)
 }
 
-fnvalidate_raw_asm_args<'a>(
+fnvalidate_asm_args<'a>(
 ecx:&ExtCtxt<'a>,
 asm_macro:AsmMacro,
-raw_args:Vec<RawAsmArg>,
-) -> PResult<'a,AsmArgs>{
+args:Vec<AsmArg>,
+) -> PResult<'a,ValidatedAsmArgs>{
 let dcx = ecx.dcx();
 
-letmutargs = AsmArgs{
+letmutvalidated = ValidatedAsmArgs{
 templates:vec![],
 operands:vec![],
 named_args:Default::default(),
@@ -284,9 +281,9 @@ fn validate_raw_asm_args<'a>(
 
 letmut allow_templates = true;
 
-for arg inraw_args{
+for arg inargs{
 match arg.kind{
-RawAsmArgKind::Template(template) => {
+AsmArgKind::Template(template) => {
 // The error for the first template is delayed.
 if !allow_templates {
 match template.kind{
@@ -306,15 +303,15 @@ fn validate_raw_asm_args<'a>(
 }
 }
 
-args.templates.push(template);
+validated.templates.push(template);
 }
-RawAsmArgKind::Operand(name, op) => {
+AsmArgKind::Operand(name, op) => {
  allow_templates = false;
 
 let explicit_reg = matches!(op.reg(),Some(ast::InlineAsmRegOrRegClass::Reg(_)));
 let span = arg.span;
-let slot = args.operands.len();
-args.operands.push((op, span));
+let slot = validated.operands.len();
+validated.operands.push((op, span));
 
 // Validate the order of named, positional & explicit register operands and
 // clobber_abi/options. We do this at the end once we have the full span
@@ -324,25 +321,27 @@ fn validate_raw_asm_args<'a>(
 if name.is_some(){
  dcx.emit_err(errors::AsmExplicitRegisterName{ span });
 }
-args.reg_args.insert(slot);
+validated.reg_args.insert(slot);
 }elseifletSome(name) = name {
-ifletSome(&prev) = args.named_args.get(&name){
+ifletSome(&prev) = validated.named_args.get(&name){
  dcx.emit_err(errors::AsmDuplicateArg{
  span,
  name,
-prev:args.operands[prev].1,
+prev:validated.operands[prev].1,
 });
 continue;
 }
- args.named_args.insert(name, slot);
-}elseif !args.named_args.is_empty() || !args.reg_args.is_empty(){
-let named = args.named_args.values().map(|p| args.operands[*p].1).collect();
-let explicit = args.reg_args.iter().map(|p| args.operands[p].1).collect();
+ validated.named_args.insert(name, slot);
+}elseif !validated.named_args.is_empty() || !validated.reg_args.is_empty(){
+let named =
+ validated.named_args.values().map(|p| validated.operands[*p].1).collect();
+let explicit =
+ validated.reg_args.iter().map(|p| validated.operands[p].1).collect();
 
  dcx.emit_err(errors::AsmPositionalAfter{ span, named, explicit });
 }
 }
-RawAsmArgKind::Options(new_options) => {
+AsmArgKind::Options(new_options) => {
  allow_templates = false;
 
 for(symbol, option, span, full_span)in new_options {
@@ -354,53 +353,55 @@ fn validate_raw_asm_args<'a>(
  full_span,
 macro_name: asm_macro.macro_name(),
 });
-}elseifargs.options.contains(option){
+}elseifvalidated.options.contains(option){
 // Tool-only output.
  dcx.emit_err(errors::AsmOptAlreadyprovided{ span, symbol, full_span });
 }else{
-args.options |= option;
+validated.options |= option;
 }
 }
 
-args.options_spans.push(arg.span);
+validated.options_spans.push(arg.span);
 }
-RawAsmArgKind::ClobberAbi(new_abis) => {
+AsmArgKind::ClobberAbi(new_abis) => {
  allow_templates = false;
 
 match&new_abis[..]{
 // This should have errored above during parsing.
 [] => unreachable!(),
-[(abi, _span)] => args.clobber_abis.push((*abi, arg.span)),
- _ => args.clobber_abis.extend(new_abis),
+[(abi, _span)] => validated.clobber_abis.push((*abi, arg.span)),
+ _ => validated.clobber_abis.extend(new_abis),
 }
 }
 }
 }
 
-ifargs.options.contains(ast::InlineAsmOptions::NOMEM)
- && args.options.contains(ast::InlineAsmOptions::READONLY)
+ifvalidated.options.contains(ast::InlineAsmOptions::NOMEM)
+ && validated.options.contains(ast::InlineAsmOptions::READONLY)
 {
-let spans = args.options_spans.clone();
+let spans = validated.options_spans.clone();
  dcx.emit_err(errors::AsmMutuallyExclusive{ spans,opt1:"nomem",opt2:"readonly"});
 }
-ifargs.options.contains(ast::InlineAsmOptions::PURE)
- && args.options.contains(ast::InlineAsmOptions::NORETURN)
+ifvalidated.options.contains(ast::InlineAsmOptions::PURE)
+ && validated.options.contains(ast::InlineAsmOptions::NORETURN)
 {
-let spans = args.options_spans.clone();
+let spans = validated.options_spans.clone();
  dcx.emit_err(errors::AsmMutuallyExclusive{ spans,opt1:"pure",opt2:"noreturn"});
 }
-if args.options.contains(ast::InlineAsmOptions::PURE)
- && !args.options.intersects(ast::InlineAsmOptions::NOMEM | ast::InlineAsmOptions::READONLY)
+if validated.options.contains(ast::InlineAsmOptions::PURE)
+ && !validated
+.options
+.intersects(ast::InlineAsmOptions::NOMEM | ast::InlineAsmOptions::READONLY)
 {
-let spans = args.options_spans.clone();
+let spans = validated.options_spans.clone();
  dcx.emit_err(errors::AsmPureCombine{ spans });
 }
 
 letmut have_real_output = false;
 letmut outputs_sp = vec![];
 letmut regclass_outputs = vec![];
 letmut labels_sp = vec![];
-for(op, op_sp)in&args.operands{
+for(op, op_sp)in&validated.operands{
 match op {
  ast::InlineAsmOperand::Out{ reg, expr, .. }
  | ast::InlineAsmOperand::SplitInOut{ reg,out_expr: expr, .. } => {
@@ -423,26 +424,26 @@ fn validate_raw_asm_args<'a>(
  _ => {}
 }
 }
-ifargs.options.contains(ast::InlineAsmOptions::PURE) && !have_real_output {
- dcx.emit_err(errors::AsmPureNoOutput{spans:args.options_spans.clone()});
+ifvalidated.options.contains(ast::InlineAsmOptions::PURE) && !have_real_output {
+ dcx.emit_err(errors::AsmPureNoOutput{spans:validated.options_spans.clone()});
 }
-ifargs.options.contains(ast::InlineAsmOptions::NORETURN)
+ifvalidated.options.contains(ast::InlineAsmOptions::NORETURN)
  && !outputs_sp.is_empty()
  && labels_sp.is_empty()
 {
 let err = dcx.create_err(errors::AsmNoReturn{ outputs_sp });
 // Bail out now since this is likely to confuse MIR
 returnErr(err);
 }
-ifargs.options.contains(ast::InlineAsmOptions::MAY_UNWIND) && !labels_sp.is_empty(){
+ifvalidated.options.contains(ast::InlineAsmOptions::MAY_UNWIND) && !labels_sp.is_empty(){
  dcx.emit_err(errors::AsmMayUnwind{ labels_sp });
 }
 
-if !args.clobber_abis.is_empty(){
+if !validated.clobber_abis.is_empty(){
 match asm_macro {
 AsmMacro::GlobalAsm | AsmMacro::NakedAsm => {
 let err = dcx.create_err(errors::AsmUnsupportedClobberAbi{
-spans:args.clobber_abis.iter().map(|(_, span)| *span).collect(),
+spans:validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
 macro_name: asm_macro.macro_name(),
 });
 
@@ -453,14 +454,14 @@ fn validate_raw_asm_args<'a>(
 if !regclass_outputs.is_empty(){
  dcx.emit_err(errors::AsmClobberNoReg{
 spans: regclass_outputs,
-clobbers:args.clobber_abis.iter().map(|(_, span)| *span).collect(),
+clobbers:validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
 });
 }
 }
 }
 }
 
-Ok(args)
+Ok(validated)
 }
 
 fnparse_options<'a>(
@@ -566,7 +567,7 @@ fn parse_reg<'a>(p: &mut Parser<'a>) -> PResult<'a, ast::InlineAsmRegOrRegClass>
 fnexpand_preparsed_asm(
 ecx:&mutExtCtxt<'_>,
 asm_macro:AsmMacro,
-args:AsmArgs,
+args:ValidatedAsmArgs,
 ) -> ExpandResult<Result<ast::InlineAsm,ErrorGuaranteed>,()>{
 letmut template = vec![];
 // Register operands are implicitly used since they are not allowed to be

src/tools/rustfmt/src/parse/macros/asm.rs

@@ -1,14 +1,11 @@
 use rustc_ast::ast;
-use rustc_builtin_macros::asm::{RawAsmArg, parse_raw_asm_args};
+use rustc_builtin_macros::asm::{AsmArg, parse_asm_args};
 
 usecrate::rewrite::RewriteContext;
 
 #[allow(dead_code)]
-pub(crate)fnparse_asm(
-context:&RewriteContext<'_>,
-mac:&ast::MacCall,
-) -> Option<Vec<RawAsmArg>>{
+pub(crate)fnparse_asm(context:&RewriteContext<'_>,mac:&ast::MacCall) -> Option<Vec<AsmArg>>{
 let ts = mac.args.tokens.clone();
 letmut parser = super::build_parser(context, ts);
-parse_raw_asm_args(&mut parser, mac.span(), ast::AsmMacro::Asm).ok()
+parse_asm_args(&mut parser, mac.span(), ast::AsmMacro::Asm).ok()
 }