implement (and use) precedence in parsing

Author: nikomatsakis

crates/formality-macros/src/attrs.rs

@@ -2,7 +2,7 @@
 
 use syn::{spanned::Spanned, Attribute, DeriveInput};
 
-use crate::custom::Customize;
+use crate::{custom::Customize, precedence::Precedence};
 
 /// Checks for any kind of attribute that indicates an "is-a" relationship,
 /// e.g. `#[cast]` and `#[variable]`.
@@ -39,30 +39,42 @@ pub(crate) fn has_variable_attr(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|a| a.path().is_ident("variable"))
 }
 
+/// Extract a `#[precedence]` level, defaults to 0
+pub(crate) fn precedence(attrs: &[Attribute]) -> syn::Result<Precedence> {
+    parse_attr_named(attrs, "precedence")
+}
+
 /// Extracts any customization attribute from a list of attributes.
 pub(crate) fn customize(attrs: &[Attribute]) -> syn::Result<Customize> {
-    let mut v: Vec<Customize> = attrs
+    parse_attr_named(attrs, "customize")
+}
+
+fn parse_attr_named<T>(attrs: &[Attribute], name: &str) -> syn::Result<T>
+where
+    T: Default + syn::parse::Parse,
+{
+    let mut v: Vec<T> = attrs
         .iter()
-        .filter(|a| a.path().is_ident("customize"))
+        .filter(|a| a.path().is_ident(name))
         .map(|a| a.parse_args())
         .collect::<syn::Result<_>>()?;
 
     if v.len() > 1 {
         Err(syn::Error::new(
             attrs
                 .iter()
-                .filter(|a| a.path().is_ident("customize"))
+                .filter(|a| a.path().is_ident(name))
                 .skip(1)
                 .next()
                 .unwrap()
                 .path()
                 .span(),
-            "multiple customize attributes",
+            format!("multiple `{}` attributes", name),
         ))
     } else if v.len() == 1 {
         Ok(v.pop().unwrap())
     } else {
-        Ok(Customize::default())
+        Ok(T::default())
     }
 }
 
@@ -82,5 +94,6 @@ fn remove_formality_attributes_from_vec(attrs: &mut Vec<Attribute>) {
             && !attr.path().is_ident("cast")
             && !attr.path().is_ident("variable")
             && !attr.path().is_ident("customize")
+            && !attr.path().is_ident("precedence")
     });
 }

crates/formality-macros/src/lib.rs

@@ -12,6 +12,7 @@ mod debug;
 mod fixed_point;
 mod fold;
 mod parse;
+mod precedence;
 mod spec;
 mod term;
 mod test;

crates/formality-macros/src/parse.rs

@@ -1,12 +1,13 @@
 extern crate proc_macro;
+
 use convert_case::{Case, Casing};
 use proc_macro2::{Ident, Literal, TokenStream};
 use quote::{quote, quote_spanned};
 use syn::{spanned::Spanned, Attribute};
 use synstructure::BindingInfo;
 
 use crate::{
-    attrs::{has_cast_attr, has_variable_attr},
+    attrs::{has_cast_attr, has_variable_attr, precedence},
     spec::{self, FieldMode, FormalitySpec},
 };
 
@@ -40,13 +41,11 @@ pub(crate) fn derive_parse_with_spec(
     for variant in s.variants() {
         let variant_name = as_literal(variant.ast().ident);
         let v = parse_variant(variant, external_spec)?;
-        parse_variants.extend(quote! {
-            {
-                let __span = tracing::span!(tracing::Level::TRACE, "parse", variant_name = #variant_name);
-                let __guard = __span.enter();
-                __parser.parse_variant(#variant_name, 0, |__p| { #v });
-            }
-        });
+        let precedence = precedence(&variant.ast().attrs)?.literal();
+        parse_variants.extend(quote_spanned!(
+            variant.ast().ident.span() =>
+            __parser.parse_variant(#variant_name, #precedence, |__p| { #v });
+        ));
     }
 
     let type_name: Literal = as_literal(&s.ast().ident);

crates/formality-macros/src/precedence.rs

@@ -0,0 +1,51 @@
+use std::str::FromStr;
+
+use proc_macro2::{Literal, TokenStream};
+use syn::spanned::Spanned;
+
+#[derive(Default, Debug)]
+pub(crate) struct Precedence {
+    pub level: usize,
+}
+
+impl Precedence {
+    pub fn literal(&self) -> Literal {
+        Literal::usize_unsuffixed(self.level)
+    }
+}
+
+impl syn::parse::Parse for Precedence {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let token_stream: TokenStream = input.parse()?;
+        let span = token_stream.span();
+        let mut tokens = token_stream.into_iter();
+
+        let Some(token) = tokens.next() else {
+            return Err(syn::Error::new(span, "precedence expected"));
+        };
+
+        let level;
+        match token {
+            proc_macro2::TokenTree::Literal(l) => {
+                let l_str = l.to_string();
+                match usize::from_str(&l_str) {
+                    Ok(l) => level = l,
+                    Err(_) => return Err(syn::Error::new(l.span(), "integer precedence expected")),
+                }
+            }
+
+            _ => {
+                return Err(syn::Error::new(
+                    token.span(),
+                    "unexpected token in precedence",
+                ));
+            }
+        }
+
+        if let Some(token) = tokens.next() {
+            return Err(syn::Error::new(token.span(), "extra tokens"));
+        }
+
+        Ok(Precedence { level })
+    }
+}

crates/formality-types/src/grammar/ty.rs

@@ -99,7 +99,6 @@ impl DowncastTo<TyData> for Ty {
 // NB: TyData doesn't implement Fold; you fold types, not TyData,
 // because variables might not map to the same variant.
 #[term]
-#[customize(parse)]
 pub enum TyData {
     #[cast]
     RigidTy(RigidTy),
@@ -108,6 +107,7 @@ pub enum TyData {
     #[cast]
     PredicateTy(PredicateTy),
     #[variable]
+    #[precedence(1)]
     Variable(Variable),
 }
 

crates/formality-types/src/grammar/ty/parse_impls.rs

@@ -6,27 +6,10 @@ use formality_core::{seq, Set};
 
 use crate::grammar::{AdtId, AssociatedItemId, Bool, Const, RefKind, RigidName, Scalar, TraitId};
 
-use super::{
-    AliasTy, AssociatedTyName, Lt, LtData, Parameter, PredicateTy, RigidTy, ScalarId, Ty, TyData,
-};
+use super::{AliasTy, AssociatedTyName, Lt, LtData, Parameter, RigidTy, ScalarId, Ty};
 
 use crate::rust::FormalityLang as Rust;
 
-// ANCHOR: ty_parse_impl
-// For types, we invest some effort into parsing them decently because it makes
-// writing tests so much more pleasant.
-impl CoreParse<Rust> for TyData {
-    fn parse<'t>(scope: &Scope<Rust>, text0: &'t str) -> ParseResult<'t, Self> {
-        let mut parser = Parser::new(scope, text0, "Ty");
-        parser.parse_variant("Variable", 1, |p| p.variable());
-        parser.parse_variant_cast::<RigidTy>(0);
-        parser.parse_variant_cast::<AliasTy>(0);
-        parser.parse_variant_cast::<PredicateTy>(0);
-        parser.finish()
-    }
-}
-// ANCHOR_END: ty_parse_impl
-
 impl CoreParse<Rust> for RigidTy {
     fn parse<'t>(scope: &Scope<Rust>, text: &'t str) -> ParseResult<'t, Self> {
         let mut parser: Parser<'_, '_, RigidTy, Rust> = Parser::new(scope, text, "AliasTy");