text/template/parse: undo breaking API changes

golang.org/cl/84480 altered the API for the parse package for
clarity and consistency. However, the changes also broke the
API for consumers of the package. This CL reverts the API
to the previous spelling, adding only a single new exported
symbol.

Fixes #25968

Change-Id: Ieb81054b61eeac7df3bc3864ef446df43c26b80f
Reviewed-on: https://go-review.googlesource.com/120355
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/api/except.txt b/api/except.txt
index b85003eda237a41786b84baf88135899c46a81ea..e104f8e17b98b4af6d6dfa52ed44c56a6cdf25d3 100644 (file)
--- a/api/except.txt
+++ b/api/except.txt
@@ -362,15 +362,6 @@ pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
 pkg syscall (openbsd-amd64), const SYS_KILL = 37
 pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37
 pkg unicode, const Version = "9.0.0"
-pkg text/template/parse, method (*VariableNode) Copy() Node
-pkg text/template/parse, method (*VariableNode) String() string
-pkg text/template/parse, method (VariableNode) Position() Pos
-pkg text/template/parse, method (VariableNode) Type() NodeType
-pkg text/template/parse, type PipeNode struct, Decl []*VariableNode
-pkg text/template/parse, type VariableNode struct
-pkg text/template/parse, type VariableNode struct, Ident []string
-pkg text/template/parse, type VariableNode struct, embedded NodeType
-pkg text/template/parse, type VariableNode struct, embedded Pos
 pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
 pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
 pkg syscall (windows-386), type CertContext struct, CertInfo uintptr

