Auto gen pretty_print impls.

ast-generator/src/lib.rs

@@ -5,6 +5,7 @@ mod leaf_struct_build_fn;
 mod polymorphic_build_build_fn;
 mod polymorphic_build_fn;
 mod polymorphic_enum_build_fn;
+mod pretty_print;
 mod production_build_fn;
 mod spec;
 mod struct_build_fn;
@@ -17,6 +18,7 @@ use crate::leaf_struct_build_fn::make_leaf_struct_build_fn;
 use crate::polymorphic_build_build_fn::make_polymorphic_build_build_fn;
 use crate::polymorphic_build_fn::make_polymorphic_build_fn;
 use crate::polymorphic_enum_build_fn::make_polymorphic_enum_build_fn;
+use crate::pretty_print::make_pretty_print_impl;
 use crate::production_build_fn::make_production_build_fn;
 use crate::struct_build_fn::make_struct_build_fn;
 use crate::type_gen::make_type;
@@ -133,7 +135,7 @@ fn generate_build_file(build_specs: &[BuildSpec]) -> AstGeneratedFile {
         use pest::iterators::Pair;
         //noinspection RsUnusedImport
         use crate::ast::node::*;
-        
+
         #(#build_fns)*
     };
     AstGeneratedFile {
@@ -157,9 +159,30 @@ fn generate_node_file(build_specs: &[BuildSpec]) -> AstGeneratedFile {
     }
 }
 
+fn generate_pretty_print_file(build_specs: &[BuildSpec]) -> AstGeneratedFile {
+    let impls = build_specs
+        .iter()
+        .map(|build_spec| {
+            let stream = make_pretty_print_impl(build_spec);
+            debug_built_spec(build_spec, &stream);
+            stream
+        })
+        .collect::<Vec<_>>();
+    
+    let combined = quote! {
+        use crate::ast::node::*;
+        #(#impls)*
+    };
+    AstGeneratedFile {
+        name: String::from("pretty_print.rs"),
+        contents: token_stream_to_string(combined),
+    }
+}
+
 pub fn generate_files(build_specs: &[BuildSpec]) -> Vec<AstGeneratedFile> {
     vec![
         generate_build_file(build_specs),
         generate_node_file(build_specs),
+        generate_pretty_print_file(build_specs),
     ]
 }

ast-generator/src/pretty_print.rs

