use more standard parsing terminology

nikomatsakis · nikomatsakis · commit 3631d6e89101 · 2023-11-02T08:19:16.000-04:00
not sure why I called it *op* when it's just a symbol
diff --git a/crates/formality-macros/src/debug.rs b/crates/formality-macros/src/debug.rs
@@ -6,7 +6,7 @@ use syn::{spanned::Spanned, Attribute};
 
 use crate::{
     attrs,
-    spec::{self, FieldMode, FormalitySpec, FormalitySpecOp},
+    spec::{self, FieldMode, FormalitySpec, FormalitySpecSymbol},
 };
 
 /// Derive the `Parse` impl, using an optional grammar supplied "from the outside".
@@ -122,23 +122,26 @@ fn debug_variant_with_attr(
 
     stream.extend(quote!(let mut sep = "";));
 
-    let mut prev_op: Option<&FormalitySpecOp> = None;
-    for op in &spec.ops {
+    let mut prev_op: Option<&FormalitySpecSymbol> = None;
+    for op in &spec.symbols {
         // insert whitespace if needed
         let suppress_space = match (prev_op, op) {
             // consecutive characters don't need spaces
-            (Some(spec::FormalitySpecOp::Char { .. }), spec::FormalitySpecOp::Char { .. }) => true,
+            (
+                Some(spec::FormalitySpecSymbol::Char { .. }),
+                spec::FormalitySpecSymbol::Char { .. },
+            ) => true,
 
             // `foo(` looks better than `foo (`
             (
-                Some(spec::FormalitySpecOp::Keyword { .. }),
-                spec::FormalitySpecOp::Delimeter { .. },
+                Some(spec::FormalitySpecSymbol::Keyword { .. }),
+                spec::FormalitySpecSymbol::Delimeter { .. },
             ) => true,
 
             // consecutive delimeters don't need spaces
             (
-                Some(spec::FormalitySpecOp::Delimeter { .. }),
-                spec::FormalitySpecOp::Delimeter { .. },
+                Some(spec::FormalitySpecSymbol::Delimeter { .. }),
+                spec::FormalitySpecSymbol::Delimeter { .. },
             ) => true,
 
             _ => false,
@@ -150,7 +153,7 @@ fn debug_variant_with_attr(
         }
 
         stream.extend(match op {
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Single | FieldMode::Optional,
             } => {
@@ -162,7 +165,7 @@ fn debug_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Many,
             } => {
@@ -176,7 +179,7 @@ fn debug_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Comma,
             } => {
@@ -191,7 +194,7 @@ fn debug_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Keyword { ident } => {
+            spec::FormalitySpecSymbol::Keyword { ident } => {
                 let literal = as_literal(ident);
                 quote_spanned!(ident.span() =>
                     write!(fmt, "{}", sep)?;
@@ -200,7 +203,7 @@ fn debug_variant_with_attr(
                 )
             }
 
-            spec::FormalitySpecOp::Char { punct } => {
+            spec::FormalitySpecSymbol::Char { punct } => {
                 let literal = Literal::character(punct.as_char());
                 quote_spanned!(punct.span() =>
                     write!(fmt, "{}", sep)?;
@@ -209,7 +212,7 @@ fn debug_variant_with_attr(
                 )
             }
 
-            spec::FormalitySpecOp::Delimeter { text } => match text {
+            spec::FormalitySpecSymbol::Delimeter { text } => match text {
                 '{' | '}' => {
                     let literal = Literal::character(*text);
                     quote!(
diff --git a/crates/formality-macros/src/parse.rs b/crates/formality-macros/src/parse.rs
@@ -6,7 +6,7 @@ use syn::{spanned::Spanned, Attribute};
 use synstructure::BindingInfo;
 
 use crate::{
-    spec::{self, FieldMode, FormalitySpec, FormalitySpecOp},
+    spec::{self, FieldMode, FormalitySpec, FormalitySpecSymbol},
     attrs::{has_variable_attr, has_cast_attr},
 };
 
@@ -154,11 +154,11 @@ fn parse_variant_with_attr(
 ) -> syn::Result<TokenStream> {
     let mut stream = TokenStream::new();
 
-    for i in 0..spec.ops.len() {
-        let op = &spec.ops[i];
-        let next_op = spec.ops.get(i + 1);
-        stream.extend(match op {
-            spec::FormalitySpecOp::Field {
+    for i in 0..spec.symbols.len() {
+        let symbol = &spec.symbols[i];
+        let next_symbol = spec.symbols.get(i + 1);
+        stream.extend(match symbol {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Single,
             } => {
@@ -167,7 +167,7 @@ fn parse_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Optional,
             } => {
@@ -178,11 +178,11 @@ fn parse_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Many,
             } => {
-                match lookahead(next_op) {
+                match lookahead(next_symbol) {
                     Some(lookahead) => quote_spanned! {
                         name.span() => let (#name, text) = parse::CoreParse::parse_many(scope, text, #lookahead)?;
                     },
@@ -192,11 +192,11 @@ fn parse_variant_with_attr(
                 }
             }
 
-            spec::FormalitySpecOp::Field {
+            spec::FormalitySpecSymbol::Field {
                 name,
                 mode: FieldMode::Comma,
             } => {
-                match lookahead(next_op) {
+                match lookahead(next_symbol) {
                     Some(lookahead) => quote_spanned! {
                         name.span() => let (#name, text) = parse::CoreParse::parse_comma(scope, text, #lookahead)?;
                     },
@@ -210,17 +210,17 @@ fn parse_variant_with_attr(
                 
             }
 
-            spec::FormalitySpecOp::Keyword { ident } => {
+            spec::FormalitySpecSymbol::Keyword { ident } => {
                 let literal = as_literal(ident);
                 quote_spanned!(ident.span() => let ((), text) = parse::expect_keyword(#literal, text)?;)
             }
 
-            spec::FormalitySpecOp::Char { punct } => {
+            spec::FormalitySpecSymbol::Char { punct } => {
                 let literal = Literal::character(punct.as_char());
                 quote_spanned!(punct.span() => let ((), text) = parse::expect_char(#literal, text)?;)
             }
 
-            spec::FormalitySpecOp::Delimeter { text } => {
+            spec::FormalitySpecSymbol::Delimeter { text } => {
                 let literal = Literal::character(*text);
                 quote!(let ((), text) = parse::expect_char(#literal, text)?;)
             }
@@ -236,11 +236,11 @@ fn parse_variant_with_attr(
     Ok(stream)
 }
 
-fn lookahead(op: Option<&FormalitySpecOp>) -> Option<Literal> {
-    match op {
-        Some(FormalitySpecOp::Char { punct }) => Some(Literal::character(punct.as_char())),
-        Some(FormalitySpecOp::Delimeter { text }) => Some(Literal::character(*text)),
-        Some(FormalitySpecOp::Keyword { .. }) | Some(FormalitySpecOp::Field { .. }) | None => None,
+fn lookahead(next_symbol: Option<&FormalitySpecSymbol>) -> Option<Literal> {
+    match next_symbol {
+        Some(FormalitySpecSymbol::Char { punct }) => Some(Literal::character(punct.as_char())),
+        Some(FormalitySpecSymbol::Delimeter { text }) => Some(Literal::character(*text)),
+        Some(FormalitySpecSymbol::Keyword { .. }) | Some(FormalitySpecSymbol::Field { .. }) | None => None,
     }
 }
 
diff --git a/crates/formality-macros/src/spec.rs b/crates/formality-macros/src/spec.rs
@@ -10,11 +10,11 @@ use proc_macro2::{Ident, Punct, TokenStream, TokenTree};
 /// * a character like `<` is parsed as is; a group like `[..]` parses a `[`, the contents, and then `]`
 #[derive(Debug)]
 pub struct FormalitySpec {
-    pub ops: Vec<FormalitySpecOp>,
+    pub symbols: Vec<FormalitySpecSymbol>,
 }
 
 #[derive(Debug)]
-pub enum FormalitySpecOp {
+pub enum FormalitySpecSymbol {
     /// `$foo` or `$foo*` -- indicates we should parse the type of the given field.
     Field { name: Ident, mode: FieldMode },
 
@@ -53,17 +53,17 @@ pub enum FieldMode {
 impl syn::parse::Parse for FormalitySpec {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let token_stream: TokenStream = input.parse()?;
-        let mut ops = vec![];
-        token_stream_to_ops(&mut ops, token_stream)?;
-        Ok(FormalitySpec { ops })
+        let mut symbols = vec![];
+        token_stream_to_symbols(&mut symbols, token_stream)?;
+        Ok(FormalitySpec { symbols })
     }
 }
 
-fn token_stream_to_ops(
-    ops: &mut Vec<FormalitySpecOp>,
+fn token_stream_to_symbols(
+    symbols: &mut Vec<FormalitySpecSymbol>,
     token_stream: TokenStream,
 ) -> syn::Result<()> {
-    use FormalitySpecOp::*;
+    use FormalitySpecSymbol::*;
 
     let mut tokens = token_stream.into_iter();
 
@@ -78,17 +78,17 @@ fn token_stream_to_ops(
                 };
 
                 if let Some(ch) = open_text {
-                    ops.push(Delimeter { text: ch });
+                    symbols.push(Delimeter { text: ch });
                 }
-                token_stream_to_ops(ops, v.stream())?;
+                token_stream_to_symbols(symbols, v.stream())?;
                 if let Some(ch) = close_text {
-                    ops.push(Delimeter { text: ch });
+                    symbols.push(Delimeter { text: ch });
                 }
             }
-            proc_macro2::TokenTree::Ident(ident) => ops.push(Keyword { ident }),
+            proc_macro2::TokenTree::Ident(ident) => symbols.push(Keyword { ident }),
             proc_macro2::TokenTree::Punct(punct) => match punct.as_char() {
-                '$' => ops.push(parse_variable_binding(punct, &mut tokens)?),
-                _ => ops.push(Char { punct }),
+                '$' => symbols.push(parse_variable_binding(punct, &mut tokens)?),
+                _ => symbols.push(Char { punct }),
             },
             proc_macro2::TokenTree::Literal(_) => {
                 let message = "unexpected literal in parse string";
@@ -109,7 +109,7 @@ fn token_stream_to_ops(
 fn parse_variable_binding(
     dollar_token: Punct,
     tokens: &mut impl Iterator<Item = TokenTree>,
-) -> syn::Result<FormalitySpecOp> {
+) -> syn::Result<FormalitySpecSymbol> {
     let error = || {
         let message = "expected field name or field mode (`,`, `*`)";
         Err(syn::Error::new(dollar_token.span(), message))
@@ -128,7 +128,7 @@ fn parse_variable_binding(
                 ',' => FieldMode::Comma,
                 '*' => FieldMode::Many,
                 '?' => FieldMode::Optional,
-                '$' => return Ok(FormalitySpecOp::Char { punct }),
+                '$' => return Ok(FormalitySpecSymbol::Char { punct }),
                 _ => return error(),
             };
 
@@ -148,5 +148,5 @@ fn parse_variable_binding(
         _ => return error(),
     };
 
-    Ok(FormalitySpecOp::Field { name, mode })
+    Ok(FormalitySpecSymbol::Field { name, mode })
 }
