all: remove the dollar identifier

gazerro · gazerro · commit 2ecde7b004f8 · 2022-07-05T16:11:45.000+02:00
Dollar identifier was a deprecated feature, this change removes it.
diff --git a/ast/ast.go b/ast/ast.go
@@ -699,27 +699,6 @@ func (n *Defer) String() string {
 	return "defer " + n.Call.String()
 }
 
-// DollarIdentifier node represents a dollar identifier in the form  $id.
-type DollarIdentifier struct {
-	*expression
-	*Position             // position in the source.
-	Ident     *Identifier // identifier.
-
-	IR struct {
-		Ident Expression
-	}
-}
-
-// NewDollarIdentifier returns a new DollarIdentifier node.
-func NewDollarIdentifier(pos *Position, ident *Identifier) *DollarIdentifier {
-	return &DollarIdentifier{&expression{}, pos, ident, struct{ Ident Expression }{}}
-}
-
-// String returns the string representation of n.
-func (n *DollarIdentifier) String() string {
-	return "$" + n.Ident.String()
-}
-
 // Extends node represents an "extends" declaration.
 type Extends struct {
 	*Position        // position in the source.
diff --git a/ast/astutil/clone.go b/ast/astutil/clone.go
@@ -393,9 +393,6 @@ func CloneExpression(expr ast.Expression) ast.Expression {
 	case *ast.Default:
 		expr2 = ast.NewDefault(ClonePosition(e.Position), CloneExpression(e.Expr1), CloneExpression(e.Expr2))
 
-	case *ast.DollarIdentifier:
-		expr2 = ast.NewDollarIdentifier(ClonePosition(e.Position), CloneExpression(e.Ident).(*ast.Identifier))
-
 	case *ast.Func:
 		var ident *ast.Identifier
 		if e.Ident != nil {
diff --git a/ast/astutil/dump_test.go b/ast/astutil/dump_test.go
@@ -28,7 +28,7 @@ func ExampleDump() {
 	}
 
 	for _, c := range cases {
-		tree, _, err := compiler.ParseTemplateSource([]byte(c), ast.FormatHTML, false, false, false)
+		tree, _, err := compiler.ParseTemplateSource([]byte(c), ast.FormatHTML, false, false)
 		if err != nil {
 			panic(err)
 		}
diff --git a/ast/astutil/walk.go b/ast/astutil/walk.go
@@ -108,9 +108,6 @@ func Walk(v Visitor, node ast.Node) {
 		Walk(v, n.Expr1)
 		Walk(v, n.Expr2)
 
-	case *ast.DollarIdentifier:
-		Walk(v, n.Ident)
-
 	case *ast.For:
 		if n.Init != nil {
 			Walk(v, n.Init)
diff --git a/ast/astutil/walk_test.go b/ast/astutil/walk_test.go
@@ -62,7 +62,7 @@ func TestWalk(t *testing.T) {
 	}
 
 	for _, c := range stringCases {
-		tree, _, err := compiler.ParseTemplateSource([]byte(c.input), ast.FormatHTML, false, false, false)
+		tree, _, err := compiler.ParseTemplateSource([]byte(c.input), ast.FormatHTML, false, false)
 		if err != nil {
 			panic(err)
 		}
diff --git a/internal/compiler/checker_dependencies.go b/internal/compiler/checker_dependencies.go
@@ -332,10 +332,6 @@ func (d *deps) nodeDeps(n ast.Node, scopes depScopes) []*ast.Identifier {
 			deps = append(deps, d.nodeDeps(out.Type, scopes)...)
 		}
 		return deps
-	case *ast.DollarIdentifier:
-		// A valid dollar identifier can at most depend upon global
-		// identifiers, so it is not considered in the dependency analysis.
-		return nil
 	case *ast.Go:
 		return d.nodeDeps(n.Call, scopes)
 	case *ast.Goto:
diff --git a/internal/compiler/checker_expressions.go b/internal/compiler/checker_expressions.go
@@ -455,9 +455,6 @@ func (tc *typechecker) typeof(expr ast.Expression, typeExpected bool) *typeInfo
 		}
 		return t
 
-	case *ast.DollarIdentifier:
-		return tc.checkDollarIdentifier(expr)
-
 	case *ast.Identifier:
 		return tc.checkIdentifier(expr, true)
 
@@ -2208,51 +2205,6 @@ func (tc *typechecker) isCompileConstant(expr ast.Expression) bool {
 	return true
 }
 
-// checkDollarIdentifier type checks a dollar identifier $x.
-func (tc *typechecker) checkDollarIdentifier(expr *ast.DollarIdentifier) *typeInfo {
-
-	// Check that x is a valid identifier.
-	if ti, _, ok := tc.scopes.Lookup(expr.Ident.Name); ok {
-		// Check that x is not a builtin function.
-		if ti.IsBuiltinFunction() {
-			panic(tc.errorf(expr.Ident, "use of builtin %s not in function call", expr.Ident))
-		}
-		// Check that x is not a type.
-		if ti.IsType() {
-			panic(tc.errorf(expr.Ident, "unexpected type in dollar identifier"))
-		}
-		// Check that x is not a local identifier.
-		if _, _, ok := tc.scopes.LookupInFunc(expr.Ident.Name); ok {
-			panic(tc.errorf(expr, "use of local identifier within dollar identifier"))
-		}
-		// Check that x is not declared in the file/package block, that
-		// contains, for example, the variable declarations at the top level of
-		// an imported or extending file.
-		if _, ok := tc.scopes.FilePackage(expr.Ident.Name); ok {
-			panic(tc.errorf(expr, "use of top-level identifier within dollar identifier"))
-		}
-	}
-
-	// Set the IR of the expression.
-	var arg *ast.Identifier
-	var pos = expr.Pos()
-	if _, ok := tc.scopes.Global(expr.Ident.Name); ok {
-		arg = expr.Ident // "x"
-	} else {
-		arg = ast.NewIdentifier(pos, "nil") // "nil"
-	}
-	// expr.IR.Ident is set to "interface{}(x)" or "interface{}(nil)".
-	expr.IR.Ident = ast.NewCall(
-		pos,
-		ast.NewInterface(pos), // "interface{}"
-		[]ast.Expression{arg}, // "x" or "nil"
-		false,
-	)
-
-	// Type check the IR of the expression and return its type info.
-	return tc.checkExpr(expr.IR.Ident)
-}
-
 // checkDefault type checks a default expression. show indicates if the
 // default expression is in a show statement.
 func (tc *typechecker) checkDefault(expr *ast.Default, show bool) typeInfoPair {
diff --git a/internal/compiler/checker_template_test.go b/internal/compiler/checker_template_test.go
@@ -168,7 +168,7 @@ func TestCheckerTemplateExpressions(t *testing.T) {
 	}
 	options := checkerOptions{mod: templateMod, formatTypes: formatTypes, mdConverter: mdConverter}
 	for _, expr := range checkerTemplateExprs {
-		var lex = scanTemplate([]byte("{{ "+expr.src+" }}"), ast.FormatText, false, false)
+		var lex = scanTemplate([]byte("{{ "+expr.src+" }}"), ast.FormatText, false)
 		func() {
 			defer func() {
 				if r := recover(); r != nil {
@@ -241,7 +241,7 @@ var checkerTemplateExprErrors = []struct {
 func TestCheckerTemplateExpressionErrors(t *testing.T) {
 	options := checkerOptions{mod: templateMod, formatTypes: formatTypes}
 	for _, expr := range checkerTemplateExprErrors {
-		var lex = scanTemplate([]byte("{{ "+expr.src+" }}"), ast.FormatText, false, false)
+		var lex = scanTemplate([]byte("{{ "+expr.src+" }}"), ast.FormatText, false)
 		func() {
 			defer func() {
 				if r := recover(); r != nil {
diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
@@ -62,13 +62,6 @@ type Options struct {
 	AllowGoStmt          bool
 	NoParseShortShowStmt bool
 
-	// DollarIdentifier, when true, keeps the backward compatibility by
-	// supporting the dollar identifier.
-	//
-	// NOTE: the dollar identifier is deprecated and will be removed in a
-	// future version of Scriggo.
-	DollarIdentifier bool
-
 	FormatTypes map[ast.Format]reflect.Type
 	Globals     native.Declarations
 
@@ -166,7 +159,7 @@ func BuildTemplate(fsys fs.FS, name string, opts Options) (*Code, error) {
 
 	// Parse the source code.
 	var err error
-	tree, err = ParseTemplate(fsys, name, opts.NoParseShortShowStmt, opts.DollarIdentifier)
+	tree, err = ParseTemplate(fsys, name, opts.NoParseShortShowStmt)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/compiler/emitter_expressions.go b/internal/compiler/emitter_expressions.go
@@ -150,16 +150,6 @@ func (em *emitter) _emitExpr(expr ast.Expression, dstType reflect.Type, reg int8
 
 		return em.emitCompositeLiteral(expr, reg, dstType)
 
-	case *ast.DollarIdentifier:
-
-		// The field expr.IR.Ident has been set by the type checker; it may be
-		// interface{}(x) if x is an existing global identifier, or
-		// interface{}(nil) otherwise.
-		//
-		// So, the emission of a dollar identifier can be done simply by
-		// emitting expr.IR.Ident.
-		return em._emitExpr(expr.IR.Ident, dstType, reg, useGivenReg, allowK)
-
 	case *ast.Default:
 		ex := expr.Expr1
 		if ti := em.ti(expr.Expr1); ti == nil {
diff --git a/internal/compiler/lexer.go b/internal/compiler/lexer.go
@@ -33,18 +33,17 @@ func scanProgram(text []byte) *lexer {
 }
 
 // scanTemplate scans a template file and returns a lexer.
-func scanTemplate(text []byte, format ast.Format, noParseShow, dollarIdentifier bool) *lexer {
+func scanTemplate(text []byte, format ast.Format, noParseShow bool) *lexer {
 	tokens := make(chan token, 20)
 	lex := &lexer{
-		text:             text,
-		src:              text,
-		line:             1,
-		column:           1,
-		ctx:              ast.Context(format),
-		tokens:           tokens,
-		templateSyntax:   true,
-		dollarIdentifier: dollarIdentifier,
-		noParseShow:      noParseShow,
+		text:           text,
+		src:            text,
+		line:           1,
+		column:         1,
+		ctx:            ast.Context(format),
+		tokens:         tokens,
+		templateSyntax: true,
+		noParseShow:    noParseShow,
 	}
 	lex.tag.ctx = ast.ContextHTML
 	if lex.ctx == ast.ContextMarkdown {
@@ -89,14 +88,13 @@ type lexer struct {
 		index int         // index of first byte of the current attribute value in src
 		ctx   ast.Context // context of the tag's content
 	}
-	rawMarker        []byte     // raw marker, not nil when a raw statement has been lexed
-	tokens           chan token // tokens, is closed at the end of the scan
-	lastTokenType    tokenTyp   // type of the last non-empty emitted token
-	totals           int        // total number of emitted tokens, excluding automatically inserted semicolons
-	err              error      // error, reports whether there was an error
-	templateSyntax   bool       // support template syntax.
-	dollarIdentifier bool       // support the dollar identifier, only if 'templateSyntax' is true
-	noParseShow      bool       // do not parse the short show statement.
+	rawMarker      []byte     // raw marker, not nil when a raw statement has been lexed
+	tokens         chan token // tokens, is closed at the end of the scan
+	lastTokenType  tokenTyp   // type of the last non-empty emitted token
+	totals         int        // total number of emitted tokens, excluding automatically inserted semicolons
+	err            error      // error, reports whether there was an error
+	templateSyntax bool       // support template syntax.
+	noParseShow    bool       // do not parse the short show statement.
 }
 
 // newline is called when the lexer encounters a new line.
@@ -1204,14 +1202,6 @@ LOOP:
 				l.column++
 			}
 			endLineAsSemicolon = false
-		case '$':
-			if l.templateSyntax && l.dollarIdentifier {
-				l.emit(tokenDollar, 1)
-				l.column++
-				endLineAsSemicolon = false
-			} else {
-				return l.errorf("invalid character U+0024 '$'")
-			}
 		case '(':
 			l.emit(tokenLeftParenthesis, 1)
 			l.column++
diff --git a/internal/compiler/lexer_test.go b/internal/compiler/lexer_test.go
@@ -174,7 +174,6 @@ var typeTestsText = map[string][]tokenTyp{
 		tokenAmpersand, tokenIdentifier, tokenLeftParenthesis, tokenInt, tokenRightParenthesis, tokenRightBraces},
 	"{{ *a }}":              {tokenLeftBraces, tokenMultiplication, tokenIdentifier, tokenRightBraces},
 	"{{ []*int{} }}":        {tokenLeftBraces, tokenLeftBracket, tokenRightBracket, tokenMultiplication, tokenIdentifier, tokenLeftBrace, tokenRightBrace, tokenRightBraces},
-	"{{ $a }}":              {tokenLeftBraces, tokenDollar, tokenIdentifier, tokenRightBraces},
 	"{{ a[\"5\"] }}":        {tokenLeftBraces, tokenIdentifier, tokenLeftBracket, tokenInterpretedString, tokenRightBracket, tokenRightBraces},
 	"{{ a[:] }}":            {tokenLeftBraces, tokenIdentifier, tokenLeftBracket, tokenColon, tokenRightBracket, tokenRightBraces},
 	"{{ a[:8] }}":           {tokenLeftBraces, tokenIdentifier, tokenLeftBracket, tokenColon, tokenInt, tokenRightBracket, tokenRightBraces},
@@ -595,7 +594,7 @@ TYPES:
 	for source, types := range test {
 		var lex *lexer
 		if isTemplate {
-			lex = scanTemplate([]byte(source), format, false, true)
+			lex = scanTemplate([]byte(source), format, false)
 		} else {
 			lex = scanProgram([]byte(source))
 		}
@@ -684,7 +683,7 @@ func TestLexerMacroOrUsingContexts(t *testing.T) {
 CONTEXTS:
 	for source, contexts := range macroAndUsingContextTests {
 		text := []byte(source)
-		lex := scanTemplate(text, ast.FormatText, false, false)
+		lex := scanTemplate(text, ast.FormatText, false)
 		var i int
 		for tok := range lex.Tokens() {
 			if tok.typ == tokenEOF {
@@ -714,7 +713,7 @@ CONTEXTS:
 
 func TestPositions(t *testing.T) {
 	for _, test := range positionTests {
-		var lex = scanTemplate([]byte(test.src), ast.FormatHTML, false, false)
+		var lex = scanTemplate([]byte(test.src), ast.FormatHTML, false)
 		var i int
 		for tok := range lex.Tokens() {
 			if tok.typ == tokenEOF {
@@ -847,7 +846,7 @@ func TestLexRawContent(t *testing.T) {
 }
 
 func TestNoParseShow(t *testing.T) {
-	var lex = scanTemplate([]byte("a{{ v }}b"), ast.FormatHTML, true, false)
+	var lex = scanTemplate([]byte("a{{ v }}b"), ast.FormatHTML, true)
 	tokens := lex.Tokens()
 	if tok := <-tokens; tok.typ != tokenText {
 		t.Errorf("unexpected token %s, expecting text", tok)
diff --git a/internal/compiler/parser.go b/internal/compiler/parser.go
@@ -236,7 +236,7 @@ func parseSource(src []byte, noPackage bool) (tree *ast.Tree, err error) {
 //
 // format can be Text, HTML, CSS, JS, JSON and Markdown. imported indicates
 // whether it is imported.
-func ParseTemplateSource(src []byte, format ast.Format, imported, noParseShow, dollarIdentifier bool) (tree *ast.Tree, unexpanded []ast.Node, err error) {
+func ParseTemplateSource(src []byte, format ast.Format, imported, noParseShow bool) (tree *ast.Tree, unexpanded []ast.Node, err error) {
 
 	if format < ast.FormatText || format > ast.FormatMarkdown {
 		return nil, nil, errors.New("scriggo: invalid format")
@@ -245,7 +245,7 @@ func ParseTemplateSource(src []byte, format ast.Format, imported, noParseShow, d
 	tree = ast.NewTree("", nil, format)
 
 	var p = &parsing{
-		lex:        scanTemplate(src, format, noParseShow, dollarIdentifier),
+		lex:        scanTemplate(src, format, noParseShow),
 		format:     format,
 		imported:   imported,
 		ancestors:  []ast.Node{tree},
diff --git a/internal/compiler/parser_cycle_test.go b/internal/compiler/parser_cycle_test.go
@@ -168,7 +168,7 @@ var cycleTemplateTests = []struct {
 func TestCyclicTemplates(t *testing.T) {
 	for _, test := range cycleTemplateTests {
 		t.Run(test.name, func(t *testing.T) {
-			_, err := ParseTemplate(test.fsys, "index.html", false, false)
+			_, err := ParseTemplate(test.fsys, "index.html", false)
 			if err == nil {
 				t.Fatal("expecting cycle error, got no error")
 			}
diff --git a/internal/compiler/parser_expressions.go b/internal/compiler/parser_expressions.go
@@ -162,18 +162,6 @@ func (p *parsing) parseExpr(tok token, canBeSwitchGuard, canElideType, mustBeTyp
 				panic(syntaxError(tok.pos, "unexpected %s, expecting type", tok.txt))
 			}
 			tok = p.next()
-		case tokenDollar: // $id
-			pos := tok.pos
-			tok = p.next()
-			if tok.typ != tokenIdentifier {
-				panic(syntaxError(tok.pos, "unexpected %s, expecting name", tok.txt))
-			}
-			if len(tok.txt) == 1 && tok.txt[0] == '_' {
-				panic(syntaxError(tok.pos, "cannot use _ as value"))
-			}
-			ident := p.parseIdentifierNode(tok)
-			operand = ast.NewDollarIdentifier(pos.WithEnd(tok.pos.End), ident)
-			tok = p.next()
 		case
 			tokenRune,      // '\x3c'
 			tokenInt,       // 18
diff --git a/internal/compiler/parser_expressions_test.go b/internal/compiler/parser_expressions_test.go
@@ -128,11 +128,6 @@ var exprTests = []struct {
 			ast.NewIdentifier(p(1, 10, 9, 9), "b"),
 		),
 	)},
-	{"$a", ast.NewDollarIdentifier(p(1, 1, 0, 1), ast.NewIdentifier(p(1, 2, 1, 1), "a"))},
-	{"$a.(string)", ast.NewTypeAssertion(p(1, 3, 0, 10),
-		ast.NewDollarIdentifier(p(1, 1, 0, 1), ast.NewIdentifier(p(1, 2, 1, 1), "a")),
-		ast.NewIdentifier(p(1, 5, 4, 9), "string")),
-	},
 	{"a contains b", ast.NewBinaryOperator(p(1, 3, 0, 11), ast.OperatorContains,
 		ast.NewIdentifier(p(1, 1, 0, 0), "a"),
 		ast.NewIdentifier(p(1, 12, 11, 11), "b")),
@@ -631,7 +626,7 @@ var exprTests = []struct {
 
 func TestExpressions(t *testing.T) {
 	for _, expr := range exprTests {
-		var lex = scanTemplate([]byte("{{"+expr.src+"}}"), ast.FormatText, false, true)
+		var lex = scanTemplate([]byte("{{"+expr.src+"}}"), ast.FormatText, false)
 		<-lex.Tokens()
 		func() {
 			defer func() {
diff --git a/internal/compiler/parser_template.go b/internal/compiler/parser_template.go
diff --git a/internal/compiler/parser_test.go b/internal/compiler/parser_test.go
diff --git a/internal/compiler/tokens.go b/internal/compiler/tokens.go
diff --git a/programs.go b/programs.go
diff --git a/templates.go b/templates.go
diff --git a/test/misc/templates_test.go b/test/misc/templates_test.go

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ func ExampleDump() {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`for _, c := range cases {`
`31`		`- tree, _, err := compiler.ParseTemplateSource([]byte(c), ast.FormatHTML, false, false, false)`
	`31`	`+ tree, _, err := compiler.ParseTemplateSource([]byte(c), ast.FormatHTML, false, false)`
`32`	`32`	`if err != nil {`
`33`	`33`	`panic(err)`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ func TestWalk(t *testing.T) {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`for _, c := range stringCases {`
`65`		`- tree, _, err := compiler.ParseTemplateSource([]byte(c.input), ast.FormatHTML, false, false, false)`
	`65`	`+ tree, _, err := compiler.ParseTemplateSource([]byte(c.input), ast.FormatHTML, false, false)`
`66`	`66`	`if err != nil {`
`67`	`67`	`panic(err)`
`68`	`68`	`}`