Merge pull request #3 from 0xpantera/refactor/core-types

Refactor core types

Author: 0xpantera

CHANGELOG.md

@@ -46,4 +46,13 @@
   - TACKY generation tests 
   - Assembly generation tests
   - Full pipeline integration tests
-- Test utilities and helper functions in Test.Common
+- Test utilities and helper functions in Test.Common
+
+## 0.2.2.0 -- 2024-11-25
+
+### Changed
+- Improved type definitions across compiler stages
+- Added record syntax for multi-field data constructors
+- Standardized naming conventions in core types
+- Simplified token type names
+- Made qualified imports consistent across modules

README.md

@@ -27,40 +27,53 @@ The compiler processes source code through the following stages:
 Programs are represented internally using a series of increasingly lower-level data structures:
 
 1. **Abstract Syntax Tree (AST)**:
-   ```haskell
-   data Program = Program FunctionDef
-   data FunctionDef = Function 
-     { name :: Text
-     , body :: Statement 
-     }
-   data Statement = Return Expr
-   data Expr = Constant Int | Unary UnaryOp Expr
-   data UnaryOp = Complement | Negate
-   ```
+  ```haskell
+  data Program = Program Function
+  data Function = Function 
+    { name :: Text
+    , body :: Statement 
+    }
+  data Statement = Return Expr
+  data Expr
+    = Constant { value :: Int }
+    | Unary { operator :: UnaryOp, operand :: Expr }
+  data UnaryOp = Complement | Negate
+  ```
 
 2. **TACKY IR**:
   ```haskell
-  data Program = Program FunctionDef
-  data FunctionDef = Function 
+  data Program = Program Function
+  data Function = Function 
     { name :: Text
     , body :: [Instruction]
     }
-  data Instruction 
-    = Return TackyVal
-    | Unary UnaryOp TackyVal TackyVal
-  data TackyVal = Constant Int | Var Text
+  data Instruction
+    = Return { value :: Val }
+    | Unary { operator :: UnaryOp, src :: Val, dst :: Val }
+  data Val = Constant Int | Var Text
+  data UnaryOp = Complement | Negate
   ```
 
 3. **Assembly AST**:
-   ```haskell
-   data Program = Program FunctionDef
-   data FunctionDef = Function 
-     { name :: Text
-     , instructions :: [Instruction]
-     }
-   data Instruction = Mov Operand Operand | Ret
-   data Operand = Imm Int | Register
-   ```
+  ```haskell
+  data Program = Program Function
+  data Function = Function 
+    { name :: Text
+    , instructions :: [Instruction]
+    }
+  data Instruction
+    = Mov { src :: Operand, dst :: Operand }
+    | Unary { operator :: UnaryOp, operand :: Operand }
+    | AllocateStack { bytes :: Int }
+    | Ret
+  data Operand 
+    = Imm Int 
+    | Register Reg
+    | Pseudo Text
+    | Stack Int
+  data UnaryOp = Neg | Not
+  data Reg = Ax | R10
+  ```
 
 
 ## Project Structure

halcyon.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               halcyon
-version:            0.2.1.0
+version:            0.2.2.0
 -- synopsis:
 -- description:
 license:            BSD-3-Clause

lib/Halcyon/Backend/Codegen.hs

@@ -4,7 +4,7 @@ module Halcyon.Backend.Codegen where
 import qualified Halcyon.Core.Assembly as Asm
 import qualified Halcyon.Core.Tacky as Tacky
 
-convertVal :: Tacky.TackyVal -> Asm.Operand
+convertVal :: Tacky.Val -> Asm.Operand
 convertVal (Tacky.Constant int)   = Asm.Imm int
 convertVal (Tacky.Var identifier) = Asm.Pseudo identifier
 
@@ -25,7 +25,7 @@ convertInstruction (Tacky.Unary op src dest) =
     asmOp   = convertOp op
   in [Asm.Mov asmSrc asmDest, Asm.Unary asmOp asmDest]
 
-convertFunction :: Tacky.FunctionDef -> Asm.FunctionDef
+convertFunction :: Tacky.Function -> Asm.Function
 convertFunction Tacky.Function{..} =
   let instructions = concatMap convertInstruction body
   in Asm.Function {name, instructions}

lib/Halcyon/Backend/Emit.hs

@@ -31,7 +31,7 @@ emitInstruction (Asm.Unary op operand) =
 emitInstruction Asm.Ret = 
   "\tmovq %rbp, %rsp\n\tpopq %rbp\n\tret\n"
 
-emitFunction :: Asm.FunctionDef -> Text
+emitFunction :: Asm.Function -> Text
 emitFunction Asm.Function{..} =
   let
     header = 

