feat(types): inference

oxidic · May 5, 2023 · cfadc8b · cfadc8b
1 parent f846da1
commit cfadc8b
Show file tree

Hide file tree

Showing 7 changed files with 71 additions and 19 deletions.
diff --git a/examples/echo.oxi b/examples/echo.oxi
@@ -1,3 +1,3 @@
-let a: str = read();
+let a = read();
 
 println(a);
diff --git a/examples/factorial.oxi b/examples/factorial.oxi
@@ -1,6 +1,6 @@
-let s: str = "10";
+let s = "10";
 
-let n: int = int(s);
+let n = int(s);
 
 fn factorial(n: int) -> int {
     if n == 0 {
@@ -10,6 +10,6 @@ fn factorial(n: int) -> int {
     return n * factorial(n - 1);
 }
 
-let f: int = factorial(n);
+let f = factorial(n);
 
 println(f);
diff --git a/examples/function.oxi b/examples/function.oxi
@@ -2,6 +2,6 @@ fn add(a: int, b: int) -> int {
     return a + b;
 }
 
-let c: int = add(5, 3) + 2;
+let c = add(5, 3) + 2;
 
 println(c);
diff --git a/examples/pattern.oxi b/examples/pattern.oxi
@@ -1,5 +1,5 @@
-let i: int = 1;
-let j: int = 1;
+let i = 1;
+let j = 1;
 
 loop {
     if i > 5 {

diff --git a/src/ast.rs b/src/ast.rs
@@ -5,7 +5,7 @@ pub type Ast = Vec<(AstNode, Range<usize>)>;
 
 #[derive(Clone, Debug)]
 pub enum AstNode {
-    Assignment(String, DataType, Expression),
+    Assignment(String, Option<DataType>, Expression),
     ReAssignment(String, Expression),
     If(Expression, Ast),
     Loop(Ast),

diff --git a/src/interpreter.rs b/src/interpreter.rs
@@ -47,6 +47,25 @@ impl<'a> Interpreter<'a> {
         match node.0 {
             AstNode::Assignment(ident, datatype, expression) => {
                 let data = self.parse_expression(expression, &node.1);
+                let datatype = if datatype.is_none() {
+                    data.r#type()
+                } else {
+                    datatype.unwrap()
+                };
+                if datatype != data.r#type() {
+                    error(
+                        self.name,
+                        self.file,
+                        "E00011",
+                        "incorrect data type",
+                        &format!(
+                            "mismatched data types expected {} found {}",
+                            datatype,
+                            data.to_string()
+                        ),
+                        &node.1,
+                    )
+                }
                 self.variables.insert(ident, Variable::new(datatype, data));
             }
             AstNode::ReAssignment(ident, expression) => {

diff --git a/src/parser.rs b/src/parser.rs
@@ -2,7 +2,7 @@ use std::{iter::Peekable, ops::Range, vec::IntoIter};
 
 use crate::{
     ast::{Ast, AstNode, Expression},
-    data::Param,
+    data::{DataType, Param},
     error::error,
     token::{Token, Tokens},
 };
@@ -193,18 +193,12 @@ impl<'a> Parser<'a> {
         let node: (AstNode, Range<usize>) = if token.0 == Token::Let {
             let t = &stream.next()?;
             if let Token::Identifier(ident) = &t.0 {
-                let t = stream.next()?;
+                let t = stream.peek()?;
                 let datatype = if let Token::DataType(datatype) = t.0 {
-                    datatype
+                    stream.next()?;
+                    Some(datatype)
                 } else {
-                    error(
-                        self.name,
-                        self.file,
-                        "E0010",
-                        "expected data type",
-                        "expected data type",
-                        &(t.1 - 1..t.1 + t.0.len() - 1),
-                    )
+                    None
                 };
 
                 self.check(stream.next()?, Token::Equal);
@@ -219,6 +213,16 @@ impl<'a> Parser<'a> {
 
                 let (expression, _) = self.pratt_parser(tokens.into_iter().peekable(), 0);
 
+                println!("{datatype:?}");
+
+                let datatype = if datatype.is_none() {
+                    let datatype = self.infer_datatype(&expression);
+
+                    datatype
+                } else {
+                    datatype
+                };
+
                 (
                     AstNode::Assignment(ident.to_string(), datatype, expression),
                     token.1..t.1,
@@ -478,6 +482,35 @@ impl<'a> Parser<'a> {
         true
     }
 
+    pub fn infer_datatype(&self, expr: &Expression) -> Option<DataType> {
+        match expr {
+            Expression::BinaryOperation(lhs, _, rhs) => {
+                let lhs = self.infer_datatype(lhs);
+                let rhs = self.infer_datatype(rhs);
+
+                if lhs.is_none() || rhs.is_none() {
+                    return None;
+                };
+
+                let lhs = lhs.unwrap();
+                let rhs = rhs.unwrap();
+
+                Some(match (lhs, rhs) {
+                    (DataType::Str, _) => DataType::Str,
+                    (_, DataType::Str) => DataType::Str,
+                    (DataType::Int, _) => DataType::Int,
+                    (_, DataType::Int) => DataType::Int,
+                    (DataType::Bool, _) => DataType::Bool,
+                })
+            }
+            Expression::Str(_) => Some(DataType::Str),
+            Expression::Int(_) => Some(DataType::Int),
+            Expression::Bool(_) => Some(DataType::Bool),
+            Expression::FunctionCall(_, _) => None,
+            Expression::Identifier(_) => None,
+        }
+    }
+
     pub fn pratt_parser(
         &'a self,
         mut lexer: Peekable<IntoIter<&'a (Token, usize)>>,