🅾️ typechecker

ndc_bin/src/docs.rs

@@ -18,8 +18,7 @@ pub fn docs(query: Option<&str>) -> anyhow::Result<()> {
 
     let matched_functions = functions
         .into_iter()
-        .flat_map(|x| x.implementations().collect::<Vec<_>>())
-        .filter(|(_, func)| {
+        .filter(|func| {
             if let Some(query) = query {
                 string_match(query, func.name())
             } else {
@@ -28,7 +27,7 @@ pub fn docs(query: Option<&str>) -> anyhow::Result<()> {
         })
         .collect::<Vec<_>>()
         .tap_mut(|list| {
-            list.sort_by(|(_, l), (_, r)| {
+            list.sort_by(|l, r| {
                 if let Some(query) = query {
                     normalized_damerau_levenshtein(l.name(), query)
                         .partial_cmp(&normalized_damerau_levenshtein(r.name(), query))
@@ -46,31 +45,38 @@ pub fn docs(query: Option<&str>) -> anyhow::Result<()> {
     skin.headers[1].align = Alignment::Left;
     skin.headers[2].align = Alignment::Left;
 
-    for (type_sig, function) in matched_functions {
+    for function in matched_functions {
         let mut signature = String::new();
+        let type_sig = function.type_signature();
         match type_sig {
             TypeSignature::Variadic => {
-                writeln!(signature, "(*args**)")?;
+                write!(signature, "(*args**)")?;
             }
             TypeSignature::Exact(params) => {
                 write!(signature, "(")?;
                 let mut param_iter = params.iter().peekable();
                 while let Some(Parameter { name, type_name }) = param_iter.next() {
-                    write!(signature, "*{name}*: **{}**", type_name.as_str().green())?;
+                    write!(
+                        signature,
+                        "*{name}*: **{}**",
+                        format!("{}", type_name).green()
+                    )?;
 
                     if param_iter.peek().is_some() {
                         write!(signature, ", ")?;
                     }
                 }
 
-                writeln!(signature, ")")?;
+                write!(signature, ")")?;
             }
         }
         let name = function.name();
         let documentation = function.documentation().trim();
+        let return_type = function.return_type();
         let markdown = format!(
-            "---\n\n## **{}**{signature}\n{documentation}{}",
+            "---\n\n## **{}**{signature} -> {}\n\n{documentation}{}",
             name.green(),
+            format!("{}", return_type).green().bold(),
             if documentation.is_empty() { "" } else { "\n\n" }
         );
 

ndc_lib/Cargo.toml

@@ -27,7 +27,6 @@ thiserror.workspace = true
 # Crypto
 md5 = { version = "0.8.0", optional = true }
 sha1 = { version = "0.10.6", optional = true }
-log = "0.4.29"
 
 [features]
 default = ["ahash", "crypto"]

ndc_lib/src/ast/expression.rs

@@ -1,10 +1,18 @@
 use crate::ast::operator::LogicalOperator;
 use crate::ast::parser::Error as ParseError;
 use crate::interpreter::evaluate::EvaluationError;
+use crate::interpreter::function::StaticType;
 use crate::lexer::Span;
 use num::BigInt;
 use num::complex::Complex64;
 
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub enum Binding {
+    None,
+    Resolved(ResolvedVar),
+    Dynamic(Vec<ResolvedVar>), // figure it out at runtime
+}
+
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum ResolvedVar {
     Captured { depth: usize, slot: usize },
@@ -28,7 +36,7 @@ pub enum Expression {
     ComplexLiteral(Complex64),
     Identifier {
         name: String,
-        resolved: Option<ResolvedVar>,
+        resolved: Binding,
     },
     Statement(Box<ExpressionLocation>),
     Logical {
@@ -49,14 +57,15 @@ pub enum Expression {
         l_value: Lvalue,
         r_value: Box<ExpressionLocation>,
         operation: String,
-        resolved_assign_operation: Option<ResolvedVar>,
-        resolved_operation: Option<ResolvedVar>,
+        resolved_assign_operation: Binding,
+        resolved_operation: Binding,
     },
     FunctionDeclaration {
         name: Option<String>,
         resolved_name: Option<ResolvedVar>,
-        arguments: Box<ExpressionLocation>,
+        parameters: Box<ExpressionLocation>,
         body: Box<ExpressionLocation>,
+        return_type: Option<StaticType>,
         pure: bool,
     },
     Block {
@@ -332,15 +341,17 @@ impl std::fmt::Debug for ExpressionLocation {
                 .finish(),
             Expression::FunctionDeclaration {
                 name,
-                arguments,
+                parameters,
+                return_type,
                 body,
                 pure,
                 resolved_name,
             } => f
                 .debug_struct("FunctionDeclaration")
                 .field("name", name)
                 .field("resolved_name", resolved_name)
-                .field("arguments", arguments)
+                .field("parameters", parameters)
+                .field("return_type", return_type)
                 .field("body", body)
                 .field("pure", pure)
                 .finish(),

ndc_lib/src/ast/mod.rs

@@ -2,7 +2,9 @@ mod expression;
 mod operator;
 mod parser;
 
-pub use expression::{Expression, ExpressionLocation, ForBody, ForIteration, Lvalue, ResolvedVar};
+pub use expression::{
+    Binding, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue, ResolvedVar,
+};
 pub use operator::{BinaryOperator, LogicalOperator, UnaryOperator};
 
 pub use parser::Error;

ndc_lib/src/ast/parser.rs

@@ -3,7 +3,7 @@ use std::fmt::Write;
 use miette::Diagnostic;
 
 use crate::ast::Expression;
-use crate::ast::expression::{ExpressionLocation, ForBody, ForIteration, Lvalue};
+use crate::ast::expression::{Binding, ExpressionLocation, ForBody, ForIteration, Lvalue};
 use crate::ast::operator::{BinaryOperator, LogicalOperator, UnaryOperator};
 use crate::lexer::{Span, Token, TokenLocation};
 
@@ -201,7 +201,7 @@ impl Parser {
                 function: Box::new(
                     Expression::Identifier {
                         name: operator_token_loc.token.to_string(),
-                        resolved: None,
+                        resolved: Binding::None,
                     }
                     .to_location(operator_token_loc.span),
                 ),
@@ -214,7 +214,7 @@ impl Parser {
                     function: Box::new(
                         Expression::Identifier {
                             name: not_token.token.to_string(),
-                            resolved: None,
+                            resolved: Binding::None,
                         }
                         .to_location(not_token.span),
                     ),
@@ -246,7 +246,7 @@ impl Parser {
                 function: Box::new(
                     Expression::Identifier {
                         name: operator.to_string(),
-                        resolved: None,
+                        resolved: Binding::None,
                     }
                     .to_location(operator_span),
                 ),
@@ -385,8 +385,8 @@ impl Parser {
                         .expect("guaranteed to produce an lvalue"),
                     r_value: Box::new(expression),
                     operation: operation_identifier,
-                    resolved_assign_operation: None,
-                    resolved_operation: None,
+                    resolved_assign_operation: Binding::None,
+                    resolved_operation: Binding::None,
                 };
 
                 Ok(op_assign.to_location(start.merge(end)))
@@ -483,7 +483,7 @@ impl Parser {
                 function: Box::new(
                     Expression::Identifier {
                         name: operator_token_loc.token.to_string(),
-                        resolved: None,
+                        resolved: Binding::None,
                     }
                     .to_location(operator_span),
                 ),
@@ -610,7 +610,7 @@ impl Parser {
                 function: Box::new(
                     Expression::Identifier {
                         name: operator_token_loc.token.to_string(),
-                        resolved: None,
+                        resolved: Binding::None,
                     }
                     .to_location(token_span),
                 ),
@@ -689,7 +689,7 @@ impl Parser {
                             function: Box::new(
                                 Expression::Identifier {
                                     name: identifier,
-                                    resolved: None,
+                                    resolved: Binding::None,
                                 }
                                 .to_location(identifier_span),
                             ),
@@ -961,7 +961,7 @@ impl Parser {
             Token::String(value) => Expression::StringLiteral(value),
             Token::Identifier(identifier) => Expression::Identifier {
                 name: identifier,
-                resolved: None,
+                resolved: Binding::None,
             },
             _ => {
                 // TODO: this error might not be the best way to describe what's happening here
@@ -1155,8 +1155,9 @@ impl Parser {
         Ok(ExpressionLocation {
             expression: Expression::FunctionDeclaration {
                 name: identifier,
-                arguments: Box::new(argument_list),
+                parameters: Box::new(argument_list),
                 body: Box::new(body),
+                return_type: None, // At some point in the future we could use type declarations here to insert the type (return type inference is cringe anyway)
                 pure: is_pure,
                 resolved_name: None,
             },

ndc_lib/src/interpreter/environment.rs

@@ -1,7 +1,6 @@
-use crate::interpreter::function::{Function, OverloadedFunction};
+use crate::interpreter::function::{Function, StaticType};
 
 use crate::ast::ResolvedVar;
-use crate::interpreter::resolve::LexicalIdentifier;
 use crate::interpreter::value::Value;
 use std::cell::RefCell;
 use std::fmt;
@@ -12,7 +11,7 @@ use std::rc::Rc;
 pub struct RootEnvironment {
     pub output: Box<dyn InterpreterOutput>,
     // These are global values
-    global_functions: Vec<OverloadedFunction>,
+    global_functions: Vec<Function>,
 }
 
 pub struct Environment {
@@ -68,48 +67,27 @@ impl Environment {
         env
     }
 
-    pub fn create_global_scope_mapping(&self) -> Vec<LexicalIdentifier> {
+    pub fn get_global_identifiers(&self) -> Vec<(String, StaticType)> {
         self.root
             .borrow()
             .global_functions
             .iter()
-            .filter_map(|function| {
-                function.name().map(|name| LexicalIdentifier::Function {
-                    name: name.to_string(),
-                    arity: function.arity(),
-                })
-            })
-            .collect::<Vec<LexicalIdentifier>>()
+            .map(|function| (function.name().to_string(), function.static_type()))
+            .collect::<Vec<(String, StaticType)>>()
     }
 
     #[must_use]
-    pub fn get_all_functions(&self) -> Vec<OverloadedFunction> {
+    pub fn get_all_functions(&self) -> Vec<Function> {
         self.root.borrow().global_functions.clone()
     }
 
     pub fn set(&mut self, var: ResolvedVar, value: Value) {
         match var {
             ResolvedVar::Captured { depth: 0, slot } => {
-                // This whole mess (special handling for functions) can be removed once we check
-                // types during the resolver pass
-                if let Value::Function(value_to_insert) = &value {
-                    if let Some(existing_value) = self.values.get(slot) {
-                        if let Value::Function(func) = existing_value {
-                            func.borrow_mut().merge(&mut value_to_insert.borrow_mut())
-                        }
-                    } else {
-                        self.values.push(value);
-                        // self.values.insert(slot, value);
-                    }
-
-                    return;
-                }
-
                 if self.values.len() > slot {
                     self.values[slot] = value
                 } else {
                     debug_assert!(slot == self.values.len());
-                    // self.values.insert(slot, value) // TODO: push should work here right
                     self.values.push(value);
                 }
             }
@@ -139,18 +117,9 @@ impl Environment {
     pub fn declare_global_fn(&mut self, function: impl Into<Function>) {
         let new_function = function.into();
 
-        let gb = &mut self.root.borrow_mut().global_functions;
-
-        // Try to add it to an existing definition
-        for fun in gb.iter_mut() {
-            if fun.name() == Some(new_function.name()) && fun.arity() == new_function.arity() {
-                fun.add(new_function);
-                return;
-            }
-        }
+        let root: &mut RootEnvironment = &mut self.root.borrow_mut();
 
-        // Create a new definition
-        gb.push(OverloadedFunction::from_multiple(vec![new_function]))
+        root.global_functions.push(new_function.clone());
     }
 
     fn get_copy_from_slot(&self, depth: usize, slot: usize) -> Value {

ndc_lib/src/interpreter/evaluate/index.rs

@@ -230,7 +230,7 @@ pub fn get_at_index(
                 .clone())
         }
         _ => Err(EvaluationError::syntax_error(
-            format!("cannot insert into {} at index", lhs.value_type()),
+            format!("cannot insert into {} at index", lhs.static_type()),
             span,
         )
         .into()),
@@ -294,7 +294,7 @@ pub fn set_at_index(
                 }
             } else {
                 return Err(EvaluationError::syntax_error(
-                    format!("cannot insert {} into a string", rhs.value_type()),
+                    format!("cannot insert {} into a string", rhs.static_type()),
                     span,
                 )
                 .into());
@@ -317,7 +317,7 @@ pub fn set_at_index(
         }
         _ => {
             return Err(EvaluationError::syntax_error(
-                format!("cannot insert into {} at index", lhs.value_type()),
+                format!("cannot insert into {} at index", lhs.static_type()),
                 span,
             )
             .into());