lib/Halcyon/Backend/ReplacePseudos.hs

@@ -63,7 +63,7 @@ replacePseudoInst = \case
   Asm.Ret -> pure Asm.Ret
   Asm.AllocateStack _ -> throwError UnexpectedAllocateStack
 
-replacePseudoFunc :: MonadReplace m => Asm.FunctionDef -> m Asm.FunctionDef
+replacePseudoFunc :: MonadReplace m => Asm.Function -> m Asm.Function
 replacePseudoFunc func@Asm.Function{..} = do
   fixedInstructions <- traverse replacePseudoInst instructions
   pure $ func { Asm.instructions = fixedInstructions }
@@ -85,7 +85,7 @@ fixupInstruction (Asm.Mov (Asm.Stack src) (Asm.Stack dst)) =
   , (Asm.Mov (Asm.Register Asm.R10) (Asm.Stack dst)) ]
 fixupInstruction other = [ other ]
 
-fixupFunction :: Asm.FunctionDef -> Int ->Asm.FunctionDef
+fixupFunction :: Asm.Function -> Int -> Asm.Function
 fixupFunction (Asm.Function{..}) lastStackSlot = Asm.Function 
   { name
   , instructions = 

lib/Halcyon/Core/Assembly.hs

@@ -2,20 +2,19 @@ module Halcyon.Core.Assembly where
 
 import Data.Text ( Text )
 
---TODO: use record syntax to name some of the product types
--- e.i. Mov Operand Operand -> Mov {src: Operand, dest: Operand}
-data Program = Program FunctionDef
+
+data Program = Program Function
   deriving (Eq, Show)
 
-data FunctionDef = Function 
+data Function = Function 
   { name         :: Text
   , instructions :: [Instruction]
   } deriving (Eq, Show)
 
-data Instruction 
-  = Mov Operand Operand
-  | Unary UnaryOp Operand
-  | AllocateStack Int
+data Instruction
+  = Mov { src :: Operand, dst :: Operand }
+  | Unary { operator :: UnaryOp, operand :: Operand }
+  | AllocateStack { bytes :: Int }
   | Ret
   deriving (Eq, Show)
 

lib/Halcyon/Core/Ast.hs

@@ -2,18 +2,20 @@ module Halcyon.Core.Ast where
 
 import Data.Text ( Text )
 
-data Program = Program FunctionDef
+data Program = Program Function
   deriving (Eq, Show)
 
-data FunctionDef = Function 
+data Function = Function 
   { name :: Text
   , body :: Statement
   } deriving (Eq, Show)
 
 data Statement = Return Expr
   deriving (Eq, Show)
 
-data Expr = Constant Int | Unary UnaryOp Expr
+data Expr
+  = Constant { value :: Int }
+  | Unary { operator :: UnaryOp, operand :: Expr }
   deriving (Eq, Show)
 
 data UnaryOp = Complement | Negate

lib/Halcyon/Core/Tacky.hs

@@ -2,20 +2,24 @@ module Halcyon.Core.Tacky where
 
 import Data.Text ( Text )
 
-data Program = Program FunctionDef
+data Program = Program Function
   deriving (Eq, Show)
 
-data FunctionDef = Function
+data Function = Function
   { name :: Text
   , body :: [Instruction]
   } deriving (Eq, Show)
 
-data Instruction 
-  = Return TackyVal
-  | Unary UnaryOp TackyVal TackyVal
+data Instruction
+  = Return { value :: Val }
+  | Unary 
+    { operator :: UnaryOp
+    , src :: Val
+    , dst :: Val 
+    }
   deriving (Eq, Show)
 
-data TackyVal
+data Val
   = Constant Int
   | Var Text
   deriving (Eq, Show)

lib/Halcyon/Core/TackyGen.hs

@@ -18,7 +18,7 @@ newtype TackyGenT m a = TackyGenT
 
 data TackyGenRes = TackyGenRes
   { instructions :: [Tacky.Instruction]
-  , resultVal :: Tacky.TackyVal 
+  , resultVal :: Tacky.Val 
   } deriving (Show, Eq)
 
 -- Helper to generate unique names
@@ -51,7 +51,7 @@ emitTackyForStmnt (Ast.Return e) = do
   TackyGenRes{..} <- emitTackyForExpr e
   pure $ TackyGenRes {..}
 
-emitTackyForFunc :: Monad m => Ast.FunctionDef -> TackyGenT m Tacky.FunctionDef
+emitTackyForFunc :: Monad m => Ast.Function -> TackyGenT m Tacky.Function
 emitTackyForFunc Ast.Function{..} = do
   TackyGenRes{..} <- emitTackyForStmnt body
   let finalInstrs = instructions ++ [Tacky.Return resultVal]