Resolve all compile errors.

ast-generator/src/build_fn/polymorphic_enum_loop_build_fn.rs

@@ -29,7 +29,7 @@ fn make_build(
     build: &PolymorphicEnumLoopRuleBuild,
 ) -> TokenStream {
     let rule_ident = format_ident!("{}", build.name());
-    let variant_type_ident = format_ident!("{}", build.name());
+    let variant_type_ident = format_ident!("{}", spec.name());
     let return_type_ident = format_ident!("{}", spec.kind());
     let variant_ident = format_ident!("{}", build.variant());
 
@@ -81,6 +81,12 @@ pub fn make_polymorphic_enum_loop_build_fn(spec: &PolymorphicEnumLoopBuildSpec)
     let pair_ident = format_ident!("{}", make_build_pair(spec.name()));
     let return_type_ident = format_ident!("{}", spec.kind());
 
+    let iter_expr = if spec.reverse() {
+        quote! { #pair_ident.into_inner().rev() }
+    } else {
+        quote! { #pair_ident.into_inner() }
+    };
+    
     let match_arms = spec
         .rules()
         .map(|rule| make_match_arm(spec, rule))
@@ -89,7 +95,7 @@ pub fn make_polymorphic_enum_loop_build_fn(spec: &PolymorphicEnumLoopBuildSpec)
     quote! {
         fn #build_fn_ident(#pair_ident: Pair<Rule>) -> #return_type_ident {
             let mut result: Option<#return_type_ident> = None;
-            for inner_pair in #pair_ident.into_inner() {
+            for inner_pair in #iter_expr {
                 match inner_pair.as_rule() {
                     #(#match_arms,)*
                     _ => unreachable!()

ast-generator/src/deserialize/polymorphic_enum_loop_spec.rs

@@ -1,4 +1,4 @@
-use crate::deserialize::util::{make_build_fn_name, unwrap_single_member_hash};
+use crate::deserialize::util::{get_as_bool, make_build_fn_name, unwrap_single_member_hash};
 use crate::spec::polymorphic_enum_loop_spec::{
     PolymorphicEnumLoopBuildSpec, PolymorphicEnumLoopChildUseCurrent, PolymorphicEnumLoopRule,
     PolymorphicEnumLoopRuleBuild, PolymorphicEnumLoopRuleBuildChild,
@@ -62,6 +62,8 @@ fn deserialize_rule(rule_name: &str, props: &Yaml) -> PolymorphicEnumLoopRule {
 
 pub fn deserialize_polymorphic_enum_loop(name: &str, props: &Yaml) -> PolymorphicEnumLoopBuildSpec {
     let kind = props["kind"].as_str().unwrap();
+    let reverse = get_as_bool(&props["reverse"]);
+    
     let rules = props["rules"]
         .as_vec()
         .unwrap()
@@ -73,5 +75,5 @@ pub fn deserialize_polymorphic_enum_loop(name: &str, props: &Yaml) -> Polymorphi
         .map(Box::new)
         .collect();
 
-    PolymorphicEnumLoopBuildSpec::new(name, kind, rules)
+    PolymorphicEnumLoopBuildSpec::new(name, kind, reverse, rules)
 }

ast-generator/src/deserialize/struct_spec.rs

@@ -38,7 +38,7 @@ fn deserialize_member_build(child_name: &str, rule: &str, props: &Yaml) -> Membe
         let kind = node_props["kind"].as_str().unwrap_or(rule);
         let with = node_props["with"]
             .as_str()
-            .map(ToString::to_string)
+            .map(|with| make_build_fn_name(with))
             .unwrap_or_else(|| make_build_fn_name(kind));
 
         let or_else = if get_as_bool(&node_props["or_else_default"]) {

ast-generator/src/spec/polymorphic_enum_loop_spec.rs

@@ -1,14 +1,16 @@
 pub struct PolymorphicEnumLoopBuildSpec {
     name: String,
     kind: String,
+    reverse: bool,
     rules: Vec<Box<PolymorphicEnumLoopRule>>,
 }
 
 impl PolymorphicEnumLoopBuildSpec {
-    pub fn new(name: &str, kind: &str, rules: Vec<Box<PolymorphicEnumLoopRule>>) -> Self {
+    pub fn new(name: &str, kind: &str, reverse: bool, rules: Vec<Box<PolymorphicEnumLoopRule>>) -> Self {
         Self {
             name: name.to_string(),
             kind: kind.to_string(),
+            reverse,
             rules,
         }
     }
@@ -21,6 +23,10 @@ impl PolymorphicEnumLoopBuildSpec {
         &self.kind
     }
     
+    pub fn reverse(&self) -> bool {
+        self.reverse
+    }
+
     pub fn rules(&self) -> impl Iterator<Item = &PolymorphicEnumLoopRule> {
         self.rules.iter().map(Box::as_ref)
     }

ast-generator/src/type_gen/struct_type.rs

@@ -23,8 +23,8 @@ fn make_vec_child_accessors(vec_child: &VecChild) -> TokenStream {
                     self.#child_ident.iter().map(Box::as_ref)
                 }
 
-                pub fn #child_ident_mut(&mut self) -> impl Iterator<Item = &mut child_type_ident> {
+                pub fn #child_ident_mut(&mut self) -> impl Iterator<Item = &mut #child_type_ident> {
-                    self.#child_ident.iter().map(Box::as_mut)
+                    self.#child_ident.iter_mut().map(Box::as_mut)
                 }
             }
         }
@@ -113,7 +113,7 @@ fn make_member_child_type_ident(member_child: &MemberChild) -> TokenStream {
     match member_child.build() {
         MemberChildBuild::Node(node_member_build) => {
             let type_ident = format_ident!("{}", node_member_build.kind());
-            quote! { #type_ident }
+            quote! { Box<#type_ident> }
         }
         MemberChildBuild::Boolean(_) => {
             quote! { bool }
@@ -125,9 +125,9 @@ fn make_member_child_annotated_member(member_child: &MemberChild) -> TokenStream
     let child_name_ident = format_ident!("{}", member_child.name());
     let type_ident = make_member_child_type_ident(member_child);
     let type_stream = if member_child.optional() {
-        quote! { Option<Box<#type_ident>> }
+        quote! { Option<#type_ident> }
     } else {
-        quote! { Box<#type_ident> }
+        quote! { #type_ident }
     };
 
     quote! {

src/parser/ast.schema.yaml

@@ -342,6 +342,8 @@ $defs:
         properties:
           kind:
             type: string
+          reverse:
+            type: boolean
           rules:
             type: array
             items:

src/parser/ast.yaml

@@ -863,6 +863,10 @@ ComparisonRhs:
       - expression:
           member:
             rule: ShiftExpression
+            build: 
+              node: 
+                kind: Expression
+                with: ShiftExpression
 ComparisonOperator:
   leaf_enum:
     rules:
@@ -899,6 +903,10 @@ ShiftRhs:
       - expression:
           member:
             rule: AdditiveExpression
+            build: 
+              node: 
+                kind: Expression
+                with: AdditiveExpression
 ShiftOperator:
   leaf_enum:
     rules:
@@ -930,6 +938,10 @@ AdditiveRhs:
       - expression:
           member:
             rule: MultiplicativeExpression
+            build: 
+              node: 
+                kind: Expression
+                with: MultiplicativeExpression
 AdditiveOperator:
   leaf_enum:
     rules:
@@ -961,6 +973,10 @@ MultiplicativeRhs:
       - expression:
           member:
             rule: PrefixExpression
+            build: 
+              node: 
+                kind: Expression
+                with: PrefixExpression
 MultiplicativeOperator:
   leaf_enum:
     rules:
@@ -970,17 +986,18 @@ MultiplicativeOperator:
 PrefixExpression:
   polymorphic_enum_loop_build:
     kind: Expression
+    reverse: true
     rules:
       - PrefixOperator:
           build:
             variant: Prefix
             children:
               - operator:
+                  on_each: 
+                    rule: PrefixOperator
+              - expression:
                   use_current: 
                     kind: Expression
-              - expression:
-                  on_each:
-                    rule: SuffixExpression
       - SuffixExpression:
           pass_through:
             kind: Expression
@@ -1008,7 +1025,7 @@ SuffixExpression:
                     kind: Expression
               - operator:
                   on_each:
-                    rule: SuffixExpression
+                    rule: SuffixOperator
 SuffixOperator:
   tree_enum:
     rules: