wip generics

Author: rahulk29

core/compiler/examples/generic_tuple/lib.ar

@@ -0,0 +1,8 @@
+fn pair<T>(x: T) -> [T] {
+    cons(x, cons(x, []))
+}
+
+cell top() {
+    let float_pair = pair(800.);
+    let r = rect("met1", x0=0., y0=200., x1=head(float_pair), y1=head(tail(float_pair)));
+}

core/compiler/src/argon.y

@@ -170,23 +170,25 @@ CellDecl -> Result<CellDecl<&'input str, ParseMetadata>, ()>
   ;
 
 FnDecl -> Result<FnDecl<&'input str, ParseMetadata>, ()>
-  : 'FN' Ident '(' ArgDecls ')' '->' TySpec Scope
+  : 'FN' Ident BracketedGenericDecls '(' ArgDecls ')' '->' TySpec Scope
   {
     Ok(FnDecl {
       name: $2?,
-      args: $4?,
-      scope: $8?,
-      return_ty: Some($7?),
+      generics: $3?,
+      args: $5?,
+      scope: $9?,
+      return_ty: Some($8?),
       span: $span,
       metadata: (),
     })
   }
-  | 'FN' Ident '(' ArgDecls ')' Scope
+  | 'FN' Ident BracketedGenericDecls '(' ArgDecls ')' Scope
   {
     Ok(FnDecl {
       name: $2?,
-      args: $4?,
-      scope: $6?,
+      generics: $3?,
+      args: $5?,
+      scope: $7?,
       return_ty: None,
       span: $span,
       metadata: (),
@@ -396,6 +398,26 @@ ArgDecl -> Result<ArgDecl<&'input str, ParseMetadata>, ()>
   : Ident ':' TySpec { Ok(ArgDecl { name: $1?, ty: $3?, metadata: () }) }
   ;
 
+BracketedGenericDecls -> Result<Vec<GenericDecl<&'input str, ParseMetadata>>, ()>
+  : { Ok(Vec::new()) }
+  | '<' GenericDecls '>' { $2 }
+  ;
+
+GenericDecls -> Result<Vec<GenericDecl<&'input str, ParseMetadata>>, ()>
+  : { Ok(Vec::new()) }
+  | GenericDecls1 { $1 }
+  | GenericDecls1 ',' { $1 }
+  ;
+
+GenericDecls1 -> Result<Vec<GenericDecl<&'input str, ParseMetadata>>, ()>
+  : GenericDecls1 ',' GenericDecl { flatten($1, $3) }
+  | GenericDecl { Ok(vec![$1?]) }
+  ;
+
+GenericDecl -> Result<GenericDecl<&'input str, ParseMetadata>, ()>
+  : Ident { Ok(GenericDecl { name: $1?, metadata: () }) }
+  ;
+
 TySpec -> Result<TySpec<&'input str, ParseMetadata>, ()>
   : Ident { Ok(TySpec { kind: TySpecKind::Ident($1?), span: $span, }) }
   | '[' TySpec ']' { Ok(TySpec { kind: TySpecKind::Seq(Box::new($2?)), span: $span, }) }

core/compiler/src/ast/annotated.rs

@@ -244,6 +244,14 @@ impl<S, T: AstMetadata> AstTransformer for AstAnnotationPass<S, T> {
         input.metadata.clone()
     }
 
+    fn dispatch_generic_decl(
+        &mut self,
+        input: &super::GenericDecl<Self::InputS, Self::InputMetadata>,
+        _name: &Ident<Self::OutputS, Self::OutputMetadata>,
+    ) -> <Self::OutputMetadata as AstMetadata>::GenericDecl {
+        input.metadata.clone()
+    }
+
     fn dispatch_scope(
         &mut self,
         input: &Scope<Self::InputS, Self::InputMetadata>,

core/compiler/src/ast/mod.rs

@@ -135,6 +135,7 @@ pub struct TySpec<S, T: AstMetadata> {
 #[derive_where(Debug, Clone, Serialize, Deserialize; S)]
 pub struct FnDecl<S, T: AstMetadata> {
     pub name: Ident<S, T>,
+    pub generics: Vec<GenericDecl<S, T>>,
     pub args: Vec<ArgDecl<S, T>>,
     pub return_ty: Option<TySpec<S, T>>,
     pub scope: Scope<S, T>,
@@ -316,6 +317,12 @@ pub struct ArgDecl<S, T: AstMetadata> {
     pub metadata: T::ArgDecl,
 }
 
+#[derive_where(Debug, Clone, Serialize, Deserialize; S)]
+pub struct GenericDecl<S, T: AstMetadata> {
+    pub name: Ident<S, T>,
+    pub metadata: T::GenericDecl,
+}
+
 #[derive_where(Debug, Clone, Serialize, Deserialize; S)]
 pub struct CastExpr<S, T: AstMetadata> {
     pub value: Expr<S, T>,
@@ -383,6 +390,7 @@ pub trait AstMetadata {
     type Args: Debug + Clone + Serialize + DeserializeOwned;
     type KwArgValue: Debug + Clone + Serialize + DeserializeOwned;
     type ArgDecl: Debug + Clone + Serialize + DeserializeOwned;
+    type GenericDecl: Debug + Clone + Serialize + DeserializeOwned;
     type Scope: Debug + Clone + Serialize + DeserializeOwned;
     type Typ: Debug + Clone + Serialize + DeserializeOwned;
     type CastExpr: Debug + Clone + Serialize + DeserializeOwned;
@@ -507,6 +515,11 @@ pub trait AstTransformer {
         name: &Ident<Self::OutputS, Self::OutputMetadata>,
         ty: &TySpec<Self::OutputS, Self::OutputMetadata>,
     ) -> <Self::OutputMetadata as AstMetadata>::ArgDecl;
+    fn dispatch_generic_decl(
+        &mut self,
+        input: &GenericDecl<Self::InputS, Self::InputMetadata>,
+        name: &Ident<Self::OutputS, Self::OutputMetadata>,
+    ) -> <Self::OutputMetadata as AstMetadata>::GenericDecl;
     fn dispatch_scope(
         &mut self,
         input: &Scope<Self::InputS, Self::InputMetadata>,
@@ -608,6 +621,11 @@ pub trait AstTransformer {
         input: &FnDecl<Self::InputS, Self::InputMetadata>,
     ) -> FnDecl<Self::OutputS, Self::OutputMetadata> {
         let name = self.transform_ident(&input.name);
+        let generics = input
+            .generics
+            .iter()
+            .map(|decl| self.transform_generic_decl(decl))
+            .collect_vec();
         let args = input
             .args
             .iter()
@@ -621,6 +639,7 @@ pub trait AstTransformer {
         let metadata = self.dispatch_fn_decl(input, &name, &args, &return_ty, &scope);
         FnDecl {
             name,
+            generics,
             args,
             return_ty,
             scope,
@@ -859,6 +878,15 @@ pub trait AstTransformer {
         ArgDecl { name, ty, metadata }
     }
 
+    fn transform_generic_decl(
+        &mut self,
+        input: &GenericDecl<Self::InputS, Self::InputMetadata>,
+    ) -> GenericDecl<Self::OutputS, Self::OutputMetadata> {
+        let name = self.transform_ident(&input.name);
+        let metadata = self.dispatch_generic_decl(input, &name);
+        GenericDecl { name, metadata }
+    }
+
     fn transform_scope(
         &mut self,
         input: &Scope<Self::InputS, Self::InputMetadata>,

core/compiler/src/compile.rs

@@ -343,6 +343,13 @@ impl<'a> AstTransformer for ImportPass<'a> {
     ) -> <Self::OutputMetadata as AstMetadata>::ArgDecl {
     }
 
+    fn dispatch_generic_decl(
+        &mut self,
+        _input: &crate::ast::GenericDecl<Self::InputS, Self::InputMetadata>,
+        _name: &Ident<Self::OutputS, Self::OutputMetadata>,
+    ) -> <Self::OutputMetadata as AstMetadata>::GenericDecl {
+    }
+
     fn dispatch_scope(
         &mut self,
         _input: &Scope<Self::InputS, Self::InputMetadata>,
@@ -570,6 +577,7 @@ impl AstMetadata for VarIdTyMetadata {
     type Args = ();
     type KwArgValue = Ty;
     type ArgDecl = (VarId, Ty);
+    type GenericDecl = ();
     type Scope = Ty;
     type Typ = ();
     type CastExpr = Ty;
@@ -1028,6 +1036,11 @@ impl<'a> AstTransformer for VarIdTyPass<'a> {
             .scope_annotation
             .as_ref()
             .map(|ident| self.transform_ident(ident));
+        let generics = input
+            .generics
+            .iter()
+            .map(|decl| self.transform_generic_decl(decl))
+            .collect_vec();
         let args: Vec<_> = input
             .args
             .iter()
@@ -1056,6 +1069,7 @@ impl<'a> AstTransformer for VarIdTyPass<'a> {
         let metadata = self.dispatch_fn_decl(input, &name, &args, &return_ty, &scope);
         FnDecl {
             name,
+            generics,
             args,
             return_ty,
             scope,
@@ -1675,6 +1689,13 @@ impl<'a> AstTransformer for VarIdTyPass<'a> {
         (self.alloc(&input.name.name, ty.clone()), ty)
     }
 
+    fn dispatch_generic_decl(
+        &mut self,
+        _input: &crate::ast::GenericDecl<Self::InputS, Self::InputMetadata>,
+        _name: &Ident<Self::OutputS, Self::OutputMetadata>,
+    ) -> <Self::OutputMetadata as AstMetadata>::GenericDecl {
+    }
+
     fn dispatch_scope(
         &mut self,
         _input: &Scope<Substr, Self::InputMetadata>,

core/compiler/src/parse.rs

@@ -45,6 +45,7 @@ impl AstMetadata for ParseMetadata {
     type Args = ();
     type KwArgValue = ();
     type ArgDecl = ();
+    type GenericDecl = ();
     type Scope = ();
     type Typ = ();
     type FnDecl = ();

core/lsp-server/src/import.rs

@@ -269,6 +269,13 @@ impl<'a> AstTransformer for ScopeAnnotationPass<'a> {
     ) -> <Self::OutputMetadata as AstMetadata>::ArgDecl {
     }
 
+    fn dispatch_generic_decl(
+        &mut self,
+        _input: &compiler::ast::GenericDecl<Self::InputS, Self::InputMetadata>,
+        _name: &Ident<Self::OutputS, Self::OutputMetadata>,
+    ) -> <Self::OutputMetadata as AstMetadata>::GenericDecl {
+    }
+
     fn dispatch_scope(
         &mut self,
         _input: &Scope<Substr, Self::InputMetadata>,