code review 6459056: text/template: add 'nil' as a keyword in the language

src/pkg/text/template/parse/node.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Parse nodes.
 
 package parse
 
 import (
         "bytes"
@@ skipping 26 matching lines @@
         NodeAction                     // A simple action such as field evaluation.
         NodeBool                       // A boolean constant.
         NodeCommand                    // An element of a pipeline.
         NodeDot                        // The cursor, dot.
         nodeElse                       // An else action. Not added to tree.
         nodeEnd                        // An end action. Not added to tree.
         NodeField                      // A field or method name.
         NodeIdentifier                 // An identifier; always a function name.
         NodeIf                         // An if action.
         NodeList                       // A list of Nodes.
+        NodeNil                        // An untyped nil constant.
         NodeNumber                     // A numerical constant.
         NodePipe                       // A pipeline of commands.
         NodeRange                      // A range action.
         NodeString                     // A string constant.
         NodeTemplate                   // A template invocation action.
         NodeVariable                   // A $ variable.
         NodeWith                       // A with action.
 )
 
 // Nodes.
@@ skipping 224 matching lines @@
 }
 
 func (d *DotNode) String() string {
         return "."
 }
 
 func (d *DotNode) Copy() Node {
         return newDot()
 }
 
+// NilNode holds the special identifier 'nil' representing an untyped nil constant.
+// It is represented by a nil pointer.
+type NilNode bool
+
+func newNil() *NilNode {
+        return nil
+}
+
+func (d *NilNode) Type() NodeType {
+        return NodeNil
+}
+
+func (d *NilNode) String() string {
+        return "nil"
+}
+
+func (d *NilNode) Copy() Node {
+        return newNil()
+}
+
 // FieldNode holds a field (identifier starting with '.').
 // The names may be chained ('.x.y').
 // The period is dropped from each ident.
 type FieldNode struct {
         NodeType
         Ident []string // The identifiers in lexical order.
 }
 
 func newField(ident string) *FieldNode {
         return &FieldNode{NodeType: NodeField, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
@@ skipping 298 matching lines @@
 func (t *TemplateNode) String() string {
         if t.Pipe == nil {
                 return fmt.Sprintf("{{template %q}}", t.Name)
         }
         return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
 }
 
 func (t *TemplateNode) Copy() Node {
         return newTemplate(t.Line, t.Name, t.Pipe.CopyPipe())
 }