isle tuple fields for structs and enum variants (#13335)

Author: Firestar99

cranelift/isle/docs/language-reference.md

@@ -1491,12 +1491,18 @@ The grammar accepted by the parser is as follows:
 
 <type-body> ::= "(" "primitive" <ident> ")"
               | "(" "enum" <enum-variant>* ")"
-              | "(" "struct" <variant-field>* ")"
+              | "(" "struct" <fields> ")"
 
 <enum-variant> ::= <ident>
-                 | "(" <ident> <variant-field>* ")"
+                 | "(" <ident> <fields> ")"
 
-<variant-field> ::= "(" <ident> <ty> ")"
+<fields> ::= <struct-fields> | <tuple-fields>
+
+<struct-fields> ::= <struct-field>*
+<struct-field> ::= "(" <ident> <ty> ")"
+
+<tuple-fields> ::= <tuple-field>*
+<tuple-field> ::= <ty>
 
 <ty> ::= <ident>
 

cranelift/isle/isle/isle_examples/run/tuple_variants.isle

@@ -0,0 +1,29 @@
+(type A (struct u32 u32))
+(type B (enum
+  (Ba (x u32))
+  (Bb u32 u32 u32)))
+(type D (enum
+  (Da A)
+  (Db B)
+  (Dc)))
+
+(type UnitStruct (struct))
+(type UninhabitedEnum (enum))
+
+(decl lower (D) B)
+
+(rule 0
+  (lower (D.Da (A x _)))
+  (B.Ba x))
+
+(rule 0
+  (lower (D.Db (B.Ba x)))
+  (B.Bb x x x))
+
+(rule 0
+  (lower (D.Db (B.Bb _ _ x)))
+  (B.Ba x))
+
+(rule 0
+  (lower (D.Dc))
+  (B.Ba 42))

cranelift/isle/isle/isle_examples/run/tuple_variants_main.rs

@@ -0,0 +1,31 @@
+extern crate alloc;
+extern crate core;
+
+mod tuple_variants;
+use tuple_variants::*;
+
+struct Context;
+impl tuple_variants::Context for Context {}
+
+fn main() {
+    assert!(matches!(
+        constructor_lower(&mut Context, &D::Da(A(1, 2))),
+        B::Ba { x: 1 }
+    ));
+    assert!(matches!(
+        constructor_lower(&mut Context, &D::Db(B::Ba { x: 6 })),
+        B::Bb(6, 6, 6)
+    ));
+    assert!(matches!(
+        constructor_lower(&mut Context, &D::Db(B::Bb(1, 2, 3))),
+        B::Ba { x: 3 }
+    ));
+    assert!(matches!(
+        constructor_lower(&mut Context, &D::Dc),
+        B::Ba { x: 42 }
+    ));
+
+    let _ = UnitStruct;
+    assert_eq!(size_of::<UnitStruct>(), 0);
+    assert_eq!(size_of::<UninhabitedEnum>(), 0);
+}

cranelift/isle/isle/src/ast.rs

@@ -46,25 +46,55 @@ pub struct Type {
 pub enum TypeValue {
     Primitive(Ident, Pos),
     Enum(Vec<Variant>, Pos),
-    Struct(Vec<Field>, Pos),
+    Struct(Fields, Pos),
 }
 
 /// One variant of an enum type.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Variant {
     pub name: Ident,
-    pub fields: Vec<Field>,
+    pub fields: Fields,
     pub pos: Pos,
 }
 
-/// One field of an enum variant.
+/// The fields of a struct or enum variant, formatted as a struct or tuple.
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub struct Field {
+pub enum Fields {
+    Unit,
+    Struct(StructFields),
+    Tuple(TupleFields),
+}
+
+/// A List of named fields of a struct.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct StructFields {
+    pub fields: Vec<StructField>,
+    pub pos: Pos,
+}
+
+/// One named field of a struct or enum variant.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct StructField {
     pub name: Ident,
     pub ty: Ident,
     pub pos: Pos,
 }
 
