Parse type params for defs

Author: ysthakur

src/compiler.rs

@@ -1,7 +1,9 @@
 use crate::errors::SourceError;
 use crate::parser::{AstNode, Block, Expr, NodeId};
 use crate::protocol::Command;
-use crate::resolver::{DeclId, Frame, NameBindings, ScopeId, VarId, Variable};
+use crate::resolver::{
+    DeclId, Frame, NameBindings, ScopeId, TypeDecl, TypeDeclId, VarId, Variable,
+};
 use crate::typechecker::{TypeId, Types};
 use std::collections::HashMap;
 
@@ -57,6 +59,10 @@ pub struct Compiler {
     pub variables: Vec<Variable>,
     /// Mapping of variable's name node -> Variable
     pub var_resolution: HashMap<NodeId, VarId>,
+    /// Type declarations, indexed by TypeDeclId
+    pub type_decls: Vec<TypeDecl>,
+    /// Mapping of type decl's name node -> TypeDecl
+    pub type_resolution: HashMap<NodeId, TypeDeclId>,
     /// Declarations (commands, aliases, externs), indexed by DeclId
     pub decls: Vec<Box<dyn Command>>,
     /// Declaration NodeIds, indexed by DeclId
@@ -96,6 +102,8 @@ impl Compiler {
             scope_stack: vec![],
             variables: vec![],
             var_resolution: HashMap::new(),
+            type_decls: vec![],
+            type_resolution: HashMap::new(),
             decls: vec![],
             decl_nodes: vec![],
             decl_resolution: HashMap::new(),
@@ -160,6 +168,8 @@ impl Compiler {
         self.scope_stack.extend(name_bindings.scope_stack);
         self.variables.extend(name_bindings.variables);
         self.var_resolution.extend(name_bindings.var_resolution);
+        self.type_decls.extend(name_bindings.type_decls);
+        self.type_resolution.extend(name_bindings.type_resolution);
         self.decls.extend(name_bindings.decls);
         self.decl_nodes.extend(name_bindings.decl_nodes);
         self.decl_resolution.extend(name_bindings.decl_resolution);

src/parser.rs

@@ -133,6 +133,7 @@ pub enum Stmt {
     // Definitions
     Def {
         name: NodeId,
+        type_params: Option<NodeId>,
         params: NodeId,
         in_out_types: Option<NodeId>,
         block: NodeId,
@@ -175,6 +176,8 @@ pub enum AstNode {
     Type(TypeAst),
 
     Name,
+    /// For now, each type parameter is a Name
+    TypeParams(Vec<NodeId>),
     TypeArgs(Vec<NodeId>),
     VarDecl,
 
@@ -958,6 +961,32 @@ impl Parser {
         self.create_node(AstNode::Params(param_list), span_start, span_end)
     }
 
+    pub fn type_params(&mut self) -> NodeId {
+        let _span = span!();
+        let span_start = self.position();
+        self.less_than();
+
+        let mut param_list = vec![];
+
+        while self.has_tokens() {
+            if self.is_greater_than() {
+                break;
+            }
+
+            if self.is_comma() {
+                self.tokens.advance();
+                continue;
+            }
+
+            param_list.push(self.name());
+        }
+
+        let span_end = self.position() + 1;
+        self.greater_than();
+
+        self.create_node(AstNode::TypeParams(param_list), span_start, span_end)
+    }
+
     pub fn type_args(&mut self) -> NodeId {
         let _span = span!();
         let span_start = self.position();
@@ -1099,6 +1128,12 @@ impl Parser {
             _ => return self.error("expected def name"),
         };
 
+        let type_params = if self.is_less_than() {
+            Some(self.type_params())
+        } else {
+            None
+        };
+
         let params = self.signature_params(ParamsContext::Squares);
         let in_out_types = if self.is_colon() {
             Some(self.in_out_types())
@@ -1112,6 +1147,7 @@ impl Parser {
         self.create_stmt(
             Stmt::Def {
                 name,
+                type_params,
                 params,
                 in_out_types,
                 block,