juledoc: add grouped variable declaration support

Author: mertcandav

builder/builder.jule

@@ -87,6 +87,10 @@ impl Builder {
 		self.fmt.buf.Clear()
 		{
 			data := ast.Nodes[i].Data.(&ast::Var)
+			// Format directly if data is grouped explicitly.
+			if data.Group != nil {
+				ret self.formatNode(ast.Nodes[i])
+			}
 			mut row := data.Token.Row
 			if len(data.Directives) > 0 {
 				row = data.Directives[0].Tag.Row
@@ -99,7 +103,7 @@ impl Builder {
 			unsafe {
 				if !d.Binded && isPub(d.Ident) {
 					self.fmt.buf.Write(self.fmt.indent)!
-					self.fmt.varDecl(d)
+					self.fmt.varDecl(d, true)
 				}
 			}
 		})

builder/formatter.jule

@@ -613,41 +613,49 @@ impl formatter {
 		self.formatType(d.Kind)
 	}
 
-	fn varDecl(&self, mut d: &ast::Var) {
-		if len(d.Directives) != 0 {
-			self.directives(d.Directives)
-		}
-		if d.Binded {
-			self.write("cpp let ")
-		} else {
-			if d.Statically {
-				self.write("static ")
-			} else if d.Constant {
-				self.write("const ")
-			} else if d.Setter == nil || d.Setter.Id == token::Id.Eq {
-				self.write("let ")
+	fn varDecl(&self, mut d: &ast::Var, head: bool) {
+		if head {
+			if len(d.Directives) != 0 {
+				self.directives(d.Directives)
+			}
+			if d.Binded {
+				self.write("cpp let ")
+			} else {
+				if d.Statically {
+					self.write("static ")
+				} else if d.Constant {
+					self.write("const ")
+				} else if d.Setter == nil || d.Setter.Id == token::Id.Eq {
+					self.write("let ")
+				}
+			}
+			if d.Mutable {
+				self.write("mut ")
+			}
+			if d.Reference {
+				self.write("&")
 			}
-		}
-		if d.Mutable {
-			self.write("mut ")
-		}
-		if d.Reference {
-			self.write("&")
 		}
 		self.write(d.Ident)
+		self.row = d.Token.Row
 		if d.Kind != nil {
 			self.write(": ")
 			self.formatType(d.Kind)
+			self.row = d.Kind.Token.Row
 		}
 		if d.Expr != nil {
 			self.write(" ")
 			self.write(d.Setter.Kind)
 			self.write(" ")
 			self.formatExpr(d.Expr)
+			self.row = d.Expr.End.Row
 		}
 	}
 
 	fn getMax(self, lines: [][]byte, rows: []int): (max: int, n: int) {
+		if len(lines) == 0 || len(rows) == 0 {
+			ret 0, 0
+		}
 		if !self.isPopsRowCommentsByF(rows[0], -1) {
 			ret
 		}
@@ -741,6 +749,61 @@ impl formatter {
 		ret
 	}
 
+	fn varGroup(&self, mut root: &ast::Var) {
+		mut lines := make([][]byte, 0, len(root.Group))
+		mut rows := make([]int, 0, len(root.Group))
+
+		self.buf.Write(self.indent)!
+		self.write("const (\n")
+		self.addIndent()
+		mut n := self.buf.Len()
+		for (_, mut v) in root.Group {
+			self.varDecl(v, false)
+			mut line := cloneBuf(self.ubuf()[n:])
+			lines = append(lines, line)
+			rows = append(rows, self.row)
+			self.setBuf(self.ubuf()[:n])
+		}
+		n = 0
+		mut max := 0
+		mut rowBreak := indexRowBrake(rows)
+		for j, line in lines {
+			isPub := isPub(root.Group[j].Ident) // Ignore private ones.
+			row := rows[j]
+			if j == rowBreak {
+				self.write("\n")
+				rowBreak = j + indexRowBrake(rows[j:])
+			}
+			self.writeCommentsExcept(row, isPub)
+			if isPub {
+				self.buf.Write(self.indent)!
+				self.buf.Write(line)!
+			}
+			// Handle comments if same-line condition is not appear or
+			// current row is not same as next row. So, we can move line comments
+			// to last statement of inline statements.
+			if len(lines)-j < 2 || rows[j] != rows[j+1] {
+				if n == 0 {
+					max, n = self.getMax(lines[j:rowBreak], rows[j:rowBreak])
+				}
+				if n > 0 {
+					self.popRowCommentsByF(row, -1, isPub, fn(c: &comment) {
+						self.write(strings::Repeat(" ", paddingAbs(max-utf8::RuneCount(line))+1))
+						self.writeComment(c)
+					})
+					n--
+				}
+			}
+			if isPub {
+				self.write("\n")
+			}
+		}
+		self.doneIndent()
+		self.buf.Write(self.indent)!
+		self.write(")")
+		self.row = rows[len(rows)-1] + 1 // Add +1 offset for "\n)" suffix.
+	}
+
 	fn groupDecls[T, Node](&self, mut nodes: []Node, mut &i: int, writer: fn(mut &d: T)) {
 		if len(nodes) == 0 {
 			ret
@@ -841,7 +904,11 @@ impl formatter {
 			} else {
 				self.writeCommentsExcept(d.Token.Row, true)
 			}
-			self.varDecl(d)
+			if d.Group != nil {
+				self.varGroup(d)
+			} else {
+				self.varDecl(d, true)
+			}
 			ret
 		| &ast::Func:
 			mut d := node.Data.(&ast::Func)
@@ -1604,4 +1671,13 @@ fn cloneBuf(b: []byte): []byte {
 	mut rb := make([]byte, len(b))
 	copy(rb, b)
 	ret rb
+}
+
+fn indexRowBrake(rows: []int): int {
+	for i, r in rows {
+		if i > 0 && r-rows[i-1] > 1 {
+			ret i
+		}
+	}
+	ret len(rows)
 }