chore: fix lint errors

Author: osteele

expressions/expressions.y

@@ -96,7 +96,7 @@ string: LITERAL {
 
 loop: IDENTIFIER IN filtered loop_modifiers {
 	name, expr, mods := $1, $3, $4
-	$$ = Loop{name, &expression{expr}, mods}
+	$$ = Loop{mods, name, &expression{expr}}
 }
 ;
 

expressions/scanner.go

@@ -29,9 +29,10 @@ type Cycle struct {
 
 // A Loop is a parse of a {% loop %} statement
 type Loop struct {
+	loopModifiers
+
 	Variable string
 	Expr     Expression
-	loopModifiers
 }
 
 type loopModifiers struct {

expressions/statements.go

@@ -18,8 +18,9 @@ type ASTBlock struct {
 
 // ASTRaw holds the text between the start and end of a raw tag.
 type ASTRaw struct {
-	Slices []string
 	sourcelessNode
+
+	Slices []string
 }
 
 // ASTTag is a tag {% tag %} that is not a block start or end.
@@ -41,8 +42,9 @@ type ASTObject struct {
 
 // ASTSeq is a sequence of nodes.
 type ASTSeq struct {
-	Children []ASTNode
 	sourcelessNode
+
+	Children []ASTNode
 }
 
 // TrimDirection determines the trim direction of an ASTTrim object.

expressions/y.go

@@ -51,14 +51,14 @@ func (c *Config) compileNode(n parser.ASTNode) (Node, parser.Error) {
 
 		return &node, nil
 	case *parser.ASTRaw:
-		return &RawNode{n.Slices, sourcelessNode{}}, nil
+		return &RawNode{sourcelessNode{}, n.Slices}, nil
 	case *parser.ASTSeq:
 		children, err := c.compileNodes(n.Children)
 		if err != nil {
 			return nil, err
 		}
 
-		return &SeqNode{children, sourcelessNode{}}, nil
+		return &SeqNode{sourcelessNode{}, children}, nil
 	case *parser.ASTTag:
 		if td, ok := c.FindTagDefinition(n.Name); ok {
 			f, err := td(n.Args)

parser/ast.go

@@ -196,6 +196,7 @@ func (c rendererContext) RenderFile(filename string, b map[string]any) (string,
 // InnerString renders the children to a string.
 func (c rendererContext) InnerString() (string, error) {
 	buf := new(bytes.Buffer)
+
 	err := c.RenderChildren(buf)
 	if err != nil {
 		return "", err

render/compiler.go

@@ -25,8 +25,9 @@ type BlockNode struct {
 
 // RawNode holds the text between the start and end of a raw tag.
 type RawNode struct {
-	slices []string
 	sourcelessNode
+
+	slices []string
 }
 
 // TagNode renders itself via a render function that is created during parsing.
@@ -50,8 +51,9 @@ type ObjectNode struct {
 
 // SeqNode is a sequence of nodes.
 type SeqNode struct {
-	Children []Node
 	sourcelessNode
+
+	Children []Node
 }
 
 // TrimNode is a trim object.

render/context.go

@@ -16,6 +16,7 @@ import (
 // Render renders the render tree.
 func Render(node Node, w io.Writer, vars map[string]any, c Config) Error {
 	tw := trimWriter{w: w}
+
 	err := node.render(&tw, newNodeContext(vars, c))
 	if err != nil {
 		return err

render/nodes.go

@@ -38,19 +38,19 @@ func makeAssignTag(cfg *render.Config) func(string) (func(io.Writer, render.Cont
 		}
 
 		// Check if dot notation is used without Jekyll extensions enabled
-		if len(stmt.Assignment.Path) > 1 && !cfg.JekyllExtensions {
+		if len(stmt.Path) > 1 && !cfg.JekyllExtensions {
 			return nil, errors.New("syntax error: dot notation in assign tag (e.g., 'obj.property = value') requires Jekyll extensions to be enabled")
 		}
 
 		return func(w io.Writer, ctx render.Context) error {
-			value, err := ctx.Evaluate(stmt.Assignment.ValueFn)
+			value, err := ctx.Evaluate(stmt.ValueFn)
 			if err != nil {
 				return err
 			}
 
 			// Use Path if available (dot notation), otherwise fall back to Variable (simple assignment)
-			if len(stmt.Assignment.Path) > 1 {
-				return ctx.SetPath(stmt.Assignment.Path, value)
+			if len(stmt.Path) > 1 {
+				return ctx.SetPath(stmt.Path, value)
 			}
 
 			// Simple assignment (backward compatibility and standard mode)