feat: add range info to ast func params

viddrobnic · Jul 28, 2024 · fe85bd2 · fe85bd2
1 parent 9217d8b
commit fe85bd2
Show file tree

Hide file tree

Showing 6 changed files with 75 additions and 11 deletions.
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -85,10 +85,16 @@ pub struct For {
     pub body: Block,
 }
 
+#[derive(Debug, PartialEq, Clone)]
+pub struct FunctionParamter {
+    pub name: String,
+    pub range: Range,
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub struct FunctionLiteral {
     pub name: Option<String>,
-    pub parameters: Vec<String>,
+    pub parameters: Vec<FunctionParamter>,
     pub body: Block,
 }
 
@@ -324,7 +330,13 @@ impl Display for NodeValue {
                     .collect::<Vec<_>>()
                     .join("\n");
 
-                write!(f, "fn({}) {{{}}}", parameters.join(", "), body)
+                let parameters = parameters
+                    .iter()
+                    .map(|par| par.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                write!(f, "fn({}) {{{}}}", parameters, body)
             }
             NodeValue::FunctionCall(FunctionCall {
                 function,

diff --git a/parser/src/parser/mod.rs b/parser/src/parser/mod.rs
@@ -1,9 +1,8 @@
 use crate::{
-    ast::{self, InfixOperatorKind, NodeKind, PrefixOperatorKind},
+    ast::{self, FunctionParamter, InfixOperatorKind, NodeKind, PrefixOperatorKind},
     error::{Error, ErrorKind, Result},
     lexer::Lexer,
-    parser::precedence::Precedence,
-    parser::validate::*,
+    parser::{precedence::Precedence, validate::*},
     position::{Position, Range},
     token::{Token, TokenKind},
 };
@@ -569,7 +568,10 @@ impl Parser<'_> {
             TokenKind::RBracket,
             TokenKind::Comma,
             |_, token| match token.kind {
-                TokenKind::Ident(ident) => Ok(ident),
+                TokenKind::Ident(ident) => Ok(FunctionParamter {
+                    name: ident,
+                    range: token.range,
+                }),
                 _ => Err(Error {
                     kind: ErrorKind::InvalidFunctionParameter,
                     range: token.range,

diff --git a/parser/src/parser/test.rs b/parser/src/parser/test.rs
@@ -1135,7 +1135,13 @@ fn fn_literal() -> Result<()> {
             ast::Node {
                 value: ast::NodeValue::FunctionLiteral(ast::FunctionLiteral {
                     name: None,
-                    parameters: vec!["a".to_string()],
+                    parameters: vec![ast::FunctionParamter {
+                        name: "a".to_string(),
+                        range: Range {
+                            start: Position::new(0, 3),
+                            end: Position::new(0, 4),
+                        },
+                    }],
                     body: ast::Block {
                         nodes: vec![],
                         range: Range {
@@ -1155,7 +1161,23 @@ fn fn_literal() -> Result<()> {
             ast::Node {
                 value: ast::NodeValue::FunctionLiteral(ast::FunctionLiteral {
                     name: None,
-                    parameters: vec!["a".to_string(), "b".to_string()],
+                    // parameters: vec!["a".to_string(), "b".to_string()],
+                    parameters: vec![
+                        ast::FunctionParamter {
+                            name: "a".to_string(),
+                            range: Range {
+                                start: Position::new(0, 3),
+                                end: Position::new(0, 4),
+                            },
+                        },
+                        ast::FunctionParamter {
+                            name: "b".to_string(),
+                            range: Range {
+                                start: Position::new(0, 6),
+                                end: Position::new(0, 7),
+                            },
+                        },
+                    ],
                     body: ast::Block {
                         nodes: vec![],
                         range: Range {

diff --git a/parser/src/position.rs b/parser/src/position.rs
@@ -11,6 +11,26 @@ impl Position {
     pub fn new(line: usize, character: usize) -> Self {
         Self { line, character }
     }
+
+    pub fn cmp_range(&self, range: &Range) -> PositionOrdering {
+        if self.line < range.start.line {
+            return PositionOrdering::Before;
+        }
+
+        if self.line == range.start.line && self.character < range.start.character {
+            return PositionOrdering::Before;
+        }
+
+        if self.line > range.end.line {
+            return PositionOrdering::After;
+        }
+
+        if self.line == range.end.line && self.character >= range.end.character {
+            return PositionOrdering::After;
+        }
+
+        PositionOrdering::Inside
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
@@ -29,3 +49,10 @@ impl Range {
         Self { start, end }
     }
 }
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum PositionOrdering {
+    Before,
+    Inside,
+    After,
+}
diff --git a/runtime/src/compiler/mod.rs b/runtime/src/compiler/mod.rs
@@ -476,7 +476,7 @@ impl Compiler {
 
         // Define argument symbols
         for param in &fn_literal.parameters {
-            self.symbol_table.define(param.to_string());
+            self.symbol_table.define(param.name.to_string());
         }
 
         // Compile body

diff --git a/runtime/src/compiler/symbol_table.rs b/runtime/src/compiler/symbol_table.rs
@@ -103,7 +103,7 @@ impl SymbolTable {
         let symbol = self.resolve_at(idx - 1, name);
         match symbol {
             None => None,
-            Some(Symbol::Global(_)) => symbol,
+            Some(Symbol::Global(_)) | Some(Symbol::Builtin(_)) => symbol,
             Some(sym) => Some(self.define_free(idx, sym, name)),
         }
     }
@@ -120,7 +120,7 @@ impl SymbolTable {
 
 #[cfg(test)]
 mod test {
-    use crate::compiler::symbol_table::Symbol;
+    use crate::{builtin::Builtin, compiler::symbol_table::Symbol};
 
     use super::SymbolTable;
 
@@ -160,6 +160,7 @@ mod test {
         table.enter_scope();
 
         assert_eq!(table.resolve("a"), Some(Symbol::Global(0)));
+        assert_eq!(table.resolve("len"), Some(Symbol::Builtin(Builtin::Len)));
 
         table.define("b".to_string());
         assert_eq!(table.resolve("b"), Some(Symbol::Local(0)));