helpers.go

package parser

import (
	"github.com/ProCode-Software/klar/internal/ast"
	"github.com/ProCode-Software/klar/internal/klarerrs"
	"github.com/ProCode-Software/klar/internal/lexer"
	"github.com/ProCode-Software/klar/internal/ranges"
	"github.com/ProCode-Software/klar/pkg/printer"
)

func newOperator(t lexer.Token) ast.Operator {
	return ast.Operator{Kind: t.Kind, Position: t.Position}
}

// isEqual returns true if the current token is '='. If it is ':=', isEqual
// reports an error and still returns true.
func (p *Parser) isEqual(t lexer.Token) bool {
	switch t.Kind {
	case lexer.ColonEqual:
		p.Error(klarerrs.Token(klarerrs.ErrColonEqual, t))
		return true
	case lexer.Equal:
		return true
	}
	return false
}

func (p *Parser) ParseAssignable() ast.Assignable {
	if p.CurrKind() == lexer.Underscore {
		return rangeFromToken(&ast.Discard{}, p.Advance())
	}
	return p.validateAssignable(p.ParseExpression(ExpressionBindingPower))
}

func (p *Parser) lastTokEnd() lexer.Position {
	last := p.Tokens[p.Index-1]
	return last.End()
}

func (p *Parser) expectShorthand() (key *ast.Symbol, value ast.Expression) {
	var ok, isComputed bool
	sym := p.ParseExpression(ExpressionBindingPower)

	// Allowed if the expression inside is an index or symbol
	var old ast.Expression
	var inner *ast.Expression
	switch expr := sym.(type) {
	case *ast.AsExpression:
		old, inner = expr, &expr.Expression
		sym = expr.Expression
	case *ast.RestExpression:
		old, inner = expr, &expr.Expression
		sym = expr.Expression
	}

	switch sym := sym.(type) {
	case *ast.Symbol:
		key, value = sym, sym
		ok = true
	case *ast.IndexExpression:
		if sym.Computed {
			isComputed = true
			break
		}
		if prop, ok2 := sym.Property.(*ast.Symbol); ok2 {
			key, value = prop, sym
			ok = true
		}
		// TODO: In the future, functions could be allowed?
		// 	:value() for `value: value()`
		//  :info.name() for `name: info.name()`
	}
	if !ok {
		err := klarerrs.Node(klarerrs.ErrInvalidLabelShorthand, sym)
		err.Params = klarerrs.ErrorParams{"computed": isComputed}
		p.Error(err)
		return &ast.Symbol{}, &ast.BadExpression{}
	}
	if old != nil {
		*inner = value
		value = old
	}
	return key, value
}

// Range utils
func markEndPos[T ast.Node](p *Parser, node T) T {
	node.SetPos(node.GetRange().Start, p.lastTokEnd())
	return node
}

func markStartEndPos[T ast.Node](p *Parser, node T, start lexer.Position) T {
	node.SetPos(start, p.lastTokEnd())
	return node
}

func rangeFromToken[T ast.Node](node T, tok lexer.Token) T {
	rang := ranges.FromToken(tok)
	node.SetPos(rang.Start, rang.End)
	return node
}

func copyPos[F, T ast.Node](from F, to T) T {
	to.SetPos(from.GetRange().Start, from.GetRange().End)
	return to
}

func newBaseNode(start, end lexer.Position) ast.BaseNode {
	return ast.BaseNode{Range: ranges.Range{start, end}}
}

func isAssignment(kind lexer.TokenType) bool {
	switch kind {
	case lexer.Equal, lexer.ColonEqual, lexer.PlusEqual,
		lexer.MinusEqual, lexer.AsteriskEqual, lexer.SlashEqual,
		lexer.PercentEqual, lexer.CaretEqual:
		return true
	}
	return false
}

func printTokens(tok []lexer.Token) []byte {
	return printer.PrintTokens(tok, printer.PrettyPrint|printer.SingleLine)
}

func isComment(t lexer.TokenType) bool {
	switch t {
	case lexer.BlockComment, lexer.LineComment, lexer.Hashbang:
		return true
	}
	return false
}

// Reports [klarerrs.ErrCurlyQuote] if tok is a Unicode curly quote (single or double)
func (p *Parser) checkCurlyQuote(tok lexer.Token) bool {
	var alt string
	switch tok.Source {
	case "“", "”":
		alt = `"`
	case "‘", "’":
		alt = "'"
	default:
		return false
	}
	err := klarerrs.Token(klarerrs.ErrCurlyQuote, tok)
	err.SetParam("alt", alt)
	err.Hint("This may have been caused by smart quoting by a mobile keyboard or word processor, which automatically types curly quotation marks instead of straight ones. In Klar, strings are delimited by straight quotes.")
	p.Error(err)
	return true
}

func (p *Parser) checkIllegal(tok lexer.Token) bool {
	if p.checkCurlyQuote(tok) {
		return true
	}
	if tok.Attributes != nil {
		if _, ok := tok.Attributes["invalidCharacter"]; ok {
			p.Error(klarerrs.Token(klarerrs.ErrInvalidCharacter, tok))
			return true
		}
	}
	return false
}