have parse_variant apply an upcast

It's silly that it did not.

Author: nikomatsakis

crates/formality-core/src/cast.rs

@@ -387,6 +387,7 @@ macro_rules! cast_impl {
 
 cast_impl!(usize);
 cast_impl!(u32);
+cast_impl!(u64);
 cast_impl!(String);
 
 impl UpcastFrom<&str> for String {

crates/formality-core/src/parse.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use crate::{
     binder::CoreBinder,
+    cast_impl,
     collections::Set,
     language::{CoreKind, Language},
     set,
@@ -14,7 +15,7 @@ use std::fmt::Debug;
 /// Trait for parsing a [`Term<L>`](`crate::term::Term`) as input.
 /// Typically this is auto-generated with the `#[term]` procedural macro,
 /// but you can implement it by hand if you want a very customized parse.
-pub trait CoreParse<L: Language>: Sized + Debug + Clone + Eq + 'static {
+pub trait CoreParse<L: Language>: Sized + Debug + Clone + Eq + 'static + Upcast<Self> {
     /// Parse a single instance of this type, returning an error if no such
     /// instance is present.
     ///
@@ -211,6 +212,8 @@ pub struct Binding<L: Language> {
     pub bound_var: CoreBoundVar<L>,
 }
 
+cast_impl!(impl(L: Language) Binding<L>);
+
 impl<L, T> CoreParse<L> for Vec<T>
 where
     L: Language,

crates/formality-core/src/parse/parser.rs

@@ -158,7 +158,7 @@ where
 impl<'s, 't, T, L> Parser<'s, 't, T, L>
 where
     L: Language,
-    T: Debug + Clone + Eq + 'static,
+    T: Debug + Clone + Eq + 'static + Upcast<T>,
 {
     /// Shorthand to create a parser for a nonterminal with a single variant,
     /// parsed by the function `op`.
@@ -225,7 +225,7 @@ where
         Self::parse_variant(self, variant_name, variant_precedence, |p| {
             p.mark_as_cast_variant();
             let v: V = p.nonterminal()?;
-            Ok(v.upcast())
+            Ok(v)
         })
     }
 
@@ -234,12 +234,14 @@ where
     /// The precedence is part of how we resolve conflicts: if there are two successful parses with distinct precedence, higher precedence wins.
     /// The `op` is a closure that defines how the variant itself is parsed.
     /// The closure `op` will be invoked with an [`ActiveVariant`][] struct that has methods for consuming identifiers, numbers, keywords, etc.
-    pub fn parse_variant(
+    pub fn parse_variant<U>(
         &mut self,
         variant_name: &'static str,
         variant_precedence: Precedence,
-        op: impl FnOnce(&mut ActiveVariant<'s, 't, L>) -> Result<T, Set<ParseError<'t>>>,
-    ) {
+        op: impl FnOnce(&mut ActiveVariant<'s, 't, L>) -> Result<U, Set<ParseError<'t>>>,
+    ) where
+        U: Upcast<T>,
+    {
         let span = tracing::span!(
             tracing::Level::TRACE,
             "variant",
@@ -277,7 +279,7 @@ where
                     text: active_variant.current_text,
                     reductions: active_variant.reductions,
                     precedence: variant_precedence,
-                    value,
+                    value: value.upcast(),
                 });
                 tracing::trace!("success: {:?}", self.successes.last().unwrap());
             }

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

@@ -45,8 +45,7 @@ impl CoreParse<Rust> for RigidTy {
                 Ok(RigidTy {
                     name: RigidName::Ref(RefKind::Shared),
                     parameters: seq![lt.upcast(), ty.upcast()],
-                }
-                .upcast())
+                })
             });
 
             parser.parse_variant("RefMut", Precedence::default(), |p| {
@@ -125,7 +124,7 @@ impl CoreParse<Rust> for ConstData {
     fn parse<'t>(scope: &Scope<Rust>, text: &'t str) -> ParseResult<'t, Self> {
         Parser::multi_variant(scope, text, "ConstData", |parser| {
             parser.parse_variant("Variable", Precedence::default(), |p| {
-                p.variable_of_kind(ParameterKind::Const).upcast()
+                p.variable_of_kind(ParameterKind::Const)
             });
 
             parser.parse_variant_cast::<Bool>(Precedence::default());