feat(compiler): add support for scope name annotations (#29)

* feat(compiler): add support for scope name annotations

* disallow spaces in # annotation

* change scope names to be more natural

* fix lint

Author: rohanku

core/compiler/examples/nested_inst.ar

@@ -23,10 +23,15 @@ cell top() {
   let mid_cell = middle();
   let left = inst(mid_cell)!;
   let right = inst(mid_cell, angle=90)!;
-  eq(left.x, 0.);
-  eq(left.y, 0.);
-  eq(right.x, 300.);
-  eq(right.y, 0.);
+  #scope0
+  {
+    eq(left.x, 0.);
+    eq(left.y, 0.);
+    eq(right.x, 300.);
+    eq(right.y, 0.);
+  }
+  #scope1
+  if 1 > 2 { } else { }
   let met3 = rect("met3", x0=left.bot.met1.x0, y0=20., x1=right.bot.met1.x1, y1=80.)!;
   let duplicate_rect = left.bot.met3!;
 }

core/compiler/src/argon.l

@@ -11,11 +11,13 @@ let "LET"
 for "FOR"
 in "IN"
 as "AS"
+#[_a-zA-Z][_a-zA-Z0-9]* "ANNOTATION"
 [_a-zA-Z][_a-zA-Z0-9]* "IDENT"
 [0-9]+\.[0-9]* "FLOATLIT"
 [0-9]+ "INTLIT"
 "[^"]*" "STRLIT"
 //[^\r\n]* ;
+\# "#"
 \+ "+"
 \* "*"
 - "-"

core/compiler/src/argon.y

@@ -132,7 +132,18 @@ FnDecl -> Result<FnDecl<'input, ParseMetadata>, ()>
       name: $2?,
       args: $4?,
       scope: $8?,
-      return_ty: $7?,
+      return_ty: Some($7?),
+      span: $span,
+      metadata: (),
+    })
+  }
+  | 'FN' Ident '(' ArgDecls ')' Scope
+  {
+    Ok(FnDecl {
+      name: $2?,
+      args: $4?,
+      scope: $6?,
+      return_ty: None,
       span: $span,
       metadata: (),
     })
@@ -168,20 +179,26 @@ Statement -> Result<Statement<'input, ParseMetadata>, ()>
   }
   ;
 
