use new-type binding for identifiers

andogq · Jul 23, 2024 · d1f5a4d · d1f5a4d
1 parent fe7ef24
commit d1f5a4d
Show file tree

Hide file tree

Showing 29 changed files with 163 additions and 556 deletions.
diff --git a/src/compile_pass.rs b/src/compile_pass.rs
@@ -3,7 +3,12 @@ use std::collections::HashMap;
 use index_vec::IndexVec;
 
 use crate::{
-    repr::{ast::typed::Function, identifier::FunctionIdx, ir, ty::Ty},
+    repr::{
+        ast::typed::Function,
+        identifier::{FunctionIdx, ScopedBinding},
+        ir,
+        ty::Ty,
+    },
     stage::{
         lower_ir::{FunctionBuilder as FunctionBuilderTrait, IRCtx},
         parse::ParseCtx,
@@ -97,7 +102,7 @@ pub struct FunctionBuilder {
     basic_blocks: IndexVec<ir::BasicBlockIdx, ir::BasicBlock>,
     current_basic_block: ir::BasicBlockIdx,
 
-    scope: Vec<(Symbol, Ty)>,
+    scope: Vec<(ScopedBinding, Ty)>,
 }
 
 impl FunctionBuilderTrait for FunctionBuilder {
@@ -114,8 +119,8 @@ impl FunctionBuilderTrait for FunctionBuilder {
         }
     }
 
-    fn register_scoped(&mut self, symbol: Symbol, ty: Ty) {
-        self.scope.push((symbol, ty));
+    fn register_scoped(&mut self, ident: ScopedBinding, ty: Ty) {
+        self.scope.push((ident, ty));
     }
 
     fn add_triple(&mut self, triple: ir::Triple) -> ir::TripleRef {

diff --git a/src/repr/ast/base/expression/block.rs b/src/repr/ast/base/expression/block.rs
@@ -2,7 +2,7 @@ use super::*;
 use crate::ast_node;
 
 ast_node! {
-    typed struct Block<TyInfo, FnIdentifier> {
-        statements: Vec<Statement<TyInfo, FnIdentifier>>,
+    typed struct Block<TyInfo, FnIdentifier, IdentIdentifier> {
+        statements: Vec<Statement<TyInfo, FnIdentifier, IdentIdentifier>>,
     }
 }
diff --git a/src/repr/ast/base/expression/call.rs b/src/repr/ast/base/expression/call.rs
@@ -3,8 +3,8 @@ use crate::ast_node;
 use super::*;
 
 ast_node! {
-    typed struct Call<TyInfo, FnIdentifier> {
+    typed struct Call<TyInfo, FnIdentifier, IdentIdentifier> {
         name: FnIdentifier,
-        args: Vec<Expression<TyInfo, FnIdentifier>>,
+        args: Vec<Expression<TyInfo, FnIdentifier, IdentIdentifier>>,
     }
 }
diff --git a/src/repr/ast/base/expression/ident.rs b/src/repr/ast/base/expression/ident.rs
@@ -1,23 +1,23 @@
 use std::hash::Hash;
 
-use crate::{ast_node, util::symbol_map::interner_symbol_map::Symbol};
+use crate::ast_node;
 
 ast_node! {
-    typed struct Ident<TyInfo> {
-        name: Symbol,
+    typed struct Ident<TyInfo, IdentIdentifier> {
+        binding: IdentIdentifier,
     }
 }
 
-impl<TyInfo> Hash for Ident<TyInfo> {
+impl<TyInfo, IdentIdentifier: Hash> Hash for Ident<TyInfo, IdentIdentifier> {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
+        self.binding.hash(state);
     }
 }
 
-impl<TyInfo> PartialEq for Ident<TyInfo> {
+impl<TyInfo, IdentIdentifier: PartialEq> PartialEq for Ident<TyInfo, IdentIdentifier> {
     fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
+        self.binding == other.binding
     }
 }
 
-impl<TyInfo> Eq for Ident<TyInfo> {}
+impl<TyInfo, IdentIdentifier: Eq> Eq for Ident<TyInfo, IdentIdentifier> {}
diff --git a/src/repr/ast/base/expression/if_else.rs b/src/repr/ast/base/expression/if_else.rs
@@ -3,9 +3,9 @@ use crate::ast_node;
 use super::*;
 
 ast_node! {
-    typed struct If<TyInfo, FnIdentifier> {
-        condition: Box<Expression<TyInfo, FnIdentifier>>,
-        success: Block<TyInfo, FnIdentifier>,
-        otherwise: Option<Block<TyInfo, FnIdentifier>>,
+    typed struct If<TyInfo, FnIdentifier, IdentIdentifier> {
+        condition: Box<Expression<TyInfo, FnIdentifier, IdentIdentifier>>,
+        success: Block<TyInfo, FnIdentifier, IdentIdentifier>,
+        otherwise: Option<Block<TyInfo, FnIdentifier, IdentIdentifier>>,
     }
 }
diff --git a/src/repr/ast/base/expression/infix.rs b/src/repr/ast/base/expression/infix.rs
@@ -29,9 +29,9 @@ impl TryFrom<Token> for InfixOperation {
 }
 
 ast_node! {
-    typed struct Infix<TyInfo, FnIdentifier> {
-        left: Box<Expression<TyInfo, FnIdentifier>>,
+    typed struct Infix<TyInfo, FnIdentifier, IdentIdentifier> {
+        left: Box<Expression<TyInfo, FnIdentifier, IdentIdentifier>>,
         operation: InfixOperation,
-        right: Box<Expression<TyInfo, FnIdentifier>>,
+        right: Box<Expression<TyInfo, FnIdentifier, IdentIdentifier>>,
     }
 }
diff --git a/src/repr/ast/base/expression/mod.rs b/src/repr/ast/base/expression/mod.rs
@@ -16,34 +16,33 @@ pub use integer::*;
 
 use crate::{
     ast_node,
-    util::{
-        source::{Span, Spanned},
-        symbol_map::interner_symbol_map::Symbol,
-    },
+    util::source::{Span, Spanned},
 };
 
 use super::Statement;
 
 ast_node!(
-    enum Expression<TyInfo, FnIdentifier> {
-        Infix(Infix<TyInfo, FnIdentifier>),
+    enum Expression<TyInfo, FnIdentifier, IdentIdentifier> {
+        Infix(Infix<TyInfo, FnIdentifier, IdentIdentifier>),
         Integer(Integer<TyInfo>),
         Boolean(Boolean<TyInfo>),
-        Ident(Ident<TyInfo>),
-        Block(Block<TyInfo, FnIdentifier>),
-        If(If<TyInfo, FnIdentifier>),
-        Call(Call<TyInfo, FnIdentifier>),
+        Ident(Ident<TyInfo, IdentIdentifier>),
+        Block(Block<TyInfo, FnIdentifier, IdentIdentifier>),
+        If(If<TyInfo, FnIdentifier, IdentIdentifier>),
+        Call(Call<TyInfo, FnIdentifier, IdentIdentifier>),
     }
 );
 
-impl<TyInfo: Default, FnIdentifier> Expression<TyInfo, FnIdentifier> {
+impl<TyInfo: Default, FnIdentifier, IdentIdentifier>
+    Expression<TyInfo, FnIdentifier, IdentIdentifier>
+{
     pub fn infix(
-        left: Expression<TyInfo, FnIdentifier>,
+        left: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
         operation: InfixOperation,
-        right: Expression<TyInfo, FnIdentifier>,
+        right: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
     ) -> Self {
         let span = Spanned::span(&left).to(&right);
-        Self::Infix(Infix::<TyInfo, FnIdentifier>::new(
+        Self::Infix(Infix::<TyInfo, FnIdentifier, IdentIdentifier>::new(
             Box::new(left),
             operation,
             Box::new(right),
@@ -59,21 +58,26 @@ impl<TyInfo: Default, FnIdentifier> Expression<TyInfo, FnIdentifier> {
         Self::Boolean(Boolean::<TyInfo>::new(value, span))
     }
 
-    pub fn ident(name: Symbol, span: Span) -> Self {
-        Self::Ident(Ident::<TyInfo>::new(name, span))
+    pub fn ident(name: IdentIdentifier, span: Span) -> Self {
+        Self::Ident(Ident::<TyInfo, IdentIdentifier>::new(name, span))
     }
 
-    pub fn block(statements: Vec<Statement<TyInfo, FnIdentifier>>, span: Span) -> Self {
-        Self::Block(Block::<TyInfo, FnIdentifier>::new(statements, span))
+    pub fn block(
+        statements: Vec<Statement<TyInfo, FnIdentifier, IdentIdentifier>>,
+        span: Span,
+    ) -> Self {
+        Self::Block(Block::<TyInfo, FnIdentifier, IdentIdentifier>::new(
+            statements, span,
+        ))
     }
 
     pub fn _if(
-        condition: Expression<TyInfo, FnIdentifier>,
-        success: Block<TyInfo, FnIdentifier>,
-        otherwise: Option<Block<TyInfo, FnIdentifier>>,
+        condition: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
+        success: Block<TyInfo, FnIdentifier, IdentIdentifier>,
+        otherwise: Option<Block<TyInfo, FnIdentifier, IdentIdentifier>>,
         span: Span,
     ) -> Self {
-        Self::If(If::<TyInfo, FnIdentifier>::new(
+        Self::If(If::<TyInfo, FnIdentifier, IdentIdentifier>::new(
             Box::new(condition),
             success,
             otherwise,
@@ -83,7 +87,7 @@ impl<TyInfo: Default, FnIdentifier> Expression<TyInfo, FnIdentifier> {
 
     pub fn call(
         identifier: FnIdentifier,
-        args: Vec<Expression<TyInfo, FnIdentifier>>,
+        args: Vec<Expression<TyInfo, FnIdentifier, IdentIdentifier>>,
         span: Span,
     ) -> Self {
         Self::Call(Call::new(identifier, args, span))

diff --git a/src/repr/ast/base/function.rs b/src/repr/ast/base/function.rs
@@ -3,10 +3,10 @@ use crate::{ast_node, repr::ty::Ty, util::symbol_map::interner_symbol_map::Symbo
 use super::*;
 
 ast_node! {
-    struct Function<TyInfo, FnIdentifier> {
+    struct Function<TyInfo, FnIdentifier, IdentIdentifier> {
         name: FnIdentifier,
         parameters: Vec<(Symbol, Ty)>,
         return_ty: Ty,
-        body: Block<TyInfo, FnIdentifier>,
+        body: Block<TyInfo, FnIdentifier, IdentIdentifier>,
     }
 }
diff --git a/src/repr/ast/base/macros.rs b/src/repr/ast/base/macros.rs
@@ -76,25 +76,27 @@ macro_rules! ast_node {
 
 #[macro_export]
 macro_rules! generate_ast {
-    (TyInfo: $ty_info:ty, FnIdentifier: $fn_identifier:ty) => {
+    (TyInfo: $ty_info:ty, FnIdentifier: $fn_identifier:ty, IdentIdentifier: $ident_identifier:ty) => {
         use $crate::repr::ast::base as ast;
 
         // Re-export non-typed utilities
         pub use ast::InfixOperation;
 
-        pub type Block = ast::Block<$ty_info, $fn_identifier>;
+        pub type Block = ast::Block<$ty_info, $fn_identifier, $ident_identifier>;
         pub type Boolean = ast::Boolean<$ty_info>;
-        pub type Call = ast::Call<$ty_info, $fn_identifier>;
-        pub type Ident = ast::Ident<$ty_info>;
-        pub type If = ast::If<$ty_info, $fn_identifier>;
-        pub type Infix = ast::Infix<$ty_info, $fn_identifier>;
+        pub type Call = ast::Call<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type Ident = ast::Ident<$ty_info, $ident_identifier>;
+        pub type If = ast::If<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type Infix = ast::Infix<$ty_info, $fn_identifier, $ident_identifier>;
         pub type Integer = ast::Integer<$ty_info>;
-        pub type Expression = ast::Expression<$ty_info, $fn_identifier>;
-        pub type Function = ast::Function<$ty_info, $fn_identifier>;
-        pub type Program = ast::Program<$ty_info, $fn_identifier>;
-        pub type Statement = ast::Statement<$ty_info, $fn_identifier>;
-        pub type ReturnStatement = ast::ReturnStatement<$ty_info, $fn_identifier>;
-        pub type LetStatement = ast::LetStatement<$ty_info, $fn_identifier>;
-        pub type ExpressionStatement = ast::ExpressionStatement<$ty_info, $fn_identifier>;
+        pub type Expression = ast::Expression<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type Function = ast::Function<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type Program = ast::Program<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type Statement = ast::Statement<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type ReturnStatement =
+            ast::ReturnStatement<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type LetStatement = ast::LetStatement<$ty_info, $fn_identifier, $ident_identifier>;
+        pub type ExpressionStatement =
+            ast::ExpressionStatement<$ty_info, $fn_identifier, $ident_identifier>;
     };
 }
diff --git a/src/repr/ast/base/program.rs b/src/repr/ast/base/program.rs
@@ -3,9 +3,9 @@ use crate::{ast_node, util::symbol_map::interner_symbol_map::InternerSymbolMap};
 use super::*;
 
 ast_node! {
-    struct Program<TyInfo, FnIdentifier> {
-        functions: Vec<Function<TyInfo, FnIdentifier>>,
-        main: Function<TyInfo, FnIdentifier>,
+    struct Program<TyInfo, FnIdentifier, IdentIdentifier> {
+        functions: Vec<Function<TyInfo, FnIdentifier, IdentIdentifier>>,
+        main: Function<TyInfo, FnIdentifier, IdentIdentifier>,
         symbols: InternerSymbolMap,
     }
 }
diff --git a/src/repr/ast/base/statement.rs b/src/repr/ast/base/statement.rs
@@ -1,26 +1,35 @@
-use crate::{ast_node, util::source::Span, util::symbol_map::interner_symbol_map::Symbol};
+use crate::{ast_node, util::source::Span};
 
 use super::*;
 
 ast_node!(
-    enum Statement<TyInfo, FnIdentifier> {
-        Return(ReturnStatement<TyInfo, FnIdentifier>),
-        Let(LetStatement<TyInfo, FnIdentifier>),
-        Expression(ExpressionStatement<TyInfo, FnIdentifier>),
+    enum Statement<TyInfo, FnIdentifier, IdentIdentifier> {
+        Return(ReturnStatement<TyInfo, FnIdentifier, IdentIdentifier>),
+        Let(LetStatement<TyInfo, FnIdentifier, IdentIdentifier>),
+        Expression(ExpressionStatement<TyInfo, FnIdentifier, IdentIdentifier>),
     }
 );
 
-impl<TyInfo: Default, FnIdentifier> Statement<TyInfo, FnIdentifier> {
-    pub fn _return(expression: Expression<TyInfo, FnIdentifier>, span: Span) -> Self {
+impl<TyInfo: Default, FnIdentifier, IdentIdentifier>
+    Statement<TyInfo, FnIdentifier, IdentIdentifier>
+{
+    pub fn _return(
+        expression: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
+        span: Span,
+    ) -> Self {
         Self::Return(ReturnStatement::new(expression, span))
     }
 
-    pub fn _let(name: Symbol, value: Expression<TyInfo, FnIdentifier>, span: Span) -> Self {
+    pub fn _let(
+        name: IdentIdentifier,
+        value: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
+        span: Span,
+    ) -> Self {
         Self::Let(LetStatement::new(name, value, span))
     }
 
     pub fn expression(
-        expression: Expression<TyInfo, FnIdentifier>,
+        expression: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
         implicit_return: bool,
         span: Span,
     ) -> Self {
@@ -29,21 +38,21 @@ impl<TyInfo: Default, FnIdentifier> Statement<TyInfo, FnIdentifier> {
 }
 
 ast_node! {
-    typed struct ReturnStatement<TyInfo, FnIdentifier> {
-        value: Expression<TyInfo, FnIdentifier>,
+    typed struct ReturnStatement<TyInfo, FnIdentifier, IdentIdentifier> {
+        value: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
     }
 }
 
 ast_node! {
-    typed struct LetStatement<TyInfo, FnIdentifier> {
-        name: Symbol,
-        value: Expression<TyInfo, FnIdentifier>,
+    typed struct LetStatement<TyInfo, FnIdentifier, IdentIdentifier> {
+        binding: IdentIdentifier,
+        value: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
     }
 }
 
 ast_node! {
-    typed struct ExpressionStatement<TyInfo, FnIdentifier> {
-        expression: Expression<TyInfo, FnIdentifier>,
+    typed struct ExpressionStatement<TyInfo, FnIdentifier, IdentIdentifier> {
+        expression: Expression<TyInfo, FnIdentifier, IdentIdentifier>,
         implicit_return: bool,
     }
 }
diff --git a/src/repr/ast/typed.rs b/src/repr/ast/typed.rs
@@ -1,6 +1,6 @@
 use crate::{
     generate_ast,
-    repr::{identifier::FunctionIdx, ty::Ty},
+    repr::{identifier::*, ty::Ty},
 };
 
 #[derive(Clone, Debug)]
@@ -11,5 +11,6 @@ pub struct TyInfo {
 
 generate_ast! {
     TyInfo: TyInfo,
-    FnIdentifier: FunctionIdx
+    FnIdentifier: FunctionIdx,
+    IdentIdentifier: ScopedBinding
 }
diff --git a/src/repr/ast/untyped.rs b/src/repr/ast/untyped.rs
@@ -2,5 +2,6 @@ use crate::{generate_ast, repr::ty::Ty, util::symbol_map::interner_symbol_map::S
 
 generate_ast! {
     TyInfo: Option<Ty>,
-    FnIdentifier: Symbol
+    FnIdentifier: Symbol,
+    IdentIdentifier: Symbol
 }
diff --git a/src/repr/identifier/function.rs b/src/repr/identifier/function.rs
diff --git a/src/repr/identifier/mod.rs b/src/repr/identifier/mod.rs
@@ -1,3 +1,9 @@
-mod function;
+use index_vec::define_index_type;
 
-pub use function::FunctionIdx;
+define_index_type! {pub struct FunctionIdx = usize;}
+define_index_type! {pub struct ScopeIdx = usize;}
+define_index_type! {pub struct BindingIdx = usize;}
+
+/// A binding within a specific scope.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ScopedBinding(pub ScopeIdx, pub BindingIdx);