Add binary operation to infer expr type

Author: Glyphack

cli/src/main.rs

@@ -34,7 +34,7 @@ fn symbols(path: &PathBuf) -> std::result::Result<(), anyhow::Error> {
     manager.build();
     let module = manager.modules.values().last().unwrap();
 
-    format!("{}", module.symbol_table);
+    println!("{}", module.symbol_table);
 
     Ok(())
 }

typechecker/src/symbol_table.rs

@@ -177,6 +177,7 @@ impl SymbolTableNode {
 
 impl std::fmt::Display for SymbolTable {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "-------------------")?;
         writeln!(f, "global scope:")?;
         let mut sorted_scopes = self.scopes.iter().collect::<Vec<&SymbolTableScope>>();
         sorted_scopes.sort_by(|a, b| a.name.cmp(&b.name));
@@ -185,14 +186,14 @@ impl std::fmt::Display for SymbolTable {
             writeln!(f, "{}", scope)?;
         }
 
-        writeln!(f, "-------------------")?;
         writeln!(f, "all scopes:")?;
 
         let mut sorted_all_scopes = self.all_scopes.iter().collect::<Vec<&SymbolTableScope>>();
         sorted_all_scopes.sort_by(|a, b| a.name.cmp(&b.name));
         for scope in sorted_all_scopes {
             writeln!(f, "{}", scope)?;
         }
+        writeln!(f, "-------------------")?;
         Ok(())
     }
 }

typechecker/src/type_check/checker.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 
 use super::{
-    type_inference::{self, type_check_bin_op},
+    type_inference::{self, bin_op_result_type, type_check_bin_op},
     types::Type,
 };
 
@@ -60,14 +60,12 @@ impl<'a> TypeChecker<'a> {
             Some(symbol) => match symbol.last_declaration() {
                 Some(declaration) => self.infer_declaration_type(declaration),
                 None => {
-                    self.errors
-                        .push(format!("Symbol '{}' not found", name));
+                    self.errors.push(format!("Symbol '{}' not found", name));
                     Type::Unknown
                 }
             },
             None => {
-                self.errors
-                    .push(format!("Symbol '{}' not found", name));
+                self.errors.push(format!("Symbol '{}' not found", name));
                 Type::Unknown
             }
         }
@@ -92,6 +90,11 @@ impl<'a> TypeChecker<'a> {
                     _ => panic!("TODO: infer type from call"),
                 }
             }
+            ast::Expression::BinOp(b) => bin_op_result_type(
+                &self.infer_expr_type(&b.left),
+                &self.infer_expr_type(&b.right),
+                &b.op,
+            ),
             _ => Type::Unknown,
         }
     }
