Feat: Implemented dict and list for build and updated IT.

Author: dylan-sutton-chavez

compiler/src/main.rs

@@ -29,7 +29,7 @@ fn main() {
 
     initialize_logger();
 
-    let source = "name: str = 'Dylan'\nage: int = 25\nmsg: str = f'User {name} is {age} years old'";
+    let source = "dict()\ndict(a=1)\n{'a': 1}\ndict({'a': 1})";
 
     let chunk = modules::parser::Parser::new(source, modules::lexer::lexer(source)).parse();
 

compiler/src/modules/parser.rs

@@ -49,10 +49,10 @@ use std::collections::HashMap;
 pub enum OpCode {
     LoadConst, LoadName, StoreName, Call, PopTop, ReturnValue,
     BuildString, CallPrint, CallLen, FormatValue, CallAbs, Minus,
-    CallStr, CallInt, CallRange, Phi, Add, CallType,
+    CallStr, CallInt, CallRange, Phi, CallChr, CallType,
     CallFloat, CallBool, CallRound, CallMin, CallMax, CallSum,
     CallSorted, CallEnumerate, CallZip, CallList, CallTuple, CallDict,
-    CallIsInstance, CallSet, CallInput, CallChr, CallOrd
+    CallIsInstance, CallSet, CallInput, CallOrd, BuildDict, BuildList
 }
 
 #[derive(Debug)] pub struct Instruction { pub opcode: OpCode, pub operand: u16 }
@@ -156,6 +156,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             }
         }
     }
+
     fn advance(&mut self) -> Token { self.tokens.next().unwrap() }
     fn at_end(&mut self) -> bool { self.peek().is_none() }
     fn lexeme(&self, t: &Token) -> &'src str { &self.source[t.start..t.end] }
@@ -182,10 +183,36 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             TokenType::None => self.emit_const(Value::None),
             TokenType::FstringStart => self.fstring(),
             TokenType::Minus => { self.expr(); self.chunk.emit(OpCode::Minus, 0); },
+            TokenType::Lbrace => self.dict_literal(),  // ← agrega
+            TokenType::Lsqb   => self.list_literal(),  // ← agrega
             _ => {}
         }
     }
 
+    fn dict_literal(&mut self) {
+        let mut pairs = 0u16;
+        while !matches!(self.peek(), Some(TokenType::Rbrace) | None) {
+            self.expr(); // clave
+            if matches!(self.peek(), Some(TokenType::Colon)) { self.advance(); }
+            self.expr(); // valor
+            pairs += 1;
+            if matches!(self.peek(), Some(TokenType::Comma)) { self.advance(); }
+        }
+        self.advance(); // consume '}'
+        self.chunk.emit(OpCode::BuildDict, pairs);
+    }
+
+    fn list_literal(&mut self) {
+        let mut count = 0u16;
+        while !matches!(self.peek(), Some(TokenType::Rsqb) | None) {
+            self.expr();
+            count += 1;
+            if matches!(self.peek(), Some(TokenType::Comma)) { self.advance(); }
+        }
+        self.advance(); // consume ']'
+        self.chunk.emit(OpCode::BuildList, count);
+    }
+
     fn parse_number(&mut self, raw: &str, kind: TokenType) {
         let s = raw.replace('_', "");
         if kind == TokenType::Float {
@@ -227,7 +254,21 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         self.advance();
         let mut argc = 0;
         while !matches!(self.peek(), Some(TokenType::Rpar) | None) {
-            self.expr(); argc += 1;
+            // kwarg: name=value → emite ("name", value)
+            if matches!(self.peek(), Some(TokenType::Name)) {
+                let t = self.advance();
+                if matches!(self.peek(), Some(TokenType::Equal)) {
+                    self.advance();
+                    let i = self.chunk.push_const(Value::Str(self.lexeme(&t).to_string()));
+                    self.chunk.emit(OpCode::LoadConst, i);
+                    self.expr();
+                } else {
+                    self.name(t); // expresión normal
+                }
+            } else {
+                self.expr();
+            }
+            argc += 1;
             if matches!(self.peek(), Some(TokenType::Comma)) { self.advance(); }
         }
         self.advance();

compiler/tests/cases/parser_cases.json

@@ -28,5 +28,11 @@
     ["Range(0, 4, 1)"],
     [],
     [["LoadConst",0], ["CallRange",1], ["PopTop",0], ["ReturnValue",0]]
+  ],
+  [
+    "dict()\ndict(a=1)\n{'a': 1}\ndict({'a': 1})",
+    ["a", "1", "a", "1", "a", "1"],
+    [],
+    [["CallDict",0], ["PopTop",0], ["LoadConst",0], ["LoadConst",1], ["CallDict",1], ["PopTop",0], ["LoadConst",2], ["LoadConst",3], ["BuildDict",1], ["PopTop",0], ["LoadConst",4], ["LoadConst",5], ["BuildDict",1], ["CallDict",1], ["PopTop",0], ["ReturnValue",0]]
   ]
 ]

documentation/implementation/syntax.md

@@ -50,7 +50,7 @@ x = 42
 
 FStrings parse from `FstringStart -> FstringMiddle -> FstringEnd` token sequence. Each `FstringMiddle` scanned for `{name}` expressions (`f"Hey, {name}."`).
 
-Supported: simple name {name} and binary addition {name + expr}.
+Supported: simple name `{name}` and binary addition `{name + expr}`.
 
 ## SSA Form