@@ -0,0 +1,256 @@
+use crate::spec::{
+    AlternativeChild, BuildSpec, EnumBuildSpec, EnumRuleChildKind, LeafEnumBuildSpec,
+    LeafStructBuildSpec, LeafStructMemberKind, MemberChildToBuild, PolymorphicBuildBuildSpec,
+    PolymorphicEnumBuildSpec, PolymorphicTypeBuildSpec, ProductionBuildSpec, StructBuildSpec,
+    StructChildSpec, VecChildToBuild,
+};
+use convert_case::{Case, Casing};
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+
+fn make_production_p2_impl(_spec: &ProductionBuildSpec) -> TokenStream {
+    quote! {}
+}
+
+fn make_polymorphic_enum_p2_impl(_spec: &PolymorphicEnumBuildSpec) -> TokenStream {
+    quote! {}
+}
+
+fn make_polymorphic_build_p2_impl(spec: &PolymorphicBuildBuildSpec) -> TokenStream {
+    let (_, build) = spec.primary_alternative();
+    let type_ident = format_ident!("{}", spec.name());
+    let name_str = spec.name();
+
+    let child_statements = build
+        .children()
+        .map(|child| match child {
+            AlternativeChild::Skip => None,
+            AlternativeChild::Build(build) => {
+                let child_ident = format_ident!("{}", build.name());
+                Some(quote! {
+                    self.#child_ident().pretty_print(writer)?
+                })
+            }
+        })
+        .filter(Option::is_some)
+        .map(Option::unwrap)
+        .collect::<Vec<TokenStream>>();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                writer.writeln_indented(#name_str);
+                writer.increase_indent();
+                #(#child_statements;)*
+                writer.decrease_indent();
+                Ok(())
+            }
+        }
+    }
+}
+
+fn make_polymorphic_type_p2_impl(spec: &PolymorphicTypeBuildSpec) -> TokenStream {
+    let type_ident = format_ident!("{}", spec.name());
+    let child_matchers = spec
+        .enum_members()
+        .map(|member| {
+            let enum_member_ident = format_ident!("{}", member.name());
+            let inner_name = format_ident!("{}", member.inner_kind().to_case(Case::Snake));
+            quote! {
+                #type_ident::#enum_member_ident(#inner_name) => #inner_name.pretty_print(writer)
+            }
+        })
+        .collect::<Vec<_>>();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                match self {
+                    #(#child_matchers,)*
+                }
+            }
+        }
+    }
+}
+
+fn make_leaf_enum_p2_impl(spec: &LeafEnumBuildSpec) -> TokenStream {
+    let type_ident = format_ident!("{}", spec.build());
+    let child_matchers = spec
+        .rules()
+        .map(|rule| {
+            let enum_variant_ident = format_ident!("{}", rule.rule());
+            let name_str = rule.rule();
+            quote! {
+                #type_ident::#enum_variant_ident => writer.writeln_indented(#name_str)
+            }
+        })
+        .collect::<Vec<_>>();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                match self {
+                    #(#child_matchers,)*
+                }
+            }
+        }
+    }
+}
+
+fn make_enum_p2_impl(spec: &EnumBuildSpec) -> TokenStream {
+    let type_ident = format_ident!("{}", spec.build());
+    let type_str = spec.build();
+
+    let child_matchers = spec
+        .rules()
+        .map(|rule| {
+            let enum_variant_ident = format_ident!("{}", rule.rule());
+            if let Some(child) = rule.child() {
+                match child.kind() {
+                    EnumRuleChildKind::Node(node_child) => {
+                        let child_name_ident =
+                            format_ident!("{}", node_child.build().to_case(Case::Snake));
+                        Some(quote! {
+                            #type_ident::#enum_variant_ident(#child_name_ident) => {
+                                #child_name_ident.pretty_print(writer)?;
+                            }
+                        })
+                    }
+                    _ => None,
+                }
+            } else {
+                let variant_str = rule.rule();
+                Some(quote! {
+                    #type_ident::#enum_variant_ident => writer.writeln_indented(#variant_str)?
+                })
+            }
+        })
+        .filter(Option::is_some)
+        .map(Option::unwrap)
+        .collect::<Vec<_>>();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                writer.writeln_indented(#type_str)?;
+                writer.increase_indent();
+                match self {
+                    #(#child_matchers,)*
+                    _ => {}
+                }
+                writer.decrease_indent();
+                Ok(())
+            }
+        }
+    }
+}
+
+fn make_leaf_struct_p2_impl(leaf_struct_build_spec: &LeafStructBuildSpec) -> TokenStream {
+    let type_ident = format_ident!("{}", leaf_struct_build_spec.build());
+    let member_formatters = leaf_struct_build_spec
+        .members()
+        .map(|member| match member.kind() {
+            LeafStructMemberKind::String => Some("{}"),
+        })
+        .filter(Option::is_some)
+        .map(Option::unwrap)
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    let format_string = format!("{}({})", leaf_struct_build_spec.build(), member_formatters);
+
+    let members = leaf_struct_build_spec
+        .members()
+        .map(|member| {
+            let member_ident = format_ident!("{}", member.name());
+            quote! {
+                self.#member_ident()
+            }
+        })
+        .collect::<Vec<_>>();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                writer.writeln_indented(&format!(#format_string, #(#members),*))
+            }
+        }
+    }
+}
+
+fn make_struct_p2_impl(struct_build_spec: &StructBuildSpec) -> TokenStream {
+    let child_print_statements = struct_build_spec
+        .children()
+        .map(|child| match child {
+            StructChildSpec::SkipChild(_) => None,
+            StructChildSpec::VecChild(vec_child) => match vec_child.build() {
+                VecChildToBuild::Node(_) => {
+                    let child_ident = format_ident!("{}", vec_child.name());
+                    Some(quote! {
+                        for child in self.#child_ident() {
+                            child.pretty_print(writer)?;
+                        }
+                    })
+                }
+                VecChildToBuild::String => None,
+            },
+            StructChildSpec::MemberChild(member_child) => match member_child.build() {
+                MemberChildToBuild::Node(node_member_child) => {
+                    let child_ident = format_ident!("{}", member_child.name());
+                    if node_member_child.optional() {
+                        Some(quote! {
+                            if let Some(child) = self.#child_ident() {
+                                child.pretty_print(writer)?;
+                            }
+                        })
+                    } else {
+                        Some(quote! {
+                            self.#child_ident().pretty_print(writer)?;
+                        })
+                    }
+                }
+                MemberChildToBuild::Boolean(boolean_member_child) => {
+                    let format_string = format!("{}({})", boolean_member_child.name(), "{}");
+                    let child_ident = format_ident!("{}", boolean_member_child.name());
+                    Some(quote! {
+                        writer.writeln_indented(&format!(#format_string, self.#child_ident()))?;
+                    })
+                }
+            },
+        })
+        .filter(Option::is_some)
+        .map(Option::unwrap)
+        .collect::<Vec<_>>();
+
+    let type_ident = format_ident!("{}", struct_build_spec.build());
+    let type_string = struct_build_spec.build();
+
+    quote! {
+        impl PrettyPrint for #type_ident {
+            fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
+                writer.writeln_indented(#type_string)?;
+                writer.increase_indent();
+                #(#child_print_statements)*
+                writer.decrease_indent();
+                Ok(())
+            }
+        }
+    }
+}
+
+pub fn make_pretty_print_impl(build_spec: &BuildSpec) -> TokenStream {
+    match build_spec {
+        BuildSpec::Struct(struct_spec) => make_struct_p2_impl(struct_spec),
+        BuildSpec::LeafStruct(leaf_struct) => make_leaf_struct_p2_impl(leaf_struct),
+        BuildSpec::Enum(enum_spec) => make_enum_p2_impl(enum_spec),
+        BuildSpec::LeafEnum(leaf_enum) => make_leaf_enum_p2_impl(leaf_enum),
+        BuildSpec::Polymorphic(polymorphic) => make_polymorphic_type_p2_impl(polymorphic),
+        BuildSpec::PolymorphicBuild(polymorphic_build) => {
+            make_polymorphic_build_p2_impl(polymorphic_build)
+        }
+        BuildSpec::PolymorphicEnum(polymorphic_enum) => {
+            make_polymorphic_enum_p2_impl(polymorphic_enum)
+        }
+        BuildSpec::Production(production) => make_production_p2_impl(production),
+    }
+}