@@ -293,10 +296,6 @@ impl<'a> TraversalVisitor for TypeChecker<'a> {
         let l_type = self.infer_expr_type(&b.left);
         let r_type = self.infer_expr_type(&b.right);
 
-        println!("{}", self.module.symbol_table);
-
-        println!("{} {} {}", l_type, b.op, r_type);
-
         if !type_check_bin_op(&l_type, &r_type, &b.op) {
             self.errors.push(format!(
                 "Operator '{}' not supported for types '{}' and '{}'",

typechecker/src/type_check/type_inference.rs

@@ -59,3 +59,41 @@ pub fn type_check_bin_op(t1: &Type, t2: &Type, op: &BinaryOperator) -> bool {
 
     false
 }
+
+pub fn bin_op_result_type(t1: &Type, t2: &Type, op: &BinaryOperator) -> Type {
+    if !type_check_bin_op(t1, t2, op) {
+        return Type::Unknown;
+    }
+
+    match op {
+        BinaryOperator::Add
+        | BinaryOperator::Sub
+        | BinaryOperator::Mult
+        | BinaryOperator::MatMult
+        | BinaryOperator::Div
+        | BinaryOperator::Mod
+        | BinaryOperator::Pow
+        | BinaryOperator::LShift
+        | BinaryOperator::RShift
+        | BinaryOperator::BitOr
+        | BinaryOperator::BitXor
+        | BinaryOperator::BitAnd
+        | BinaryOperator::FloorDiv => {
+            if type_equal(t1, &Type::Float) || type_equal(t2, &Type::Float) {
+                return Type::Float;
+            }
+            if type_equal(t1, &Type::Int) || type_equal(t2, &Type::Int) {
+                return Type::Int;
+            }
+            match t1 {
+                Type::Str => Type::Str,
+                Type::None => Type::None,
+                Type::Unknown => Type::Unknown,
+                Type::Bool => Type::Bool,
+                Type::Int => Type::Int,
+                Type::Float => Type::Float,
+                _ => Type::Unknown,
+            }
+        }
+    }
+}

typechecker/testdata/output/typechecker__build__tests__class_def.snap

@@ -3,13 +3,13 @@ source: typechecker/src/build.rs
 description: "class c:\n    def __init__(self):\n        a = 1\n"
 expression: result
 ---
+-------------------
 global scope:
 Symbols:
 c
 - Declarations:
 --:   Class { declaration_path: DeclarationPath { module_name: "test", node: Node { start: 0, end: 47 } }, methods: ["__init__"] }
 
--------------------
 all scopes:
 Symbols:
 a
@@ -24,4 +24,5 @@ __init__
 - Declarations:
 --:   Function { declaration_path: DeclarationPath { module_name: "test", node: Node { start: 13, end: 47 } }, function_node: FunctionDef { node: Node { start: 13, end: 47 }, name: "__init__", args: Arguments { node: Node { start: 26, end: 30 }, posonlyargs: [], args: [Arg { node: Node { start: 26, end: 30 }, arg: "self", annotation: None }], vararg: None, kwonlyargs: [], kw_defaults: [], kwarg: None, defaults: [] }, body: [AssignStatement(Assign { node: Node { start: 41, end: 46 }, targets: [Name(Name { node: Node { start: 41, end: 42 }, id: "a" })], value: Constant(Constant { node: Node { start: 45, end: 46 }, value: Int("1") }) })], decorator_list: [], returns: None, type_comment: None }, is_method: true, is_generator: false, return_statements: [], yeild_statements: [], raise_statements: [] }
 
+-------------------
 

typechecker/testdata/output/typechecker__build__tests__function_def.snap

@@ -3,13 +3,13 @@ source: typechecker/src/build.rs
 description: "def func(a ,b , /, c = 2, **e): pass\n"
 expression: result
 ---
+-------------------
 global scope:
 Symbols:
 func
 - Declarations:
 --:   Function { declaration_path: DeclarationPath { module_name: "test", node: Node { start: 0, end: 37 } }, function_node: FunctionDef { node: Node { start: 0, end: 37 }, name: "func", args: Arguments { node: Node { start: 9, end: 29 }, posonlyargs: [Arg { node: Node { start: 9, end: 10 }, arg: "a", annotation: None }, Arg { node: Node { start: 12, end: 13 }, arg: "b", annotation: None }], args: [Arg { node: Node { start: 19, end: 24 }, arg: "c", annotation: None }], vararg: None, kwonlyargs: [], kw_defaults: [], kwarg: Some(Arg { node: Node { start: 28, end: 29 }, arg: "e", annotation: None }), defaults: [Constant(Constant { node: Node { start: 23, end: 24 }, value: Int("2") })] }, body: [Pass(Pass { node: Node { start: 32, end: 36 } })], decorator_list: [], returns: None, type_comment: None }, is_method: false, is_generator: false, return_statements: [], yeild_statements: [], raise_statements: [] }
 
--------------------
 all scopes:
 Symbols:
 a
@@ -25,4 +25,5 @@ e
 - Declarations:
 --:   Paramter { declaration_path: DeclarationPath { module_name: "test", node: Node { start: 28, end: 29 } }, parameter_node: Arg { node: Node { start: 28, end: 29 }, arg: "e", annotation: None }, type_annotation: None, default_value: None }
 
+-------------------
 

typechecker/testdata/output/typechecker__build__tests__simple_var_assignments.snap

@@ -3,6 +3,7 @@ source: typechecker/src/build.rs
 description: "a = 'hello world'\nb = a + \"!\"\n\nc: int = 1\n\nf: str = \"hello\"\n"
 expression: result
 ---
+-------------------
 global scope:
 Symbols:
 a
@@ -18,6 +19,6 @@ f
 - Declarations:
 --:   Variable { declaration_path: DeclarationPath { module_name: "test", node: Node { start: 43, end: 59 } }, scope: Global, type_annotation: Some(Name(Name { node: Node { start: 46, end: 49 }, id: "str" })), inferred_type_source: Some(Constant(Constant { node: Node { start: 52, end: 59 }, value: Str("hello") })), is_constant: false }
 
--------------------
 all scopes:
+-------------------