+/// A List of unnamed fields of a tuple.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TupleFields {
+    pub fields: Vec<TupleField>,
+    pub pos: Pos,
+}
+
+/// One unnamed field of a tuple.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TupleField {
+    pub index: usize,
+    pub ty: Ident,
+    pub pos: Pos,
+}
+
 /// A declaration of a term with its argument and return types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Decl {

cranelift/isle/isle/src/codegen.rs

@@ -2,12 +2,13 @@
 
 use crate::files::Files;
 use crate::sema::{
-    BuiltinType, ExternalSig, Field, IntType, ReturnKind, Term, TermEnv, TermId, Type, TypeEnv,
+    BuiltinType, ExternalSig, Fields, IntType, ReturnKind, Term, TermEnv, TermId, Type, TypeEnv,
     TypeId,
 };
 use crate::serialize::{Block, ControlFlow, EvalStep, MatchArm};
 use crate::stablemapset::StableSet;
 use crate::trie_again::{Binding, BindingId, Constraint, RuleSet};
+use std::borrow::Cow;
 use std::fmt::Write;
 use std::slice::Iter;
 use std::sync::Arc;
@@ -412,7 +413,7 @@ impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
 
                     // Generate the `derive`s.
                     let debug_derive = if is_nodebug { "" } else { ", Debug" };
-                    if variants.iter().all(|v| v.fields.is_empty()) {
+                    if variants.iter().all(|v| v.fields == Fields::Unit) {
                         writeln!(code, "#[derive(Copy, Clone, PartialEq, Eq{debug_derive})]")
                             .unwrap();
                     } else {
@@ -422,18 +423,10 @@ impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
                     writeln!(code, "pub enum {name} {{").unwrap();
                     for variant in variants {
                         let name = &self.typeenv.syms[variant.name.index()];
-                        if variant.fields.is_empty() {
-                            writeln!(code, "    {name},").unwrap();
-                        } else {
-                            writeln!(code, "    {name} {{").unwrap();
-                            for field in &variant.fields {
-                                let name = &self.typeenv.syms[field.name.index()];
-                                let ty_name =
-                                    self.typeenv.types[field.ty.index()].name(self.typeenv);
-                                writeln!(code, "        {name}: {ty_name},").unwrap();
-                            }
-                            writeln!(code, "    }},").unwrap();
-                        }
+                        write!(code, "    {name}").unwrap();
+                        self.generate_fields(&mut *code, &variant.fields, "    ", false)
+                            .unwrap();
+                        writeln!(code, ",").unwrap();
                     }
                     writeln!(code, "}}").unwrap();
                 }
@@ -456,26 +449,60 @@ impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
 
                     // Generate the `derive`s.
                     let debug_derive = if is_nodebug { "" } else { ", Debug" };
-                    if fields.is_empty() {
-                        writeln!(code, "#[derive(Copy, Clone, PartialEq, Eq{debug_derive})]")
-                            .unwrap();
-                        writeln!(code, "pub struct {name};").unwrap();
-                    } else {
-                        writeln!(code, "#[derive(Clone{debug_derive})]").unwrap();
-                        writeln!(code, "pub struct {name} {{").unwrap();
-                        for field in fields {
-                            let name = &self.typeenv.syms[field.name.index()];
-                            let ty_name = self.typeenv.types[field.ty.index()].name(self.typeenv);
-                            writeln!(code, "    pub {name}: {ty_name},").unwrap();
+                    match fields {
+                        Fields::Unit => {
+                            writeln!(code, "#[derive(Copy, Clone, PartialEq, Eq{debug_derive})]")
+                                .unwrap();
+                            writeln!(code, "pub struct {name};").unwrap();
+                        }
+                        Fields::Tuple(_) | Fields::Struct(_) => {
+                            writeln!(code, "#[derive(Clone{debug_derive})]").unwrap();
+                            write!(code, "pub struct {name}").unwrap();
+                            self.generate_fields(&mut *code, &fields, "", true).unwrap();
+                            if matches!(fields, Fields::Tuple(_)) {
+                                write!(code, ";").unwrap();
+                            }
                         }
-                        writeln!(code, "}}").unwrap();
                     }
                 }
                 _ => {}
             }
         }
     }
 
