Improve inline syntax macro

crates/flux-desugar/src/desugar.rs

@@ -441,7 +441,11 @@ impl<'a, 'tcx> RustItemCtxt<'a, 'tcx> {
                 })
                 .try_collect_exhaust()?;
 
-            let ret = self.desugar_variant_ret(&variant_def.ret, &mut env)?;
+            let ret = if let Some(ret) = &variant_def.ret {
+                self.desugar_variant_ret(ret, &mut env)?
+            } else {
+                self.as_lift_cx().lift_variant_ret()
+            };
 
             Ok(fhir::VariantDef {
                 def_id: hir_variant.def_id,

crates/flux-desugar/src/desugar/gather.rs

@@ -148,7 +148,9 @@ impl RustItemCtxt<'_, '_> {
             self.gather_params_ty(None, ty, TypePos::Input, &mut env)?;
         }
 
-        self.gather_params_variant_ret(&variant_def.ret, &mut env)?;
+        if let Some(ret) = &variant_def.ret {
+            self.gather_params_variant_ret(ret, &mut env)?;
+        }
 
         self.check_param_uses(&mut env, |vis| vis.visit_variant(variant_def))?;
 

crates/flux-desugar/src/resolver.rs

@@ -157,7 +157,9 @@ impl<'a> ItemLikeResolver<'a> {
                 .fields
                 .iter()
                 .try_for_each_exhaust(|ty| self.resolve_ty(ty))?;
-            self.resolve_variant_ret(&variant_def.ret)?;
+            if let Some(ret) = &variant_def.ret {
+                self.resolve_variant_ret(ret)?;
+            }
         }
         Ok(())
     }

crates/flux-middle/src/fhir/lift.rs

@@ -364,9 +364,7 @@ impl<'a, 'tcx> LiftCtxt<'a, 'tcx> {
         variant: &hir::Variant,
     ) -> Result<fhir::VariantDef, ErrorGuaranteed> {
         let item = self.tcx.hir().expect_item(self.owner.def_id);
-        let hir::ItemKind::Enum(_, generics) = &item.kind else {
-            bug!("expected an enum or struct")
-        };
+        let hir::ItemKind::Enum(_, generics) = &item.kind else { bug!("expected an enum") };
 
         let fields = variant
             .data
@@ -375,6 +373,29 @@ impl<'a, 'tcx> LiftCtxt<'a, 'tcx> {
             .map(|field| self.lift_field_def(field))
             .try_collect_exhaust()?;
 
+        let ret = self.lift_variant_ret_inner(item, generics);
+
+        Ok(fhir::VariantDef {
+            def_id: variant.def_id,
+            params: vec![],
+            fields,
+            ret,
+            span: variant.span,
+            lifted: true,
+        })
+    }
+
+    pub fn lift_variant_ret(&mut self) -> fhir::VariantRet {
+        let item = self.tcx.hir().expect_item(self.owner.def_id);
+        let hir::ItemKind::Enum(_, generics) = &item.kind else { bug!("expected an enum") };
+        self.lift_variant_ret_inner(item, generics)
+    }
+
+    fn lift_variant_ret_inner(
+        &mut self,
+        item: &hir::Item,
+        generics: &hir::Generics,
+    ) -> fhir::VariantRet {
         let span = item.ident.span.to(generics.span);
         let path = fhir::Path {
             res: fhir::Res::SelfTyAlias { alias_to: self.owner.to_def_id(), is_trait_impl: false },
@@ -384,24 +405,15 @@ impl<'a, 'tcx> LiftCtxt<'a, 'tcx> {
             span,
         };
         let bty = fhir::BaseTy::from(fhir::QPath::Resolved(None, path));
-        let ret = fhir::VariantRet {
+        fhir::VariantRet {
             bty,
             idx: fhir::RefineArg::Record(
                 self.owner.to_def_id(),
                 List::empty(), // TODO:RJ: or should we use the generics and just make it T1,...Tn?
                 vec![],
                 generics.span.shrink_to_hi(),
             ),
-        };
-
-        Ok(fhir::VariantDef {
-            def_id: variant.def_id,
-            params: vec![],
-            fields,
-            ret,
-            span: variant.span,
-            lifted: true,
-        })
+        }
     }
 
     fn lift_ty(&mut self, ty: &hir::Ty) -> Result<fhir::Ty, ErrorGuaranteed> {

crates/flux-syntax/src/grammar.lalrpop

@@ -192,7 +192,7 @@ Async: surface::Async = {
 }
 
 pub Variant: surface::VariantDef = {
-    <lo:@L> <tys:Fields?> <ret:VariantRet> <hi:@R> => {
+    <lo:@L> <tys:Fields?> <ret:VariantRet?> <hi:@R> => {
         let fields = match tys {
             Some(fields) => fields,
             None => vec![],

crates/flux-syntax/src/surface.rs

@@ -120,7 +120,7 @@ impl EnumDef {
 #[derive(Debug)]
 pub struct VariantDef {
     pub fields: Vec<Ty>,
-    pub ret: VariantRet,
+    pub ret: Option<VariantRet>,
     pub node_id: NodeId,
     pub span: Span,
 }

crates/flux-syntax/src/surface/visit.rs

@@ -196,7 +196,9 @@ pub fn walk_enum_def<V: Visitor>(vis: &mut V, enum_def: &EnumDef) {
 
 pub fn walk_variant<V: Visitor>(vis: &mut V, variant: &VariantDef) {
     walk_list!(vis, visit_ty, &variant.fields);
-    vis.visit_variant_ret(&variant.ret);
+    if let Some(ret) = &variant.ret {
+        vis.visit_variant_ret(ret);
+    }
 }
 
 pub fn walk_variant_ret<V: Visitor>(vis: &mut V, ret: &VariantRet) {