feat(hir): hir definitions and lowerer implement

Author: KeqingMoe

Cargo.lock

@@ -12,5 +12,6 @@ locale = { path = "../locale" }
 diag = { path = "../diag" }
 lexer = { path = "../lexer" }
 parser = { path = "../parser" }
+lowerer = { path = "../lowerer" }
 anstream = "0.6.21"
 unicode-width = "0.2.2"

autofront/Cargo.toml

@@ -17,6 +17,7 @@ pub enum Command {
    Lex(DebugSubcommand),
    Tt(DebugSubcommand),
    Parse(DebugSubcommand),
+   Hir(DebugSubcommand),
 }
 
 #[derive(Debug, Clone)]

autofront/src/cli/cmd.rs

@@ -9,6 +9,7 @@ pub fn print_help(topic: Option<&str>) -> Result<(), CliError> {
       Some("lex") => print_lex_help(),
       Some("tt") => print_tt_help(),
       Some("parse") => print_parse_help(),
+      Some("codegen") => print_codegen_help(),
       Some(cmd) => {
          return Err(CliError::UnknownCommand(cmd.to_string()));
       }
@@ -39,3 +40,7 @@ fn print_tt_help() {
 fn print_parse_help() {
    anstream::println!("{}", tr!(cli_help_parse));
 }
+
+fn print_codegen_help() {
+   anstream::println!("{}", tr!(cli_help_codegen));
+}

autofront/src/cli/help.rs

@@ -57,7 +57,7 @@ pub fn parse_args(args: &[String]) -> Result<Command> {
             Some(topic) => {
                let topic = topic.clone();
                match topic.as_str() {
-                  "help" | "version" | "lex" | "tt" | "parse" => Some(topic),
+                  "help" | "version" | "lex" | "tt" | "parse" | "codegen" => Some(topic),
                   _ => Err(CliError::UnknownCommand(topic))?,
                }
             }
@@ -71,6 +71,7 @@ pub fn parse_args(args: &[String]) -> Result<Command> {
       "lex" => Ok(Command::Lex(DebugSubcommand::parse(args)?)),
       "tt" => Ok(Command::Tt(DebugSubcommand::parse(args)?)),
       "parse" => Ok(Command::Parse(DebugSubcommand::parse(args)?)),
+      "hir" => Ok(Command::Hir(DebugSubcommand::parse(args)?)),
 
       other => Err(CliError::UnknownCommand(other.into())),
    }

autofront/src/cli/parser.rs

@@ -1,4 +1,5 @@
 use anstream::StripStream;
+use lowerer::lower;
 use std::{
    env::args,
    error::Error,
@@ -12,6 +13,8 @@ use unicode_width::UnicodeWidthStr;
 use crate::cli::{Command, DebugSubcommand, parse_args, print_help};
 use common::source::Source;
 use diag::{DiagPrinter, DiagSink};
+// use hir::*;
+// use ast2hir::lower_ast;
 use lexer::{lex, parse_token_tree};
 use locale::tr;
 use parser::parse;
@@ -124,6 +127,31 @@ impl Driver {
       Ok(())
    }
 
+   fn hir(&mut self, args: DebugSubcommand) -> Result<(), Box<dyn Error>> {
+      let DebugSubcommand {
+         file,
+         output,
+         show_recovery,
+      } = args;
+
+      let mut sink = DiagSink::default();
+      let src = self.load(file)?;
+
+      let tokens = lex(&src, &mut sink);
+      let ts = parse_token_tree(&tokens, &mut sink);
+      let ast = parse(&ts, &mut sink);
+      let hir = lower(&ast, &mut sink);
+
+      let printer = DiagPrinter::new(&src);
+      printer.print(sink, show_recovery)?;
+
+      let output = output.unwrap_or_else(|| format!("{}.out", src.file));
+      let out = get_out!(Some(output));
+      write!(out, "{hir:#?}")?;
+
+      Ok(())
+   }
+
    fn drive(mut self) -> Result<(), Box<dyn Error>> {
       use Command::*;
 
@@ -137,6 +165,7 @@ impl Driver {
          Lex(args) => self.lex(args)?,
          Tt(args) => self.tt(args)?,
          Parse(args) => self.parse(args)?,
+         Hir(args) => self.hir(args)?,
       }
 
       Ok(())

autofront/src/driver.rs

@@ -5,3 +5,6 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+common = { path = "../common" }
+bimap = "0.6.3"
+num-bigint = "0.4.6"

hir/Cargo.toml

@@ -0,0 +1,35 @@
+use std::ops::{Add, AddAssign};
+
+macro_rules! define_id {
+   ($id:ident) => {
+      #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+      pub struct $id(usize);
+
+      impl $id {
+         pub fn new(value: usize) -> Self {
+            Self(value)
+         }
+
+         pub fn as_usize(self) -> usize {
+            self.0
+         }
+      }
+
+      impl Add<usize> for $id {
+         type Output = Self;
+         fn add(self, rhs: usize) -> Self::Output {
+            Self(self.0 + rhs)
+         }
+      }
+
+      impl AddAssign<usize> for $id {
+         fn add_assign(&mut self, rhs: usize) {
+            self.0 += rhs
+         }
+      }
+   };
+}
+
+define_id!(SymId);
+
+define_id!(DestId);

hir/src/id.rs

@@ -0,0 +1,17 @@
+pub mod id;
+pub mod node;
+pub mod print;
+
+use common::span::Span;
+pub use {id::*, node::*, print::*};
+
+#[derive(Debug, Clone)]
+pub struct Ident {
+   pub name: String,
+   pub span: Span,
+}
+
+#[derive(Clone)]
+pub struct Hir {
+   pub items: Vec<Item>,
+}

hir/src/lib.rs

@@ -0,0 +1,84 @@
+pub mod constant;
+pub mod expr;
+pub mod ty;
+
+pub use {constant::*, expr::*, ty::*};
+
+use crate::{Ident, SymId};
+use common::span::Span;
+
+#[derive(Debug, Clone)]
+pub struct Item {
+   pub kind: ItemKind,
+   pub span: Span,
+}
+
+#[derive(Debug, Clone)]
+pub enum ItemKind {
+   FnDef(FnDef),
+   TyDef(TyDef),
+   Error,
+}
+
+#[derive(Debug, Clone)]
+pub struct FnDef {
+   pub sym_id: SymId,
+   pub name: Option<Ident>,
+   pub side_effect: bool,
+   pub params: Vec<Param>,
+   pub ret: Box<Ty>,
+   pub body: Body,
+}
+
+#[derive(Debug, Clone)]
+pub struct Body {
+   pub kind: BodyKind,
+   pub span: Span,
+}
+
+#[derive(Debug, Clone)]
+pub enum BodyKind {
+   Expr(Box<Expr>),
+   CFfi(String),
+   Error,
+}
+
+#[derive(Debug, Clone)]
+pub struct TyDef {
+   pub sym_id: SymId,
+   pub name: Option<Ident>,
+   pub ty: Box<Ty>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Param {
+   pub sym_id: SymId,
+   pub mutable: bool,
+   pub name: Ident,
+   pub ty: Box<Ty>,
+   pub span: Span,
+}
+
+#[derive(Debug, Clone)]
+pub struct Stmt {
+   pub kind: StmtKind,
+   pub span: Span,
+}
+
+#[derive(Debug, Clone)]
+pub enum StmtKind {
+   LocalDef(LocalDef),
+   Item(Item),
+   Expr(Box<Expr>),
+   Error,
+}
+
+#[derive(Debug, Clone)]
+pub struct LocalDef {
+   pub sym_id: SymId,
+   pub mutable: bool,
+   pub name: Option<Ident>,
+   pub ty: Box<Ty>,
+   pub init: Option<Box<Expr>>,
+   pub span: Span,
+}