juledoc: update to latest

Author: mertcandav

builder/builder.jule

@@ -166,6 +166,8 @@ impl Builder {
 			} else {
 				doc.Owner = doc::TypeAlias
 			}
+		| &ast::Impl:
+			// no-op, handled as special case
 		}
 		ret doc
 	}
@@ -222,11 +224,9 @@ impl Builder {
 		// the trait type declaration for implementation. If identifier type is
 		// not public, no need for documentation.
 		if ast.IsTraitImpl() {
-			match type ast.Base.Kind {
-			| &ast::IdentType:
-				if !isPub(ast.Base.Kind.(&ast::IdentType).Ident) {
-					ret
-				}
+			name, isName := ast.Base.Kind.(&ast::IdentType)
+			if isName && !isPub(name.Ident) {
+				ret
 			}
 			meta.Traits = append(meta.Traits, self.formatType(ast.Base))
 		}
@@ -269,10 +269,13 @@ impl Builder {
 		mut i := 0
 		for i < len(ast.Nodes); i++ {
 			mut node := ast.Nodes[i]
+			// Special cases.
 			match type node.Data {
 			| &ast::Impl:
 				self.analysisImpl(node.Data.(&ast::Impl))
 				continue
+			|:
+				// no-op
 			}
 			mut nodeDoc := self.mainNode(ast, i)
 			if nodeDoc == nil {

builder/formatter.jule

@@ -952,6 +952,8 @@ impl formatter {
 				self.writeCommentsExcept(node.Token.Row, true)
 			}
 			self.structDecl(d)
+		|:
+			// no-op
 		}
 		if node.Token.Row-self.writeComments(node.Token.Row, true) > 1 {
 			self.write("\n")
@@ -963,6 +965,8 @@ impl formatter {
 			self.enumDecl[&ast::TypeEnum](node.Data.(&ast::TypeEnum))
 		| &ast::Trait:
 			self.traitDecl(node.Data.(&ast::Trait))
+		|:
+			// no-op
 		}
 	}
 }
@@ -1080,10 +1084,9 @@ impl typeFormatter {
 		mut range := false
 		if c.Recv && c.Send {
 			self.write("chan ")
-			match type c.Elem.Kind {
-			| &ast::ChanType:
-				elemC := c.Elem.Kind.(&ast::ChanType)
-				if elemC.Recv && !elemC.Send {
+			elemChan, isChan := c.Elem.Kind.(&ast::ChanType)
+			if isChan {
+				if elemChan.Recv && !elemChan.Send {
 					range = true
 					self.write("(")
 				}
@@ -1119,6 +1122,8 @@ impl typeFormatter {
 			self.fmt.fnDecl(kind.(&ast::Func))
 		| &ast::ChanType:
 			self.chanType(kind.(&ast::ChanType))
+		| &ast::TupleType:
+			// no-op
 		}
 	}
 }
@@ -1296,20 +1301,20 @@ impl exprFormatter {
 		mut lb, mut rb, mut cb := false, false, false
 		lr, rr, cr := isRanged(i.Start), isRanged(i.To), isRanged(i.Cap)
 		if !lr && i.Start != nil {
-			match type i.Start.Kind {
-			| &ast::BinaryExpr:
+			_, isBinary := i.Start.Kind.(&ast::BinaryExpr)
+			if isBinary {
 				lb = true
 			}
 		}
 		if !rr && i.To != nil {
-			match type i.To.Kind {
-			| &ast::BinaryExpr:
+			_, isBinary := i.To.Kind.(&ast::BinaryExpr)
+			if isBinary {
 				rb = true
 			}
 		}
 		if !cr && i.Cap != nil {
-			match type i.Cap.Kind {
-			| &ast::BinaryExpr:
+			_, isBinary := i.Cap.Kind.(&ast::BinaryExpr)
+			if isBinary {
 				cb = true
 			}
 		}
@@ -1658,38 +1663,31 @@ fn paddingAbs(x: int): int {
 }
 
 fn isPrimType(&t: &ast::Type): bool {
-	match type t.Kind {
-	| &ast::IdentType:
-		itd := t.Kind.(&ast::IdentType)
-		ret itd.Ident == types::I8 ||
-			itd.Ident == types::I16 ||
-			itd.Ident == types::I32 ||
-			itd.Ident == types::I64 ||
-			itd.Ident == types::U8 ||
-			itd.Ident == types::U16 ||
-			itd.Ident == types::U32 ||
-			itd.Ident == types::U64 ||
-			itd.Ident == types::Int ||
-			itd.Ident == types::Uint ||
-			itd.Ident == types::Uintptr ||
-			itd.Ident == types::F32 ||
-			itd.Ident == types::F64 ||
-			itd.Ident == types::Bool ||
-			itd.Ident == types::Str ||
-			itd.Ident == types::Any
-	}
-	ret false
+	name, ok := t.Kind.(&ast::IdentType)
+	ret ok && name.Ident == types::I8 ||
+		name.Ident == types::I16 ||
+		name.Ident == types::I32 ||
+		name.Ident == types::I64 ||
+		name.Ident == types::U8 ||
+		name.Ident == types::U16 ||
+		name.Ident == types::U32 ||
+		name.Ident == types::U64 ||
+		name.Ident == types::Int ||
+		name.Ident == types::Uint ||
+		name.Ident == types::Uintptr ||
+		name.Ident == types::F32 ||
+		name.Ident == types::F64 ||
+		name.Ident == types::Bool ||
+		name.Ident == types::Str ||
+		name.Ident == types::Any
 }
 
 fn isRanged(&e: &ast::Expr): bool {
 	if e == nil {
 		ret false
 	}
-	match type e.Kind {
-	| &ast::RangeExpr:
-		ret true
-	}
-	ret false
+	_, ok := e.Kind.(&ast::RangeExpr)
+	ret ok
 }
 
 fn cloneBuf(b: []byte): []byte {