-Scope -> Result<Scope<'input, ParseMetadata>, ()>
+ScopeAnnotation -> Result<Ident<'input, ParseMetadata>, ()>
+    : 'ANNOTATION' { Ok(Ident { span: $span, name: &$lexer.span_str($span)[1..], metadata: () }) }
+    ;
+
+UnannotatedScope -> Result<Scope<'input, ParseMetadata>, ()>
   : '{' Statements '}'
   {
     let mut __stmts = $2?;
     if let Some(Statement::Expr { value, semicolon }) = __stmts.last().cloned() && !semicolon {
       __stmts.pop().unwrap();
       return Ok(Scope {
+        scope_annotation: None,
         span: $span,
         stmts: __stmts,
         tail: Some(value),
         metadata: (),
       })
     }
     Ok(Scope {
+      scope_annotation: None,
       span: $span,
       stmts: __stmts,
       tail: None,
@@ -191,6 +208,7 @@ Scope -> Result<Scope<'input, ParseMetadata>, ()>
   | '{' Statements NonBlockExpr '}'
   {
     Ok(Scope {
+      scope_annotation: None,
       span: $span,
       stmts: $2?,
       tail: Some($3?),
@@ -199,13 +217,28 @@ Scope -> Result<Scope<'input, ParseMetadata>, ()>
   }
   ;
 
+Scope -> Result<Scope<'input, ParseMetadata>, ()>
+    : ScopeAnnotation UnannotatedScope
+    {
+        Ok(Scope {
+            scope_annotation: Some($1?),
+            ..$2?
+        })
+    }
+    | UnannotatedScope 
+    {
+        $1
+    }
+    ;
+
 Expr -> Result<Expr<'input, ParseMetadata>, ()>
   : NonBlockExpr { $1 }
   | BlockExpr { $1 }
   ;
 
 BlockExpr -> Result<Expr<'input, ParseMetadata>, ()>
-  : 'IF' Expr Scope 'ELSE' Scope { Ok(Expr::If(Box::new(IfExpr { cond: $2?, then: Expr::Scope(Box::new($3?)), else_: Expr::Scope(Box::new($5?)), span: $span, metadata: (), }))) }
+  : 'IF' Expr Scope 'ELSE' Scope { Ok(Expr::If(Box::new(IfExpr { scope_annotation: None, cond: $2?, then: Expr::Scope(Box::new($3?)), else_: Expr::Scope(Box::new($5?)), span: $span, metadata: (), }))) }
+  | ScopeAnnotation 'IF' Expr Scope 'ELSE' Scope { Ok(Expr::If(Box::new(IfExpr { scope_annotation: Some($1?), cond: $3?, then: Expr::Scope(Box::new($4?)), else_: Expr::Scope(Box::new($6?)), span: $span, metadata: (), }))) }
   | Scope { Ok(Expr::Scope(Box::new($1?))) }
   ;
 

core/compiler/src/ast.rs

@@ -80,7 +80,7 @@ pub struct CellDecl<'a, T: AstMetadata> {
 pub struct FnDecl<'a, T: AstMetadata> {
     pub name: Ident<'a, T>,
     pub args: Vec<ArgDecl<'a, T>>,
-    pub return_ty: Ident<'a, T>,
+    pub return_ty: Option<Ident<'a, T>>,
     pub scope: Scope<'a, T>,
     pub span: Span,
     pub metadata: T::FnDecl,
@@ -96,6 +96,7 @@ pub struct ConstantDecl<'a, T: AstMetadata> {
 
 #[derive_where(Debug, Clone)]
 pub struct Scope<'a, T: AstMetadata> {
+    pub scope_annotation: Option<Ident<'a, T>>,
     pub span: Span,
     pub stmts: Vec<Statement<'a, T>>,
     pub tail: Option<Expr<'a, T>>,
@@ -166,6 +167,7 @@ pub struct VarExpr<'a, T: AstMetadata> {
 
 #[derive_where(Debug, Clone)]
 pub struct IfExpr<'a, T: AstMetadata> {
+    pub scope_annotation: Option<Ident<'a, T>>,
     pub cond: Expr<'a, T>,
     pub then: Expr<'a, T>,
     pub else_: Expr<'a, T>,
@@ -356,7 +358,7 @@ pub trait AstTransformer<'a> {
         input: &FnDecl<'a, Self::Input>,
         name: &Ident<'a, Self::Output>,
         args: &[ArgDecl<'a, Self::Output>],
-        return_ty: &Ident<'a, Self::Output>,
+        return_ty: &Option<Ident<'a, Self::Output>>,
         scope: &Scope<'a, Self::Output>,
     ) -> <Self::Output as AstMetadata>::FnDecl;
     fn dispatch_constant_decl(
@@ -512,7 +514,10 @@ pub trait AstTransformer<'a> {
             .iter()
             .map(|arg| self.transform_arg_decl(arg))
             .collect_vec();
-        let return_ty = self.transform_ident(&input.return_ty);
+        let return_ty = input
+            .return_ty
+            .as_ref()
+            .map(|ident| self.transform_ident(ident));
         let scope = self.transform_scope(&input.scope);
         let metadata = self.dispatch_fn_decl(input, &name, &args, &return_ty, &scope);
         FnDecl {
@@ -566,11 +571,16 @@ pub trait AstTransformer<'a> {
         }
     }
     fn transform_if_expr(&mut self, input: &IfExpr<'a, Self::Input>) -> IfExpr<'a, Self::Output> {
+        let scope_annotation = input
+            .scope_annotation
+            .as_ref()
+            .map(|ident| self.transform_ident(ident));
         let cond = self.transform_expr(&input.cond);
         let then = self.transform_expr(&input.then);
         let else_ = self.transform_expr(&input.else_);
         let metadata = self.dispatch_if_expr(input, &cond, &then, &else_);
         IfExpr {
+            scope_annotation,
             span: input.span,
             metadata,
             cond,
@@ -722,6 +732,10 @@ pub trait AstTransformer<'a> {
 
     fn transform_scope(&mut self, input: &Scope<'a, Self::Input>) -> Scope<'a, Self::Output> {
         self.enter_scope(input);
+        let scope_annotation = input
+            .scope_annotation
+            .as_ref()
+            .map(|ident| self.transform_ident(ident));
         let stmts = input
             .stmts
             .iter()
@@ -730,6 +744,7 @@ pub trait AstTransformer<'a> {
         let tail = input.tail.as_ref().map(|stmt| self.transform_expr(stmt));
         let metadata = self.dispatch_scope(input, &stmts, &tail);
         let output = Scope {
+            scope_annotation,
             span: input.span,
             stmts,
             tail,