detect '_' as special discard syntax in assignments

Author: sauerbraten

constructors.go

@@ -238,3 +238,7 @@ func (t *Template) newNumber(pos Pos, text string, typ itemType) (*NumberNode, e
 func (t *Template) newIdentifier(ident string, pos Pos, line int) *IdentifierNode {
 	return &IdentifierNode{NodeBase: NodeBase{TemplatePath: t.Name, NodeType: NodeIdentifier, Pos: pos, Line: line}, Ident: ident}
 }
+
+func (t *Template) newDiscard(pos Pos, line int) *DiscardNode {
+	return &DiscardNode{NodeBase: NodeBase{TemplatePath: t.Name, NodeType: NodeDiscard, Pos: pos, Line: line}}
+}

eval.go

@@ -284,34 +284,44 @@ RESTART:
 func (st *Runtime) executeSetList(set *SetNode) {
 	if set.IndexExprGetLookup {
 		value := st.evalPrimaryExpressionGroup(set.Right[0])
-		st.executeSet(set.Left[0], value)
-		if value.IsValid() {
-			st.executeSet(set.Left[1], valueBoolTRUE)
-		} else {
-			st.executeSet(set.Left[1], valueBoolFALSE)
+		if set.Left[0].Type() != NodeDiscard {
+			st.executeSet(set.Left[0], value)
+		}
+		if set.Left[1].Type() != NodeDiscard {
+			if value.IsValid() {
+				st.executeSet(set.Left[1], valueBoolTRUE)
+			} else {
+				st.executeSet(set.Left[1], valueBoolFALSE)
+			}
 		}
 	} else {
 		for i := 0; i < len(set.Left); i++ {
-			st.executeSet(set.Left[i], st.evalPrimaryExpressionGroup(set.Right[i]))
+			value := st.evalPrimaryExpressionGroup(set.Right[i])
+			if set.Left[i].Type() != NodeDiscard {
+				st.executeSet(set.Left[i], value)
+			}
 		}
 	}
 }
 
 func (st *Runtime) executeLetList(set *SetNode) {
 	if set.IndexExprGetLookup {
 		value := st.evalPrimaryExpressionGroup(set.Right[0])
-
-		st.variables[set.Left[0].(*IdentifierNode).Ident] = value
-
-		if value.IsValid() {
-			st.variables[set.Left[1].(*IdentifierNode).Ident] = valueBoolTRUE
-		} else {
-			st.variables[set.Left[1].(*IdentifierNode).Ident] = valueBoolFALSE
+		if set.Left[0].Type() != NodeDiscard {
+			st.variables[set.Left[0].(*IdentifierNode).Ident] = value
+		}
+		if set.Left[1].Type() != NodeDiscard {
+			if value.IsValid() {
+				st.variables[set.Left[1].(*IdentifierNode).Ident] = valueBoolTRUE
+			} else {
+				st.variables[set.Left[1].(*IdentifierNode).Ident] = valueBoolFALSE
+			}
 		}
-
 	} else {
 		for i := 0; i < len(set.Left); i++ {
-			st.variables[set.Left[i].(*IdentifierNode).Ident] = st.evalPrimaryExpressionGroup(set.Right[i])
+			if set.Left[i].Type() != NodeDiscard {
+				st.variables[set.Left[i].(*IdentifierNode).Ident] = st.evalPrimaryExpressionGroup(set.Right[i])
+			}
 		}
 	}
 }

eval_test.go

@@ -184,7 +184,7 @@ func TestEvalActionNode(t *testing.T) {
 	RunJetTest(t, data, nil, "actionNode_NumberNegative", `{{ -5 }}`, "-5")
 	RunJetTest(t, data, nil, "actionNode_NumberNegative_1", `{{ 1 + -5 }}`, fmt.Sprint(1+-5))
 
-	//this is an error RunJetTest(t, data, nil, "actionNode_AddStringInt", `{{ "1"-2 }}`, "12")
+	//this must be an error RunJetTest(t, data, nil, "actionNode_AddStringInt", `{{ "1"-2 }}`, "12")
 
 	RunJetTest(t, data, nil, "actionNode_Mult", `{{ 4*4 }}`, fmt.Sprint(4*4))
 	RunJetTest(t, data, nil, "actionNode_MultAdd", `{{ 2+4*4 }}`, fmt.Sprint(2+4*4))
@@ -203,6 +203,21 @@ func TestEvalActionNode(t *testing.T) {
 	RunJetTest(t, data, nil, "actionNode_NumericCmp", `{{ 5*5 > 2*12.5 }}`, fmt.Sprint(5*5 > 2*12.5))
 	RunJetTest(t, data, nil, "actionNode_NumericCmp1", `{{ 5*5 >= 2*12.5 }}`, fmt.Sprint(5*5 >= 2*12.5))
 	RunJetTest(t, data, nil, "actionNode_NumericCmp1", `{{ 5 * 5 > 2 * 12.5 == 5 * 5 > 2 * 12.5 }}`, fmt.Sprint((5*5 > 2*12.5) == (5*5 > 2*12.5)))
+
+	// test discard syntax in assignments
+	called := false
+	markCalled := func() { called = true }
+	data.Set("foo", markCalled)
+	data.Set("called", &called)
+	RunJetTest(t, data, nil, "actionNode_assign_discard", `{{ _ = foo() ; called }}`, "true")
+	if !called {
+		t.Log("function whose value should be evaluated but discarded was never called!")
+		t.Fail()
+	}
+	if _, ok := data["_"]; ok {
+		t.Log("a variable with name '_' was set!")
+		t.Fail()
+	}
 }
 
 func TestEvalIfNode(t *testing.T) {

lex.go

@@ -82,6 +82,7 @@ const (
 	itemTernary
 	itemLeftBrackets
 	itemRightBrackets
+	itemUnderscore
 	// Keywords appear after all the rest.
 	itemKeyword // used only to delimit the keywords
 	itemExtends
@@ -346,7 +347,7 @@ func lexInsideAction(l *lexer) stateFn {
 		if l.parenDepth == 0 {
 			return lexRightDelim
 		}
-		return l.errorf("unclosed left paren")
+		return l.errorf("unclosed left parenthesis")
 	}
 	switch r := l.next(); {
 	case r == eof:
@@ -467,6 +468,12 @@ func lexInsideAction(l *lexer) stateFn {
 	case '0' <= r && r <= '9':
 		l.backup()
 		return lexNumber
+	case r == '_':
+		if isSpace(l.peek()) {
+			l.emit(itemUnderscore)
+			return lexInsideAction
+		}
+		fallthrough // no space? must be the start of an identifier
 	case isAlphaNumeric(r):
 		l.backup()
 		return lexIdentifier
@@ -485,7 +492,6 @@ func lexInsideAction(l *lexer) stateFn {
 		}
 	case r <= unicode.MaxASCII && unicode.IsPrint(r):
 		l.emit(itemChar)
-		return lexInsideAction
 	default:
 		return l.errorf("unrecognized character in action: %#U", r)
 	}

lex_test.go

@@ -65,6 +65,7 @@ func TestLexer(t *testing.T) {
 	lexerTestCase(t, `{{.Ex!1}}`, itemLeftDelim, itemField, itemNot, itemNumber, itemRightDelim)
 	lexerTestCase(t, `{{.Ex==1}}`, itemLeftDelim, itemField, itemEquals, itemNumber, itemRightDelim)
 	lexerTestCase(t, `{{.Ex&&1}}`, itemLeftDelim, itemField, itemAnd, itemNumber, itemRightDelim)
+	lexerTestCase(t, `{{ _ = foo }}`, itemLeftDelim, itemUnderscore, itemAssign, itemIdentifier, itemRightDelim)
 }
 
 func TestCustomDelimiters(t *testing.T) {

node.go

@@ -77,6 +77,7 @@ const (
 	NodeCommand                    //An element of a pipeline.
 	NodeField                      //A field or method name.
 	NodeIdentifier                 //An identifier; always a function name.
+	NodeDiscard                    //An underscore
 	NodeList                       //A list of Nodes.
 	NodePipe                       //A pipeline of commands.
 	NodeSet
@@ -215,6 +216,15 @@ func (i *IdentifierNode) String() string {
 	return i.Ident
 }
 
+// DiscardNode signals to discard the corresponding right side of an assignment.
+type DiscardNode struct {
+	NodeBase
+}
+
+func (i *DiscardNode) String() string {
+	return "_"
+}
+
 // NilNode holds the special identifier 'nil' representing an untyped nil constant.
 type NilNode struct {
 	NodeBase

parse.go

@@ -619,7 +619,7 @@ func (t *Template) assignmentOrExpression(context string) (operand Expression) {
 	leftloop:
 		for {
 			switch operand.Type() {
-			case NodeField, NodeChain, NodeIdentifier:
+			case NodeField, NodeChain, NodeIdentifier, NodeDiscard:
 				left = append(left, operand)
 			default:
 				t.errorf("unexpected node in assign")
@@ -638,7 +638,7 @@ func (t *Template) assignmentOrExpression(context string) (operand Expression) {
 
 		if isLet {
 			for _, operand := range left {
-				if operand.Type() != NodeIdentifier {
+				if operand.Type() != NodeIdentifier && operand.Type() != NodeDiscard {
 					t.errorf("unexpected node type %s in variable declaration", operand)
 				}
 			}
@@ -974,6 +974,8 @@ func (t *Template) term() Node {
 		t.errorf("%s", token.val)
 	case itemIdentifier:
 		return t.newIdentifier(token.val, token.pos, t.lex.lineNumber())
+	case itemUnderscore:
+		return t.newDiscard(token.pos, t.lex.lineNumber())
 	case itemNil:
 		return t.newNil(token.pos)
 	case itemField:

testData/assignment.jet

@@ -2,8 +2,14 @@
 {{ newName := name; safeHtml: newName, " ", "new name" }}
 {{ newName,newValue := name,value }}
 {{ value,found := name["key"] }}
+{{ _ := foo() }}
+{{ _ = foo() }}
+{{ _, _ = name["key"] }}
 ===
 {{newURL:=url("", "").Method("");newURL | pipe}}
 {{newName:=name;safeHtml(newName, " ", "new name")}}
 {{newName, newValue:=name, value}}
-{{value, found:=name["key"]}}
+{{value, found:=name["key"]}}
+{{_:=foo()}}
+{{_=foo()}}
+{{_, _=name["key"]}}