ast-generator/src/spec.rs

@@ -512,6 +512,25 @@ impl PolymorphicBuildBuildSpec {
     pub fn alternatives(&self) -> impl Iterator<Item = &PolymorphicBuildAlternative> {
         self.alternatives.iter().map(Box::as_ref)
     }
+
+    pub fn primary_alternative(&self) -> (&AlternativeTest, &AlternativeBuild) {
+        let primary_build_alternative = self
+            .alternatives
+            .iter()
+            .find(|alternative| match alternative.action {
+                AlternativeAction::Build(_) => true,
+                _ => false,
+            })
+            .map(Box::as_ref)
+            .unwrap();
+        let alternative_build =
+            if let AlternativeAction::Build(build) = &primary_build_alternative.action {
+                build
+            } else {
+                unreachable!();
+            };
+        (primary_build_alternative.test(), alternative_build)
+    }
 }
 
 pub struct PolymorphicBuildAlternative {

ast-generator/src/type_gen.rs

@@ -44,7 +44,7 @@ fn make_polymorphic_build_type(build_spec: &PolymorphicBuildBuildSpec) -> TokenS
 
     let initializers = alternative_build
         .children()
-        .map(|build_child| match build_child {
+        .map(|child| match child {
             AlternativeChild::Skip => None,
             AlternativeChild::Build(build_child) => Some(format_ident!("{}", build_child.name())),
         })
@@ -52,6 +52,27 @@ fn make_polymorphic_build_type(build_spec: &PolymorphicBuildBuildSpec) -> TokenS
         .map(Option::unwrap)
         .collect::<Vec<_>>();
 
+    let accessors = alternative_build
+        .children()
+        .map(|child| match child {
+            AlternativeChild::Skip => None,
+            AlternativeChild::Build(build_child) => {
+                let child_ident = format_ident!("{}", build_child.name());
+                let child_ident_mut = format_ident!("{}_mut", build_child.name());
+                let child_type_ident = format_ident!("{}", build_child.kind());
+                Some(quote! {
+                    pub fn #child_ident(&self) -> &#child_type_ident {
+                        &self.#child_ident
+                    }
+
+                    pub fn #child_ident_mut(&mut self) -> &mut #child_type_ident {
+                        &mut self.#child_ident
+                    }
+                })
+            }
+        })
+        .collect::<Vec<_>>();
+
     let type_ident = format_ident!("{}", build_spec.name());
 
     quote! {
@@ -65,11 +86,13 @@ fn make_polymorphic_build_type(build_spec: &PolymorphicBuildBuildSpec) -> TokenS
                     #(#initializers),*
                 }
             }
+
+            #(#accessors)*
         }
     }
 }
 