+    fn generate_fields(
+        &self,
+        code: &mut String,
+        fields: &Fields,
+        pad: &str,
+        allow_pub: bool,
+    ) -> std::fmt::Result {
+        let _pub = if allow_pub { "pub " } else { "" };
+        match fields {
+            Fields::Unit => Ok(()),
+            Fields::Struct(fields) => {
+                writeln!(code, " {{")?;
+                for field in &fields.fields {
+                    let name = &self.typeenv.syms[field.name.index()];
+                    let ty_name = self.typeenv.types[field.ty.index()].name(self.typeenv);
+                    writeln!(code, "{pad}    {_pub}{name}: {ty_name},")?;
+                }
+                write!(code, "{pad}}}")
+            }
+            Fields::Tuple(fields) => {
+                write!(code, "(")?;
+                for (i, field) in fields.fields.iter().enumerate() {
+                    let ty_name = self.typeenv.types[field.ty.index()].name(self.typeenv);
+                    write!(code, "{_pub}{ty_name}")?;
+                    if i < fields.fields.len() - 1 {
+                        write!(code, ", ")?;
+                    }
+                }
+                write!(code, ")")
+            }
+        }
+    }
+
     fn type_name(&self, typeid: TypeId, by_ref: bool) -> String {
         match self.typeenv.types[typeid.index()] {
             Type::Builtin(bt) => String::from(bt.name()),
@@ -926,17 +953,19 @@ impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
 
         let extract_fields = |ctx: &mut BodyContext<W>,
                               field_bindings: &[BindingId],
-                              type_fields: &[Field]|
+                              fields: &Fields|
          -> std::fmt::Result {
             if !field_bindings.is_empty() {
                 ctx.begin_block()?;
-                for (field, value) in type_fields.iter().zip(field_bindings.iter()) {
-                    write!(
-                        ctx.out,
-                        "{}{}: ",
-                        &ctx.indent,
-                        &self.typeenv.syms[field.name.index()],
-                    )?;
+                for (i, value) in field_bindings.iter().enumerate() {
+                    let field_name = match fields {
+                        Fields::Unit => panic!(),
+                        Fields::Struct(fields) => {
+                            Cow::Borrowed(&self.typeenv.syms[fields.fields[i].name.index()])
+                        }
+                        Fields::Tuple(_) => Cow::Owned(format!("{i}")),
+                    };
+                    write!(ctx.out, "{}{field_name}: ", &ctx.indent)?;
                     self.emit_expr(ctx, *value)?;
                     if ctx.is_ref.contains(value) {
                         write!(ctx.out, ".clone()")?;
@@ -1095,20 +1124,24 @@ impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
         &self,
         ctx: &mut BodyContext<W>,
         bindings: &[Option<BindingId>],
-        fields: &[Field],
+        fields: &Fields,
     ) -> std::fmt::Result {
         if !bindings.is_empty() {
             ctx.begin_block()?;
             let mut skipped_some = false;
-            for (&binding, field) in bindings.iter().zip(fields.iter()) {
+            for (i, &binding) in bindings.iter().enumerate() {
                 if let Some(binding) = binding {
-                    write!(
-                        ctx.out,
-                        "{}{}: ",
-                        &ctx.indent,
-                        &self.typeenv.syms[field.name.index()]
-                    )?;
-                    let (is_ref, _) = self.ty(field.ty);
+                    let (field_name, field_ty) = match fields {
+                        Fields::Unit => panic!(),
+                        Fields::Struct(fields) => {
+                            let field = &fields.fields[i];
+                            let name = &self.typeenv.syms[field.name.index()];
+                            (Cow::Borrowed(name), field.ty)
+                        }
+                        Fields::Tuple(fields) => (Cow::Owned(format!("{i}")), fields.fields[i].ty),
+                    };
+                    write!(ctx.out, "{}{field_name}: ", &ctx.indent)?;
+                    let (is_ref, _) = self.ty(field_ty);
                     if is_ref {
                         ctx.set_ref(binding, true);
                         write!(ctx.out, "ref ")?;