clean up ty check stage

andogq · Sep 9, 2024 · eb4aef9 · eb4aef9
1 parent 2118e01
commit eb4aef9
Show file tree

Hide file tree

Showing 40 changed files with 154 additions and 191 deletions.
diff --git a/src/codegen/llvm/mod.rs b/src/codegen/llvm/mod.rs
@@ -6,7 +6,7 @@ use inkwell::{
     builder::Builder,
     context::Context,
     module::Module as LlvmModule,
-    types::{BasicType, BasicTypeEnum},
+    types::{BasicType as _, BasicTypeEnum},
     values::{BasicValue, FunctionValue, IntValue, PointerValue},
     IntPredicate,
 };
@@ -19,8 +19,8 @@ use crate::{
             BasicBlockIdx, BinaryOp, ConstantValue, Function, Terminator, Triple, TripleRef,
             UnaryOp, Value,
         },
-        ty::Ty,
     },
+    ty::Ty,
 };
 
 /// A single LLVM module.

diff --git a/src/compiler/function_manager.rs b/src/compiler/function_manager.rs
@@ -1,13 +1,11 @@
+use crate::ty::Ty;
 use std::collections::HashMap;
 
 use index_vec::IndexVec;
 
 use crate::{
-    repr::{
-        identifier::{FunctionIdx, ScopedBinding},
-        ty::Ty,
-    },
-    stage::type_check::FunctionSignature,
+    repr::identifier::{FunctionIdx, ScopedBinding},
+    ty::FunctionSignature,
 };
 
 use super::Symbol;

diff --git a/src/compiler/mod.rs b/src/compiler/mod.rs
@@ -7,7 +7,8 @@ use self::function_manager::*;
 use crate::{
     hir::SolveType,
     repr::ir,
-    stage::{self, parse::ParseError, type_check::TyError},
+    stage::{self, parse::ParseError},
+    ty::TyError,
 };
 
 /// A symbol represents an interned string.

diff --git a/src/hir/expression/array.rs b/src/hir/expression/array.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -70,7 +68,7 @@ impl SolveType for Array<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         // Type check each of the init items
         let init = self
             .init

diff --git a/src/hir/expression/assign.rs b/src/hir/expression/assign.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -58,7 +56,7 @@ impl SolveType for Assign<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         // Work out what type the variable has to be
         let (binding, ty) = state
             .resolve(self.binding)

diff --git a/src/hir/expression/block.rs b/src/hir/expression/block.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -66,7 +64,7 @@ impl SolveType for Block<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         // Enter a new scope
         let block_scope = state.enter();
 

