basic format func decls

StunxFS · StunxFS · commit c1b1055d19f9 · 2023-11-15T21:20:55.000-04:00
diff --git a/lib/rivet/src/ast/Decl.ri b/lib/rivet/src/ast/Decl.ri
@@ -2,6 +2,8 @@
 // Use of this source code is governed by an MIT license that can
 // be found in the LICENSE file.
 
+import std/strings;
+
 import ../token;
 
 public enum Decl {
@@ -138,6 +140,43 @@ public enum Decl {
         self_pos: token.Pos;
         mut sym: Sym;
         mut defer_stmts: []Stmt.Defer;
+
+        public func stringify(self) -> string {
+            mut sb := strings.Builder.new(500);
+            if self.is_public {
+                sb.write_string("public ");
+            }
+            sb.write_fmt("func {}(", self.name);
+            if self.is_method {
+                if self.self_is_ptr {
+                    sb.write_string("&");
+                }
+                if self.self_is_mut {
+                    sb.write_string("mut ");
+                }
+                sb.write_string("self");
+                if self.args.len > 0 {
+                    sb.write_string(", ");
+                }
+            }
+            for i, arg in self.args {
+                if arg.is_mut {
+                    sb.write_string("mut ");
+                }
+                sb.write_fmt("{}: {}", arg.name, arg.type);
+                if arg.has_def_expr {
+                    sb.write_fmt(" := {}", arg.def_expr);
+                }
+                if i < self.args.len - 1 {
+                    sb.write_string(", ");
+                }
+            }
+            sb.write_byte(b')');
+            if self.ret_type !is .Void {
+                sb.write_fmt(" -> {}", self.ret_type);
+            }
+            return sb.to_string();
+        }
     },
     Test {
         docs: []Comment;
diff --git a/lib/rivet/src/fmt/comments.ri b/lib/rivet/src/fmt/comments.ri
@@ -13,7 +13,7 @@ extend Formatter {
     // Optional arguments defines the way comments are going to be written
     // - has_nl: adds an newline at the end of a list of comments
     // - same_line: line comments will be on the same line as the last statement
-    // - level:  either .keep (don't indent), or .indent (increment indentation)
+    // - level:  either .Keep (don't indent), or .Indent (increment indentation)
     // - prev_line: the line number of the previous token to save linebreaks
     func format_comment(
         mut self, comment: ast.Comment, same_line: bool := false,
@@ -22,10 +22,13 @@ extend Formatter {
         if level == .Indent {
             self.indent += 1;
         }
-        if !comment.text.contains("\n") {
+        if !comment.is_multiline() {
             is_separate_line := !same_line or comment.text.starts_with("\x01");
             s := comment.text.trim_left("\x01").trim_right(" ");
             mut out_s := "//";
+            if comment.is_doc {
+                out_s = out_s.concat("/");
+            }
             if s != "" {
                 if s[0].is_alnum() {
                     out_s = out_s.concat(" ");
@@ -36,9 +39,6 @@ extend Formatter {
                 _ = self.remove_new_line(); // delete the generated \n
                 self.write(" ");
             }
-            if comment.is_doc {
-                self.write("/");
-            }
             self.writeln(out_s);
         } else {
             lines := comment.text.trim_space().split_into_lines();
diff --git a/lib/rivet/src/fmt/decls.ri b/lib/rivet/src/fmt/decls.ri
@@ -13,8 +13,23 @@ extend Formatter {
 
     func format_decl(mut self, decl: ast.Decl) {
         match decl is {
-            .Comment as comment -> self.format_comment(comment),
+            .Comment as comment -> self.format_comment(comment, same_line: true),
+            .Func as func_decl -> self.format_func(func_decl),
             else -> {}
         }
     }
+
+    func format_func(mut self, func_decl: ast.Decl.Func) {
+        self.format_comments(func_decl.docs, same_line: true);
+        self.write(func_decl.stringify());
+        if func_decl.is_extern {
+            self.writeln(";");
+        } else {
+            self.writeln(" {");
+            //self.indent += 1;
+            self.format_stmts(func_decl.stmts);
+            //self.indent -= 1;
+            self.writeln("}");
+        }
+    }
 }
diff --git a/lib/rivet/src/fmt/mod.ri b/lib/rivet/src/fmt/mod.ri
@@ -5,6 +5,7 @@
 import std/strings;
 
 import ../ast;
+import ../utils;
 import ../prefs;
 
 static maxLen: []uint := [0, 35, 60, 85, 93, 100];
@@ -47,7 +48,7 @@ public struct Formatter {
     }
 
     func write_indent(mut self) {
-        self.output.write_string("\t".repeat(self.indent));
+        self.output.write_string(utils.tabs(self.indent));
         self.line_len += self.indent * 4;
     }
 
diff --git a/lib/rivet/src/fmt/stmts.ri b/lib/rivet/src/fmt/stmts.ri
@@ -0,0 +1,20 @@
+// Copyright (C) 2023 The Rivet Developers. All rights reserved.
+// Use of this source code is governed by an MIT license that can
+// be found in the LICENSE file.
+
+import ../ast;
+
+extend Formatter {
+    func format_stmts(mut self, stmts: []ast.Stmt) {
+        for stmt in stmts {
+            self.format_stmt(stmt);
+        }
+    }
+
+    func format_stmt(mut self, stmt: ast.Stmt) {
+        match stmt is {
+            .Comment as comment -> self.format_comment(comment, same_line: true),
+            else -> {}
+        }
+    }
+}
diff --git a/lib/rivet/src/parser/decls.ri b/lib/rivet/src/parser/decls.ri
@@ -12,7 +12,7 @@ extend Parser {
     func parse_doc_comments(mut self) -> []ast.Comment {
         mut comments := @vec(ast.Comment);
         while self.tok.kind == .DocComment {
-            comments.push(self.parse_comment(true));
+            comments.push(self.parse_comment());
         }
         return comments;
     }
diff --git a/lib/rivet/src/parser/mod.ri b/lib/rivet/src/parser/mod.ri
@@ -156,13 +156,15 @@ public struct Parser {
         return false;
     }
 
-    func parse_comment(mut self, parse_doc_comment: bool := false) -> ast.Comment {
-        if !((parse_doc_comment and self.accept(.DocComment)) or self.accept(.Comment)) {
-            return ast.Comment();
+    func parse_comment(mut self) -> ast.Comment {
+        if self.prefs.is_fmt or (self.prefs.is_docs and self.tok.kind == .DocComment) {
+            if self.accept(.Comment) or self.accept(.DocComment) {
+                return ast.Comment(
+                    self.prev_tok.kind == .DocComment, self.prev_tok.lit, self.prev_tok.pos
+                );
+            }
         }
-        return ast.Comment(
-            self.prev_tok.kind == .DocComment, self.prev_tok.lit, self.prev_tok.pos
-        );
+        return ast.Comment();
     }
 
     // NOTE:
diff --git a/lib/rivet/src/tokenizer/next.ri b/lib/rivet/src/tokenizer/next.ri
@@ -97,7 +97,7 @@ extend Tokenizer {
                         if (is_doc_comment and self.prefs.is_docs) or self.prefs.is_fmt {
                             mut comment := self.text[start_pos..end_pos];
                             // find out if this comment is on its own line (for rivet format)
-                            mut is_separate_line_comment := false;
+                            mut is_separate_line_comment := true;
                             mut j := start_pos - bytes_to_skip;
                             while j >= 0 and self.text[j] != LF : j -= 1 {
                                 if self.text[j] !in [b'\t', b' '] {
@@ -110,7 +110,13 @@ extend Tokenizer {
                                 // comments that are on a separate line
                                 comment = "\x01".concat(comment);
                             }
-                            return self.new_token(.Comment, comment, comment.len);
+                            return self.new_token(
+                                if is_doc_comment {
+                                    .DocComment
+                                } else {
+                                    .Comment
+                                }, comment, comment.len
+                            );
                         }
                         continue;
                     } else if nextc == b'*' {
diff --git a/lib/rivet/src/utils/mod.ri b/lib/rivet/src/utils/mod.ri
@@ -12,6 +12,28 @@ public const CR: uint8 := 13;
 
 public static mut stderrSupportStyles := styles.stderr_support_styles();
 
+public static tabsTable := [
+    "",
+    "\t",
+    "\t\t",
+    "\t\t\t",
+    "\t\t\t\t",
+    "\t\t\t\t\t",
+    "\t\t\t\t\t\t",
+    "\t\t\t\t\t\t\t",
+    "\t\t\t\t\t\t\t\t",
+    "\t\t\t\t\t\t\t\t\t",
+    "\t\t\t\t\t\t\t\t\t\t"
+];
+
+public func tabs(n: uint) -> string {
+    return if n < tabsTable.len {
+        tabsTable[n]
+    } else {
+        "\t".repeat(n)
+    };
+}
+
 #[inline]
 public func min(a: uint, b: uint) -> uint {
    return if a < b { a } else { b };

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`import std/strings;`
`6`	`6`
`7`	`7`	`import ../ast;`
	`8`	`+import ../utils;`
`8`	`9`	`import ../prefs;`
`9`	`10`
`10`	`11`	`static maxLen: []uint := [0, 35, 60, 85, 93, 100];`
`@@ -47,7 +48,7 @@ public struct Formatter {`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`func write_indent(mut self) {`
`50`		`- self.output.write_string("\t".repeat(self.indent));`
	`51`	`+ self.output.write_string(utils.tabs(self.indent));`
`51`	`52`	`self.line_len += self.indent * 4;`
`52`	`53`	`}`
`53`	`54`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ extend Parser {`
`12`	`12`	`func parse_doc_comments(mut self) -> []ast.Comment {`
`13`	`13`	`mut comments := @vec(ast.Comment);`
`14`	`14`	`while self.tok.kind == .DocComment {`
`15`		`- comments.push(self.parse_comment(true));`
	`15`	`+ comments.push(self.parse_comment());`
`16`	`16`	`}`
`17`	`17`	`return comments;`
`18`	`18`	`}`