-fn make_polymorphic_type(build_spec: &PolymorphicTypeBuildSpec) -> TokenStream {
+fn make_polymorphic_type_type(build_spec: &PolymorphicTypeBuildSpec) -> TokenStream {
     let members = build_spec
         .enum_members()
         .map(|enum_member| {
@@ -431,7 +454,7 @@ pub fn make_type(build_spec: &BuildSpec) -> Option<TokenStream> {
         }
         BuildSpec::Production(_) => None,
         BuildSpec::Polymorphic(polymorphic_build_spec) => {
-            Some(make_polymorphic_type(polymorphic_build_spec))
+            Some(make_polymorphic_type_type(polymorphic_build_spec))
         }
         BuildSpec::PolymorphicBuild(polymorphic_build_build_spec) => {
             Some(make_polymorphic_build_type(polymorphic_build_build_spec))

examples/forty_two.dm

@@ -0,0 +1,3 @@
+fn main()
+    println 42
+end

src/ast/mod.rs

@@ -45,7 +45,14 @@ pub mod node {
 }
 
 pub mod build {
+    use pest::iterators::Pairs;
+
     include!(concat!(env!("OUT_DIR"), "/src/ast/build.rs"));
+    
+    pub fn build_ast(parsed_pairs: &mut Pairs<Rule>) -> Box<CompilationUnit> {
+        let compilation_unit_pair = parsed_pairs.next().unwrap();
+        Box::new(build_compilation_unit(compilation_unit_pair))
+    }
 
     #[cfg(test)]
     mod build_tests {
@@ -124,3 +131,13 @@ pub mod build {
         }
     }
 }
+
+pub mod pretty_print {
+    use crate::util::indent_writer::IndentWriter;
+
+    pub trait PrettyPrint {
+        fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()>;
+    }
+    
+    include!(concat!(env!("OUT_DIR"), "/src/ast/pretty_print.rs"));
+}

src/bin/dmc/main.rs

@@ -1,58 +1,55 @@
 // mod name_analysis;
-// mod p3;
+mod p3;
 // mod unparse;
-//
+
-// use std::path::PathBuf;
+use std::path::PathBuf;
-//
+
 // use crate::name_analysis::name_analysis;
-// use crate::p3::pretty_print_parse;
+use crate::p3::pretty_print_parse;
 // use crate::unparse::unparse;
-// use clap::{Parser, Subcommand};
+use clap::{Parser, Subcommand};
-//
+
-// #[derive(Debug, Parser)]
+#[derive(Debug, Parser)]
-// #[command(name = "dmc")]
+#[command(name = "dmc")]
-// #[command(about = "Deimos Compiler", long_about = None)]
+#[command(about = "Deimos Compiler", long_about = None)]
-// struct Cli {
+struct Cli {
-//     #[command(subcommand)]
+    #[command(subcommand)]
-//     command: Commands,
+    command: Commands,
-// }
+}
-//
+
-// #[derive(Debug, Subcommand)]
+#[derive(Debug, Subcommand)]
-// enum Commands {
+enum Commands {
-//     #[command(arg_required_else_help = true)]
+    #[command(arg_required_else_help = true)]
-//     Unparse {
+    Unparse {
-//         paths: Vec<PathBuf>,
+        paths: Vec<PathBuf>,
-//     },
+    },
-//     P3 {
+    P3 {
-//         paths: Vec<PathBuf>,
+        paths: Vec<PathBuf>,
-//     },
+    },
-//     NameAnalysis {
+    NameAnalysis {
-//         paths: Vec<PathBuf>,
+        paths: Vec<PathBuf>,
-//     },
+    },
-// }
+}
-//
-// fn main() {
-//     let args = Cli::parse();
-//     match args.command {
-//         Commands::Unparse { paths } => {
-//             for path in paths {
-//                 unparse(&path);
-//             }
-//         }
-//         Commands::P3 { paths } => {
-//             for path in paths {
-//                 pretty_print_parse(&path)
-//             }
-//         }
-//         Commands::NameAnalysis { paths } => {
-//             let result = name_analysis(&paths);
-//             if let Err(e) = result {
-//                 eprintln!("{}", e)
-//             }
-//         }
-//     }
-// }
 
 fn main() {
-    panic!("TODO")
+    let args = Cli::parse();
+    match args.command {
+        // Commands::Unparse { paths } => {
+        //     for path in paths {
+        //         unparse(&path);
+        //     }
+        // }
+        Commands::P3 { paths } => {
+            for path in paths {
+                pretty_print_parse(&path)
+            }
+        }
+        // Commands::NameAnalysis { paths } => {
+        //     let result = name_analysis(&paths);
+        //     if let Err(e) = result {
+        //         eprintln!("{}", e)
+        //     }
+        // }
+        _ => todo!()
+    }
 }

src/bin/dmc/p3.rs

@@ -10,8 +10,7 @@ pub fn pretty_print_parse(path: &PathBuf) {
     let parse_result = DeimosParser::parse(Rule::CompilationUnit, &src);
     match parse_result {
         Ok(mut pairs) => {
-            let compilation_unit_pair = pairs.next().unwrap();
+            let compilation_unit = build_ast(&mut pairs);
-            let compilation_unit = build_ast(&path.display().to_string(), 0, compilation_unit_pair);
             let mut indent_writer = IndentWriter::new(0, "  ", Box::new(std::io::stdout()));
             compilation_unit
                 .pretty_print(&mut indent_writer)