diff --git a/src/hir/expression/boolean.rs b/src/hir/expression/boolean.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{Lexer, ParseError};
-
 use super::*;
 
 ast_node! {
@@ -52,7 +50,7 @@ impl SolveType for Boolean<UntypedAstMetadata> {
         self,
         _compiler: &mut crate::compiler::Compiler,
         _state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         Ok(Boolean {
             value: self.value,
             span: self.span,

diff --git a/src/hir/expression/call.rs b/src/hir/expression/call.rs
@@ -1,7 +1,3 @@
-use std::iter;
-
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -29,7 +25,7 @@ impl<M: AstMetadata> Parsable for Call<M> {
                 };
 
                 // Consume the args
-                let args = iter::from_fn(|| {
+                let args = std::iter::from_fn(|| {
                     match lexer.peek_token()? {
                         Token::RightParen => None,
                         Token::LeftParen | Token::Comma => {

diff --git a/src/hir/expression/cast.rs b/src/hir/expression/cast.rs
@@ -1,4 +1,4 @@
-use crate::stage::parse::{parse_ty, ParseError};
+use crate::ty::TySpanned;
 
 use super::*;
 
@@ -15,7 +15,7 @@ impl<M: AstMetadata> Parsable for Cast<M> {
     fn register(parser: &mut Parser) {
         assert!(parser.register_infix::<Expression<UntypedAstMetadata>>(
             Token::As,
-            |_, _, lexer, left| {
+            |parser, compiler, lexer, left| {
                 let as_span = match lexer.next_spanned().unwrap() {
                     (Token::As, span) => span,
                     (token, _) => {
@@ -28,12 +28,12 @@ impl<M: AstMetadata> Parsable for Cast<M> {
                 };
 
                 // Parse out type from right hand side
-                let (target_ty, target_ty_span) = parse_ty(lexer)?;
+                let ty: TySpanned = parser.parse(compiler, lexer, Precedence::Lowest)?;
 
                 Ok(Expression::Cast(Cast {
                     value: Box::new(left),
-                    target_ty,
-                    span: as_span.start..target_ty_span.end,
+                    target_ty: ty.ty,
+                    span: as_span.start..ty.span.end,
                     ty_info: None,
                 }))
             }
@@ -48,7 +48,7 @@ impl SolveType for Cast<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         let value = self.value.solve(compiler, state)?;
 
         // Make sure that the value can be cast to the desired type
@@ -87,6 +87,7 @@ mod test {
 
         // Helper parsers
         Integer::<UntypedAstMetadata>::register(&mut parser);
+        TySpanned::register(&mut parser);
 
         parser
     }

diff --git a/src/hir/expression/ident.rs b/src/hir/expression/ident.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::ParseError;
-
 use super::*;
 
 use std::hash::Hash;
@@ -47,7 +45,7 @@ impl SolveType for Ident<UntypedAstMetadata> {
         self,
         _compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         let (binding, ty) = state
             .resolve(self.binding)
             .ok_or(TyError::SymbolNotFound(self.binding))?;

diff --git a/src/hir/expression/if_else.rs b/src/hir/expression/if_else.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -75,7 +73,7 @@ impl SolveType for If<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         // Make sure the condition is correctly typed
         let condition = self.condition.solve(compiler, state)?;
         let condition_ty = condition.get_ty_info();

diff --git a/src/hir/expression/index.rs b/src/hir/expression/index.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -71,7 +69,7 @@ impl SolveType for Index<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         // Ensure the inner parts are correct
         let index = self.index.solve(compiler, state)?;
 

diff --git a/src/hir/expression/infix.rs b/src/hir/expression/infix.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{Lexer, ParseError, Precedence};
-
 use super::*;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]

diff --git a/src/hir/expression/integer.rs b/src/hir/expression/integer.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::ParseError;
-
 use super::*;
 
 ast_node! {

diff --git a/src/hir/expression/loop_block.rs b/src/hir/expression/loop_block.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {
@@ -53,7 +51,7 @@ impl SolveType for Loop<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, TyError> {
         // Type check the body
         let body = self.body.solve(compiler, state)?;
 

diff --git a/src/hir/expression/mod.rs b/src/hir/expression/mod.rs
@@ -116,7 +116,7 @@ impl SolveType for Expression<UntypedAstMetadata> {
         self,
         compiler: &mut crate::compiler::Compiler,
         state: &mut Self::State,
-    ) -> Result<Self::Typed, crate::stage::type_check::TyError> {
+    ) -> Result<Self::Typed, crate::ty::TyError> {
         Ok(match self {
             Expression::Infix(e) => Expression::Infix(e.solve(compiler, state)?),
             Expression::Integer(e) => Expression::Integer(e.solve(compiler, state)?),

diff --git a/src/hir/function.rs b/src/hir/function.rs
@@ -1,11 +1,4 @@
-use crate::{
-    ast_node,
-    repr::{ast::untyped::UntypedAstMetadata, ty::Ty},
-    stage::type_check::TyError,
-    util::scope::Scope,
-};
-
-use super::{expression::Block, SolveType};
+use super::*;
 
 ast_node! {
     Function<M> {

diff --git a/src/hir/mod.rs b/src/hir/mod.rs
@@ -7,11 +7,11 @@ use crate::{
     ast_node,
     compiler::Compiler,
     repr::{
-        ast::{typed::TyInfo, untyped::UntypedAstMetadata, AstMetadata},
+        ast::{untyped::UntypedAstMetadata, AstMetadata},
         token::Token,
-        ty::Ty,
     },
-    stage::{parse::parser::Parser, type_check::TyError},
+    stage::parse::{parser::Parser, Lexer, ParseError, Precedence},
+    ty::{Ty, TyError, TyInfo},
     util::{scope::Scope, span::Span},
 };
 

diff --git a/src/hir/program.rs b/src/hir/program.rs
@@ -1,10 +1,6 @@
-use crate::{
-    ast_node,
-    repr::{ast::untyped::UntypedAstMetadata, ty::Ty},
-    stage::type_check::{FunctionSignature, TyError},
-};
+use crate::ty::FunctionSignature;
 
-use super::{function::Function, SolveType};
+use super::*;
 
 ast_node! {
     Program<M> {

diff --git a/src/hir/statement/s_break.rs b/src/hir/statement/s_break.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::ParseError;
-
 use super::*;
 
 ast_node! {

diff --git a/src/hir/statement/s_continue.rs b/src/hir/statement/s_continue.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::ParseError;
-
 use super::*;
 
 ast_node! {

diff --git a/src/hir/statement/s_expression.rs b/src/hir/statement/s_expression.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::Precedence;
-
 use super::*;
 
 ast_node! {

diff --git a/src/hir/statement/s_let.rs b/src/hir/statement/s_let.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {

diff --git a/src/hir/statement/s_return.rs b/src/hir/statement/s_return.rs
@@ -1,5 +1,3 @@
-use crate::stage::parse::{ParseError, Precedence};
-
 use super::*;
 
 ast_node! {

diff --git a/src/lib.rs b/src/lib.rs
@@ -12,6 +12,7 @@ pub mod compiler;
 mod hir;
 pub mod repr;
 pub mod stage;
+mod ty;
 pub mod util;
 
 pub fn compile_and_run(source: &'static str, debug: bool) -> i64 {

diff --git a/src/repr/ast/typed.rs b/src/repr/ast/typed.rs
@@ -1,20 +1,12 @@
 use crate::{
     generate_ast,
-    repr::{
-        identifier::{FunctionIdx, ScopedBinding},
-        ty::Ty,
-    },
+    repr::identifier::{FunctionIdx, ScopedBinding},
+    ty::TyInfo,
     util::span::Span,
 };
 
 use super::AstMetadata;
 
-#[derive(Clone, Debug)]
-pub struct TyInfo {
-    pub ty: Ty,
-    pub return_ty: Option<Ty>,
-}
-
 pub struct TypedAstMetadata;
 impl AstMetadata for TypedAstMetadata {
     type FnIdentifier = FunctionIdx;

diff --git a/src/repr/ast/untyped.rs b/src/repr/ast/untyped.rs
@@ -1,4 +1,4 @@
-use crate::{compiler::Symbol, generate_ast, repr::ty::Ty, util::span::Span};
+use crate::{compiler::Symbol, generate_ast, ty::Ty, util::span::Span};
 
 use super::AstMetadata;
 

diff --git a/src/repr/ir/function.rs b/src/repr/ir/function.rs
@@ -4,7 +4,7 @@ use index_vec::IndexVec;
 
 use crate::{
     repr::identifier::{FunctionIdx, ScopedBinding},
-    stage::type_check::FunctionSignature,
+    ty::FunctionSignature,
 };
 
 use super::BasicBlock;

diff --git a/src/repr/mod.rs b/src/repr/mod.rs
@@ -2,4 +2,3 @@ pub mod ast;
 pub mod identifier;
 pub mod ir;
 pub mod token;
-pub mod ty;
diff --git a/src/repr/ty.rs b/src/repr/ty.rs