Simple type inference

Author: ysthakur

src/compiler.rs

@@ -57,8 +57,10 @@ pub struct Compiler {
     pub variables: Vec<Variable>,
     /// Mapping of variable's name node -> Variable
     pub var_resolution: HashMap<NodeId, VarId>,
-    /// Declarations (commands, aliases, externs), indexed by VarId
+    /// Declarations (commands, aliases, externs), indexed by DeclId
     pub decls: Vec<Box<dyn Command>>,
+    /// Declaration NodeIds, indexed by DeclId
+    pub decl_nodes: Vec<NodeId>,
     /// Mapping of decl's name node -> Command
     pub decl_resolution: HashMap<NodeId, DeclId>,
 
@@ -95,6 +97,7 @@ impl Compiler {
             variables: vec![],
             var_resolution: HashMap::new(),
             decls: vec![],
+            decl_nodes: vec![],
             decl_resolution: HashMap::new(),
 
             // variables: vec![],
@@ -158,6 +161,7 @@ impl Compiler {
         self.variables.extend(name_bindings.variables);
         self.var_resolution.extend(name_bindings.var_resolution);
         self.decls.extend(name_bindings.decls);
+        self.decl_nodes.extend(name_bindings.decl_nodes);
         self.decl_resolution.extend(name_bindings.decl_resolution);
         self.errors.extend(name_bindings.errors);
     }

src/resolver.rs

@@ -58,6 +58,7 @@ pub struct NameBindings {
     pub variables: Vec<Variable>,
     pub var_resolution: HashMap<NodeId, VarId>,
     pub decls: Vec<Box<dyn Command>>,
+    pub decl_nodes: Vec<NodeId>,
     pub decl_resolution: HashMap<NodeId, DeclId>,
     pub errors: Vec<SourceError>,
 }
@@ -70,6 +71,7 @@ impl NameBindings {
             variables: vec![],
             var_resolution: HashMap::new(),
             decls: vec![],
+            decl_nodes: vec![],
             decl_resolution: HashMap::new(),
             errors: vec![],
         }
@@ -96,6 +98,8 @@ pub struct Resolver<'a> {
     pub var_resolution: HashMap<NodeId, VarId>,
     /// Declarations (commands, aliases, etc.), indexed by DeclId
     pub decls: Vec<Box<dyn Command>>,
+    /// Declaration NodeIds, indexed by DeclId
+    pub decl_nodes: Vec<NodeId>,
     /// Mapping of decl's name node -> Command
     pub decl_resolution: HashMap<NodeId, DeclId>,
     /// Errors encountered during name binding
@@ -111,6 +115,7 @@ impl<'a> Resolver<'a> {
             variables: vec![],
             var_resolution: HashMap::new(),
             decls: vec![],
+            decl_nodes: vec![],
             decl_resolution: HashMap::new(),
             errors: vec![],
         }
@@ -123,6 +128,7 @@ impl<'a> Resolver<'a> {
             variables: self.variables,
             var_resolution: self.var_resolution,
             decls: self.decls,
+            decl_nodes: self.decl_nodes,
             decl_resolution: self.decl_resolution,
             errors: self.errors,
         }
@@ -201,7 +207,7 @@ impl<'a> Resolver<'a> {
         // TODO: Move node_id param to the end, same as in typechecker
         match self.compiler.ast_nodes[node_id.0] {
             AstNode::Expr(ref expr) => self.resolve_expr(expr.clone(), node_id),
-            AstNode::Stmt(ref stmt) => self.resolve_stmt(stmt.clone()),
+            AstNode::Stmt(ref stmt) => self.resolve_stmt(stmt.clone(), node_id),
             AstNode::Params(ref params) => {
                 for param in params {
                     if let AstNode::Param { name, .. } = self.compiler.ast_nodes[param.0] {
@@ -294,7 +300,7 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    pub fn resolve_stmt(&mut self, stmt: Stmt) {
+    pub fn resolve_stmt(&mut self, stmt: Stmt, node_id: NodeId) {
         match stmt {
             Stmt::Def {
                 name,
@@ -303,7 +309,7 @@ impl<'a> Resolver<'a> {
                 block,
             } => {
                 // define the command before the block to enable recursive calls
-                self.define_decl(name);
+                self.define_decl(name, node_id);
 
                 // making sure the def parameters and body end up in the same scope frame
                 self.enter_scope(block);
@@ -320,7 +326,7 @@ impl<'a> Resolver<'a> {
                 new_name,
                 old_name: _,
             } => {
-                self.define_decl(new_name);
+                self.define_decl(new_name, node_id);
             }
             Stmt::Let {
                 variable_name,
@@ -491,7 +497,7 @@ impl<'a> Resolver<'a> {
         self.var_resolution.insert(var_name_id, var_id);
     }
 
-    pub fn define_decl(&mut self, decl_name_id: NodeId) {
+    pub fn define_decl(&mut self, decl_name_id: NodeId, decl_node_id: NodeId) {
         // TODO: Deduplicate code with define_variable()
         let decl_name = self.compiler.get_span_contents(decl_name_id);
         let decl_name = trim_decl_name(decl_name).to_vec();
@@ -509,6 +515,8 @@ impl<'a> Resolver<'a> {
         self.decls.push(Box::new(decl));
         let decl_id = DeclId(self.decls.len() - 1);
 
+        self.decl_nodes.push(decl_node_id);
+
         // let the definition of a decl also count as its use
         self.decl_resolution.insert(decl_name_id, decl_id);
     }

src/snapshots/[email protected]

@@ -85,7 +85,7 @@ input_file: tests/calls.nu
 32: string
 33: string
 34: int
-35: any
+35: list<any>
 36: unknown
 37: stream<binary>
 38: stream<binary>

src/snapshots/new_nu_parser__test__node_output@calls_invalid.nu.snap

@@ -0,0 +1,52 @@
+---
+source: src/test.rs
+expression: evaluate_example(path)
+input_file: tests/calls_invalid.nu
+---
+==== COMPILER ====
+0: Name (4 to 7) "foo"
+1: Name (10 to 11) "a"
+2: Name (13 to 16) "int"
+3: Type(Ref { name: NodeId(2), args: None, optional: false }) (13 to 16)
+4: Param { name: NodeId(1), ty: Some(NodeId(3)) } (10 to 16)
+5: Params([NodeId(4)]) (8 to 18)
+6: Expr(Block(BlockId(0))) (19 to 21)
+7: Stmt(Def { name: NodeId(0), params: NodeId(5), in_out_types: None, block: NodeId(6) }) (0 to 21)
+8: Name (22 to 25) "foo"
+9: Expr(Int) (26 to 27) "1"
+10: Expr(Int) (28 to 29) "2"
+11: Expr(Call { parts: [NodeId(8), NodeId(9), NodeId(10)] }) (26 to 29)
+12: Name (30 to 33) "foo"
+13: Expr(String) (34 to 42) ""string""
+14: Expr(Call { parts: [NodeId(12), NodeId(13)] }) (34 to 42)
+15: Expr(Block(BlockId(1))) (0 to 43)
+==== SCOPE ====
+0: Frame Scope, node_id: NodeId(15)
+      decls: [ foo: NodeId(0) ]
+1: Frame Scope, node_id: NodeId(6)
+  variables: [ a: NodeId(1) ]
+==== TYPES ====
+0: unknown
+1: unknown
+2: unknown
+3: int
+4: int
+5: forbidden
+6: ()
+7: ()
+8: unknown
+9: int
+10: unknown
+11: ()
+12: unknown
+13: string
+14: ()
+15: ()
+==== TYPE ERRORS ====
+Error (NodeId 11): Expected 1 argument(s), got 2
+Error (NodeId 13): Expected int, got string
+==== IR ====
+register_count: 0
+file_count: 0
+==== IR ERRORS ====
+Error (NodeId 7): node Stmt(Def { name: NodeId(0), params: NodeId(5), in_out_types: None, block: NodeId(6) }) not suported yet

src/snapshots/new_nu_parser__test__node_output@for_break_continue.nu.snap

@@ -57,15 +57,15 @@ input_file: tests/for_break_continue.nu
 10: int
 11: bool
 12: unknown
-13: unknown
-14: oneof<(), unknown>
+13: ()
+14: ()
 15: int
 16: forbidden
 17: int
 18: bool
 19: unknown
-20: unknown
-21: oneof<(), unknown>
+20: ()
+21: ()
 22: int
 23: forbidden
 24: int

src/snapshots/new_nu_parser__test__node_output@invalid_if.nu.snap

@@ -21,10 +21,10 @@ input_file: tests/invalid_if.nu
 2: int
 3: int
 4: int
-5: error
-6: error
+5: int
+6: int
 ==== TYPE ERRORS ====
-Error (NodeId 0): The condition for if branch is not a boolean
+Error (NodeId 0): Expected bool, got int
 ==== IR ====
 register_count: 0
 file_count: 0

src/snapshots/new_nu_parser__test__node_output@let_mismatch.nu.snap

@@ -91,9 +91,9 @@ input_file: tests/let_mismatch.nu
 39: ()
 40: ()
 ==== TYPE ERRORS ====
-Error (NodeId 13): initializer does not match declared type
-Error (NodeId 26): initializer does not match declared type
-Error (NodeId 38): initializer does not match declared type
+Error (NodeId 13): Expected string, got int
+Error (NodeId 26): Expected list<list<int>>, got list<list<string>>
+Error (NodeId 38): Expected record<a: int>, got record<a: string>
 ==== IR ====
 register_count: 0
 file_count: 0

src/snapshots/[email protected]

@@ -43,7 +43,7 @@ input_file: tests/loop.nu
 13: unknown
 14: unknown
 15: unknown
-16: unknown
+16: ()
 ==== TYPE ERRORS ====
 Error (NodeId 15): unsupported ast node 'Stmt(Loop { block: NodeId(14) })' in typechecker
 ==== IR ====