diff --git a/src/html/template/escape.go b/src/html/template/escape.go
index 8517620d3c8af2b7ea77f27813622c1b0123a4b7..f12dafa870291a4b9089c5e1adbd4b7fb11f032a 100644 (file)
--- a/src/html/template/escape.go
+++ b/src/html/template/escape.go
@@ -142,7 +142,7 @@ func (e *escaper) escape(c context, n parse.Node) context {
 
 // escapeAction escapes an action template node.
 func (e *escaper) escapeAction(c context, n *parse.ActionNode) context {
-       if len(n.Pipe.Vars) != 0 {
+       if len(n.Pipe.Decl) != 0 {
                // A local variable assignment, not an interpolation.
                return c
        }

diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index 8f8b5fe218c7f9ba0bb6b4e881cb94693bbbb6e8..214f72d51b32ac258895cfb645584d1b1df47e49 100644 (file)
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -252,7 +252,7 @@ func (s *state) walk(dot reflect.Value, node parse.Node) {
                // Do not pop variables so they persist until next end.
                // Also, if the action declares variables, don't print the result.
                val := s.evalPipeline(dot, node.Pipe)
-               if len(node.Pipe.Vars) == 0 {
+               if len(node.Pipe.Decl) == 0 {
                        s.printValue(node, val)
                }
        case *parse.IfNode:
@@ -339,11 +339,11 @@ func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
        mark := s.mark()
        oneIteration := func(index, elem reflect.Value) {
                // Set top var (lexically the second if there are two) to the element.
-               if len(r.Pipe.Vars) > 0 {
+               if len(r.Pipe.Decl) > 0 {
                        s.setTopVar(1, elem)
                }
                // Set next var (lexically the first if there are two) to the index.
-               if len(r.Pipe.Vars) > 1 {
+               if len(r.Pipe.Decl) > 1 {
                        s.setTopVar(2, index)
                }
                s.walk(elem, r.List)
@@ -432,11 +432,11 @@ func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value ref
                        value = reflect.ValueOf(value.Interface()) // lovely!
                }
        }
-       for _, variable := range pipe.Vars {
-               if pipe.Decl {
-                       s.push(variable.Ident[0], value)
-               } else {
+       for _, variable := range pipe.Decl {
+               if pipe.IsAssign {
                        s.setVar(variable.Ident[0], value)
+               } else {
+                       s.push(variable.Ident[0], value)
                }
        }
        return value
@@ -461,7 +461,7 @@ func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final ref
        case *parse.PipeNode:
                // Parenthesized pipeline. The arguments are all inside the pipeline; final is ignored.
                return s.evalPipeline(dot, n)
-       case *parse.AssignNode:
+       case *parse.VariableNode:
                return s.evalVariableNode(dot, n, cmd.Args, final)
        }
        s.at(firstWord)
@@ -530,7 +530,7 @@ func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []
        return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
 }
 
-func (s *state) evalVariableNode(dot reflect.Value, variable *parse.AssignNode, args []parse.Node, final reflect.Value) reflect.Value {
+func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
        // $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields.
        s.at(variable)
        value := s.varValue(variable.Ident[0])
@@ -771,7 +771,7 @@ func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) refle
                s.errorf("cannot assign nil to %s", typ)
        case *parse.FieldNode:
                return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, missingVal), typ)
-       case *parse.AssignNode:
+       case *parse.VariableNode:
                return s.validateType(s.evalVariableNode(dot, arg, nil, missingVal), typ)
        case *parse.PipeNode:
                return s.validateType(s.evalPipeline(dot, arg), typ)
@@ -889,7 +889,7 @@ func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Valu
                return s.idealConstant(n)
        case *parse.StringNode:
                return reflect.ValueOf(n.Text)
-       case *parse.AssignNode:
+       case *parse.VariableNode:
                return s.evalVariableNode(dot, n, nil, missingVal)
        case *parse.PipeNode:
                return s.evalPipeline(dot, n)

diff --git a/src/text/template/parse/node.go b/src/text/template/parse/node.go
index 0bb96fc2e90234bc54dcb5b8f12e6b8add2ce61e..dca83dacceb4a032dd7b1cddc53cdfd9e8713afc 100644 (file)
--- a/src/text/template/parse/node.go
+++ b/src/text/template/parse/node.go
@@ -144,15 +144,15 @@ func (t *TextNode) Copy() Node {
 type PipeNode struct {
        NodeType
        Pos
-       tr   *Tree
-       Line int            // The line number in the input. Deprecated: Kept for compatibility.
-       Decl bool           // The variables are being declared, not assigned
-       Vars []*AssignNode  // Variables in lexical order.
-       Cmds []*CommandNode // The commands in lexical order.
+       tr       *Tree
+       Line     int             // The line number in the input. Deprecated: Kept for compatibility.
+       IsAssign bool            // The variables are being assigned, not declared.
+       Decl     []*VariableNode // Variables in lexical order.
+       Cmds     []*CommandNode  // The commands in lexical order.
 }
 
-func (t *Tree) newPipeline(pos Pos, line int, vars []*AssignNode) *PipeNode {
-       return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Vars: vars}
+func (t *Tree) newPipeline(pos Pos, line int, vars []*VariableNode) *PipeNode {
+       return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: vars}
 }
 
 func (p *PipeNode) append(command *CommandNode) {
@@ -161,8 +161,8 @@ func (p *PipeNode) append(command *CommandNode) {
 
 func (p *PipeNode) String() string {
        s := ""
-       if len(p.Vars) > 0 {
-               for i, v := range p.Vars {
+       if len(p.Decl) > 0 {
+               for i, v := range p.Decl {
                        if i > 0 {
                                s += ", "
                        }
@@ -187,12 +187,12 @@ func (p *PipeNode) CopyPipe() *PipeNode {
        if p == nil {
                return p
        }
-       var vars []*AssignNode
-       for _, d := range p.Vars {
-               vars = append(vars, d.Copy().(*AssignNode))
+       var vars []*VariableNode
+       for _, d := range p.Decl {
+               vars = append(vars, d.Copy().(*VariableNode))
        }
        n := p.tr.newPipeline(p.Pos, p.Line, vars)
-       n.Decl = p.Decl
+       n.IsAssign = p.IsAssign
        for _, c := range p.Cmds {
                n.append(c.Copy().(*CommandNode))
        }
@@ -321,18 +321,18 @@ func (i *IdentifierNode) Copy() Node {
 
 // AssignNode holds a list of variable names, possibly with chained field
 // accesses. The dollar sign is part of the (first) name.
-type AssignNode struct {
+type VariableNode struct {
        NodeType
        Pos
        tr    *Tree
        Ident []string // Variable name and fields in lexical order.
 }
 
-func (t *Tree) newVariable(pos Pos, ident string) *AssignNode {
-       return &AssignNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
+func (t *Tree) newVariable(pos Pos, ident string) *VariableNode {
+       return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
 }
 
-func (v *AssignNode) String() string {
+func (v *VariableNode) String() string {
        s := ""
        for i, id := range v.Ident {
                if i > 0 {
@@ -343,12 +343,12 @@ func (v *AssignNode) String() string {
        return s
 }
 
-func (v *AssignNode) tree() *Tree {
+func (v *VariableNode) tree() *Tree {
        return v.tr
 }
 
-func (v *AssignNode) Copy() Node {
-       return &AssignNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
+func (v *VariableNode) Copy() Node {
+       return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
 }
 
 // DotNode holds the special identifier '.'.

diff --git a/src/text/template/parse/parse.go b/src/text/template/parse/parse.go
index 34dc41c6202811dc8b78daa7730e5c594071b9d0..cb9b44e9da003a43f2aefcfde8e28cedfd708efd 100644 (file)
--- a/src/text/template/parse/parse.go
+++ b/src/text/template/parse/parse.go
@@ -384,7 +384,7 @@ func (t *Tree) action() (n Node) {
 //     declarations? command ('|' command)*
 func (t *Tree) pipeline(context string) (pipe *PipeNode) {
        decl := false
-       var vars []*AssignNode
+       var vars []*VariableNode
        token := t.peekNonSpace()
        pos := token.pos
        // Are there declarations or assignments?
@@ -422,7 +422,7 @@ func (t *Tree) pipeline(context string) (pipe *PipeNode) {
                break
        }
        pipe = t.newPipeline(pos, token.line, vars)
-       pipe.Decl = decl
+       pipe.IsAssign = !decl
        for {
                switch token := t.nextNonSpace(); token.typ {
                case itemRightDelim, itemRightParen: