format.go

package javascript

import (
	"fmt"
	"io"
	"strings"
	"unicode/utf8"
	"unsafe"

	"vimagination.zapto.org/javascript/internal"
	"vimagination.zapto.org/parser"
)

var (
	indent    = []byte{'\t'}
	semiColon = []byte{';'}
)

type writer interface {
	io.Writer
	WriteString(string)
	WriteStringWithType(string, parser.TokenType)
	WriteToken(*Token)
	Underlying() writer
	PrintSemiColon()
	LastChar() byte
	LastIsWhitespace() bool
	Pos() int
	Indent() writer
	Printf(string, ...any)
	Start(Tokens)
	End()
}

type indentPrinter struct {
	writer
	hadNewline bool
}

func (i *indentPrinter) Write(p []byte) (int, error) {
	var (
		total int
		last  int
	)

	for n, c := range p {
		if c == '\n' {
			if last != n {
				if err := i.printIndent(); err != nil {
					return total, err
				}
			}

			m, err := i.writer.Write(p[last : n+1])
			total += m

			if err != nil {
				return total, err
			}

			i.hadNewline = true
			last = n + 1
		}
	}

	if last != len(p) {
		if err := i.printIndent(); err != nil {
			return total, err
		}

		m, err := i.writer.Write(p[last:])
		total += m

		if err != nil {
			return total, err
		}
	}

	return total, nil
}

func (i *indentPrinter) printIndent() error {
	if i.hadNewline {
		if _, err := i.writer.Write(indent); err != nil {
			return err
		}

		i.hadNewline = false
	}

	return nil
}

func (i *indentPrinter) Printf(format string, args ...any) {
	fmt.Fprintf(i, format, args...)
}

func (i *indentPrinter) WriteString(s string) {
	i.Write(unsafe.Slice(unsafe.StringData(s), len(s)))
}

func (i *indentPrinter) WriteStringWithType(s string, tt parser.TokenType) {
	var w writer = i

	switch tt {
	case TokenNoSubstitutionTemplate, TokenTemplateHead:
		if len(s) > 0 {
			i.WriteString(s[:1])
			s = s[1:]
		}

		fallthrough
	case TokenTemplateMiddle, TokenTemplateTail:
		w = i.Underlying()
	case TokenJSXText:
		s = strings.TrimSpace(s)
	case tokenStringAsComment:
		s = strings.ReplaceAll(s, "*/", "* /")
	}

	w.WriteString(s)
}

func (i *indentPrinter) WriteToken(tk *Token) {
	if tk == nil {
		return
	}

	i.WriteStringWithType(tk.Data, tk.Type)
}

func (i *indentPrinter) Indent() writer {
	return &indentPrinter{writer: i}
}

type underlyingWriter struct {
	io.Writer
	lastChar byte
	pos      int
}

func (u *underlyingWriter) Write(p []byte) (int, error) {
	for _, b := range p {
		if b == '\n' {
			u.pos = 0
		} else if b != '\t' || u.pos > 0 {
			u.pos++
		}

		u.lastChar = b
	}

	return u.Writer.Write(p)
}

func (u *underlyingWriter) WriteString(s string) {
	u.Write(unsafe.Slice(unsafe.StringData(s), len(s)))
}

func (u *underlyingWriter) WriteStringWithType(s string, tk parser.TokenType) {
	switch tk {
	case tokenStringAsComment:
		s = strings.ReplaceAll(s, "*/", "* /")
	}

	u.WriteString(s)
}

func (u *underlyingWriter) WriteToken(tk *Token) {
	if tk == nil {
		return
	}

	u.WriteString(tk.Data)
}

func (u *underlyingWriter) Underlying() writer {
	return u
}

func (u *underlyingWriter) PrintSemiColon() {
	if u.lastChar != '\n' {
		u.Writer.Write(semiColon)
		u.pos++
	}
}

func (u *underlyingWriter) LastChar() byte {
	return u.lastChar
}

func (u *underlyingWriter) LastIsWhitespace() bool {
	return u.lastChar == ' ' || u.lastChar == '\n' || u.lastChar == '\t'
}

func (u *underlyingWriter) Pos() int {
	return u.pos
}

func (u *underlyingWriter) Indent() writer {
	return &indentPrinter{writer: u}
}

func (u *underlyingWriter) Printf(format string, args ...any) {
	fmt.Fprintf(u, format, args...)
}

func (underlyingWriter) Start(_ Tokens) {}
func (underlyingWriter) End()           {}

type originalWriter struct {
	io.Writer
	tokenStack              []Tokens
	pos                     []int
	pd                      []Token
	pdColonSplit            *originalWriter
	lastType                parser.TokenType
	newline, semicolon, slc bool
}

func (o *originalWriter) WriteString(string) {}

func (o *originalWriter) WriteStringWithType(data string, typ parser.TokenType) {
	switch typ {
	case tokenStringAsComment:
		data = strings.ReplaceAll(data, "*/", "* /")
	case tokenPossibleTrailingComma:
		if pos := o.findStringWithToken(",", TokenPunctuator, true); pos >= 0 {
			o.WriteStringWithType(",", TokenPunctuator)
		}

		return
	case tokenColonSplit:
		o.pd = []Token{}

		return
	}

	if len(o.pd) > 0 && (data == ":" || data == "as") {
		p := *o
		o.pdColonSplit = &p
	} else if o.pdColonSplit != nil {
		if data == "}" || data == "," || data == "=" {
			o.unColon()
		} else {
			o.writePDColon()
		}
	} else if len(o.pd) > 0 && (data == "," || data == "=" || data == ";" || typ != TokenPunctuator) {
		o.writePDColon()
	}

	pos := o.findStringWithToken(data, typ, false)
	if pos >= 0 {
		o.printWhitespaceBefore(pos)
	}

	o.writeTokenData(Token{Token: parser.Token{Type: typ, Data: data}})

	if pos >= 0 {
		o.setPos(o.printWhitespaceAfter(pos))
	}
}

var (
	newline   = Token{Token: parser.Token{Type: TokenLineTerminator, Data: "\n"}}
	semicolon = Token{Token: parser.Token{Type: TokenPunctuator, Data: ";"}}
)

func (o *originalWriter) writeTokenData(tk Token) {
	if o.semicolon && last(o.tokenStack) == nil {
		o.semicolon = false

		if tk.Type != TokenRightBracePunctuator {
			o.writeTokenData(semicolon)
		}
	} else if (o.semicolon && tk.Type != TokenPunctuator && tk.Type != TokenRightBracePunctuator && tk.Type != TokenWhitespace || o.slc) && tk.Type != TokenLineTerminator {
		o.semicolon = false

		o.writeTokenData(newline)
	} else if (tk.Type == TokenKeyword || tk.Type == TokenIdentifier || tk.Type == TokenNumericLiteral || tk.Type == 0 && startsWithCharacter(tk.Data)) && (o.lastType == TokenKeyword || o.lastType == TokenIdentifier || o.lastType == TokenPrivateIdentifier) {
		o.writeTokenData(Token{Token: parser.Token{Type: TokenWhitespace, Data: " "}})
	}

	if o.pd != nil {
		o.pd = append(o.pd, tk)
	} else {
		io.WriteString(o.Writer, tk.Data)
	}

	o.lastType = tk.Type
	o.semicolon = false
	o.newline = tk.Type == TokenLineTerminator
	o.slc = false
}

func startsWithCharacter(data string) bool {
	if len(data) == 0 {
		return false
	}

	r, _ := utf8.DecodeRuneInString(data)

	return internal.IsIDContinue(r)
}

func (o *originalWriter) unColon() {
	for len(o.tokenStack) > len(o.pdColonSplit.tokenStack) {
		o.pdColonSplit.tokenStack = append(o.pdColonSplit.tokenStack, last(o.pdColonSplit.tokenStack))
		o.pdColonSplit.pos = append(o.pdColonSplit.pos, last(o.pdColonSplit.pos))
	}

	*o = *o.pdColonSplit

	o.writePDColon()
}

func (o *originalWriter) writePDColon() {
	for _, tk := range o.pd {
		io.WriteString(o.Writer, tk.Data)
	}

	o.pd = nil
	o.pdColonSplit = nil
}

func (o *originalWriter) WriteToken(tk *Token) {
	if o.pdColonSplit != nil {
		if o.pd[0] == *tk {
			o.unColon()

			return
		}

		o.writePDColon()
	}

	pos := o.findToken(tk)
	if pos >= 0 {
		o.printWhitespaceBefore(pos)
	}

	o.writeTokenData(*tk)

	o.slc = tk.Type == TokenSingleLineComment

	if pos >= 0 {
		o.setPos(o.printWhitespaceAfter(pos))
	}
}

func (o *originalWriter) Underlying() writer { return o }

func (o *originalWriter) PrintSemiColon() {
	if len(o.pd) > 0 {
		o.writePDColon()
	}

	if pos := o.findStringWithToken(";", TokenPunctuator, true); pos >= 0 {
		o.WriteStringWithType(";", TokenPunctuator)

		return
	}

	o.semicolon = !o.newline && !o.slc
}

func (o *originalWriter) LastChar() byte         { return 0 }
func (o *originalWriter) LastIsWhitespace() bool { return false }
func (o *originalWriter) Pos() int               { return 0 }
func (o *originalWriter) Indent() writer         { return o }
func (o *originalWriter) Printf(string, ...any)  {}

func (o *originalWriter) Start(tks Tokens) {
	if len(tks) > 0 && len(o.tokenStack) > 0 {
		if pos := o.findToken(&tks[0]); pos >= 0 {
			o.printWhitespaceBefore(pos)
		}
	}

	push(&o.tokenStack, tks)
	push(&o.pos, 0)
}

func push[T any](a *[]T, v T) {
	*a = append(*a, v)
}

func (o *originalWriter) End() {
	tks := last(o.tokenStack)

	pop(&o.tokenStack)
	pop(&o.pos)

	if len(tks) > 0 && len(o.tokenStack) > 0 {
		if pos := o.findToken(&tks[len(tks)-1]); pos >= 0 {
			o.setPos(o.printWhitespaceAfter(pos))
		}
	} else if len(o.tokenStack) == 0 && o.slc {
		o.writeTokenData(newline)
	}
}

func (o *originalWriter) setPos(pos int) {
	if pos > last(o.pos) {
		o.pos[len(o.pos)-1] = pos
	}
}

func (o *originalWriter) printWhitespaceAfter(pos int) int {
	tks := last(o.tokenStack)

	for _, tk := range tks[pos+1:] {
		if tk.Type != TokenWhitespace && tk.Type != TokenLineTerminator {
			break
		}

		o.writeTokenData(tk)

		pos++
	}

	return pos
}

func (o *originalWriter) printWhitespaceBefore(pos int) {
	if o.lastType == TokenWhitespace || o.lastType == TokenLineTerminator {
		return
	}

	tks := last(o.tokenStack)
	n := pos - 1
	currPos := last(o.pos)

	if pos < currPos {
		return
	}

	for ; n > currPos; n-- {
		tk := tks[n]

		if tk.Type != TokenWhitespace && tk.Type != TokenLineTerminator {
			break
		}
	}

	n++

	for _, tk := range tks[max(n, currPos):pos] {
		o.writeTokenData(tk)
	}
}

func pop[T any](a *[]T) {
	*a = (*a)[:len(*a)-1]
}

func (o *originalWriter) findToken(tk *Token) int {
	ts := last(o.tokenStack)

	for n := range ts {
		if tk == &ts[n] {
			return n
		}
	}

	return o.findStringWithToken(tk.Data, tk.Type, false)
}

func last[T any](s []T) T {
	return s[len(s)-1]
}

func (o *originalWriter) findStringWithToken(str string, tt parser.TokenType, afterOnly bool) int {
	ts := last(o.tokenStack)
	pos := last(o.pos)

	for n, tk := range ts[pos:] {
		if tk.Type == tt && tk.Data == str {
			return n + pos
		}
	}

	if !afterOnly {
		for n, tk := range ts[:pos] {
			if tk.Type == tt && tk.Data == str {
				return n
			}
		}
	}

	return -1
}

// Format implements the fmt.Formatter interface
func (t Token) Format(s fmt.State, v rune) {
	t.printType(s, s.Flag('+'))
}

func (t Token) printType(w io.Writer, v bool) {
	var typ string

	if t.Type&tokenTypescript != 0 {
		typ = "Typescript"
	}

	switch t.Type &^ tokenTypescript {
	case parser.TokenError:
		typ += "Error"
	case parser.TokenDone:
		typ += "Done"
	case TokenWhitespace:
		typ += "Whitespace"
	case TokenLineTerminator:
		typ += "LineTerminator"
	case TokenSingleLineComment:
		typ += "SingleLineComment"
	case TokenMultiLineComment:
		typ += "MultiLineComment"
	case TokenIdentifier:
		typ += "Identifier"
	case TokenBooleanLiteral:
		typ += "BooleanLiteral"
	case TokenKeyword:
		typ += "Keyword"
	case TokenPunctuator:
		typ += "Punctuator"
	case TokenNumericLiteral:
		typ += "NumericLiteral"
	case TokenStringLiteral:
		typ += "StringLiteral"
	case TokenNoSubstitutionTemplate:
		typ += "NoSubstitutionTemplate"
	case TokenTemplateHead:
		typ += "TemplateHead"
	case TokenTemplateMiddle:
		typ += "TemplateMiddle"
	case TokenTemplateTail:
		typ += "TemplateTail"
	case TokenDivPunctuator:
		typ += "DivPunctuator"
	case TokenRightBracePunctuator:
		typ += "RightBracePunctuator"
	case TokenRegularExpressionLiteral:
		typ += "RegulatExpressionLiteral"
	case TokenNullLiteral:
		typ += "NullLiteral"
	case TokenFutureReservedWord:
		typ += "FutureReservedWord"
	default:
		typ = fmt.Sprintf("%d", t.Type)
	}

	fmt.Fprintf(w, "Type: %s - Data: %q", typ, t.Data)

	if v {
		fmt.Fprintf(w, " - Position: %d (%d: %d)", t.Pos, t.Line, t.LinePos)
	}
}

// Format implements the fmt.Formatter interface
func (t Tokens) Format(s fmt.State, v rune) {
	t.printType(&underlyingWriter{Writer: s}, s.Flag('+'))
}

func (t Tokens) printType(w writer, v bool) {
	if t == nil {
		w.WriteString("nil")

		return
	} else if len(t) == 0 {
		w.WriteString("[]")

		return
	}

	w.WriteString("[")

	ipp := w.Indent()

	for n, t := range t {
		ipp.Printf("\n%d: ", n)
		t.printType(w, v)
	}

	w.WriteString("\n]")
}

func (c CommentsToken) printSource(w writer, v bool) {
	if v {
		c.Comments[0].printSource(w, true, false)
	}

	w.WriteStringWithType(".", TokenPunctuator)

	if v {
		c.Comments[1].printSource(w, true, false)
	}

	w.WriteStringWithType(c.Data, c.Type)
}

func (c Comments) printType(w writer, v bool) {
	if c == nil {
		w.WriteString("nil")

		return
	} else if len(c) == 0 {
		w.WriteString("[]")

		return
	}

	w.WriteString("[")

	ipp := w.Indent()

	for n, t := range c {
		ipp.Printf("\n%d: ", n)

		if t == nil {
			w.WriteString("nil")
		} else {
			t.printType(w, v)
		}
	}

	w.WriteString("\n]")
}

type commentPrinter bool

func (c Comments) printSource(w writer, postSpace, postNewline bool) {
	for len(c) > 0 && c[0] == nil {
		c = c[1:]
	}

	if len(c) > 0 {
		switch w.LastChar() {
		case 0, ' ', '\n', '\t':
		default:
			if c[0].Type == TokenSingleLineComment || c[0].Type == TokenMultiLineComment {
				w.WriteString(" ")
			}
		}

		var cp commentPrinter

		line := c[0].Line + uint64(strings.Count(c[0].Data, "\n"))
		pos := w.Pos()
		lastWasMulti := cp.print(w, c[0], 0, false)

		if !lastWasMulti {
			line++
		}

		for _, c := range c[1:] {
			if c == nil {
				continue
			}

			if !cp {
				if line < c.Line {
					if !lastWasMulti {
						w.WriteString("\n")
					}

					w.WriteString("\n")

					line++
					pos = 0
				} else if lastWasMulti {
					w.WriteString(" ")
				} else {
					w.WriteString("\n")
				}
			}

			if lastWasMulti = cp.print(w, c, pos, lastWasMulti); lastWasMulti {
				line += uint64(strings.Count(c.Data, "\n"))
			} else {
				line++
			}
		}

		if cp {
			w.WriteStringWithType("*/", tokenMultiLineEnd)
		}

		if postNewline || !lastWasMulti {
			w.WriteString("\n")
		} else if postSpace {
			w.WriteString(" ")
		}
	}
}

func (c Comments) LastIsMulti() bool {
	return len(c) > 0 && c[len(c)-1].Type == TokenMultiLineComment
}

const (
	tokenMultiLineStart parser.TokenType = 999 + iota
	tokenMultiLineEnd
	tokenSingleLineStart
	tokenStringAsComment
	tokenColonSplit
	tokenPossibleTrailingComma
)

func (cp *commentPrinter) print(w writer, c *Token, pos int, lastWasMulti bool) bool {
	var multi bool

	if isSingleLine(c) {
		if *cp {
			w.WriteStringWithType("*/", tokenMultiLineEnd)
			w.WriteString(" ")

			pos = max(0, pos-3)
			*cp = false
		} else if !lastWasMulti {
			w.WriteString(strings.Repeat(" ", pos))
		}

		if !strings.HasPrefix(c.Data, "//") {
			w.WriteStringWithType("// ", tokenSingleLineStart)
		}
	} else {
		multi = true

		if c.Type == TokenMultiLineComment {
			if *cp {
				w.WriteStringWithType("*/", tokenMultiLineEnd)
				w.WriteString(" ")
			}

			*cp = false
		} else if !*cp {
			w.WriteStringWithType("/*", tokenMultiLineStart)
			*cp = true
		}
	}

	if *cp {
		w.WriteStringWithType(c.Data, tokenStringAsComment)
	} else {
		w.WriteToken(c)
	}

	return multi
}

func isSingleLine(c *Token) bool {
	return c.Type == TokenSingleLineComment && !strings.Contains(c.Data, "\n")
}

type formatter interface {
	printType(writer, bool)
	printSource(writer, bool)
}

func format(f formatter, s fmt.State, v rune) {
	switch v {
	case 'v':
		f.printType(&underlyingWriter{Writer: s}, s.Flag('+'))
	case 's':
		var v bool

		if s.Flag('+') {
			v = true
		}

		if s.Flag('#') {
			f.printSource(&originalWriter{Writer: s}, true)
		} else {
			f.printSource(&underlyingWriter{Writer: s}, v)
		}
	}
}

// String implements the fmt.Stringer interface
func (ft FunctionType) String() string {
	switch ft {
	case FunctionNormal:
		return "Normal"
	case FunctionGenerator:
		return "Generator"
	case FunctionAsync:
		return "Async"
	case FunctionAsyncGenerator:
		return "Async Generator"
	default:
		return unknown
	}
}

func (ft FunctionType) printType(w writer, _ bool) {
	w.WriteString(ft.String())
}

// String implements the fmt.Stringer interface
func (mt MethodType) String() string {
	switch mt {
	case MethodNormal:
		return "MethodNormal"
	case MethodGenerator:
		return "MethodGenerator"
	case MethodAsyncGenerator:
		return "MethodAsyncGenerator"
	case MethodAsync:
		return "MethodAsync"
	case MethodGetter:
		return "MethodGetter"
	case MethodSetter:
		return "MethodSetter"
	default:
		return unknown
	}
}

func (mt MethodType) printType(w writer, _ bool) {
	w.WriteString(mt.String())
}

// String implements the fmt.Stringer interface
func (st StatementType) String() string {
	switch st {
	case StatementNormal:
		return "StatementNormal"
	case StatementContinue:
		return "StatementContinue"
	case StatementBreak:
		return "StatementBreak"
	case StatementReturn:
		return "StatementReturn"
	case StatementThrow:
		return "StatementThrow"
	case StatementDebugger:
		return "StatementDebugger"
	default:
		return unknown
	}
}

func (st StatementType) printType(w writer, _ bool) {
	w.WriteString(st.String())
}

// String implements the fmt.Stringer interface
func (ft ForType) String() string {
	switch ft {
	case ForNormal:
		return "ForNormal"
	case ForNormalVar:
		return "ForNormalVar"
	case ForNormalLexicalDeclaration:
		return "ForNormalLexicalDeclaration"
	case ForNormalExpression:
		return "ForNormalExpression"
	case ForInLeftHandSide:
		return "ForInLeftHandSide"
	case ForInVar:
		return "ForInVar"
	case ForInLet:
		return "ForInLet"
	case ForInConst:
		return "ForInConst"
	case ForOfLeftHandSide:
		return "ForOfLeftHandSide"
	case ForOfVar:
		return "ForOfVar"
	case ForOfLet:
		return "ForOfLet"
	case ForOfConst:
		return "ForOfConst"
	case ForAwaitOfLeftHandSide:
		return "ForAwaitOfLeftHandSide"
	case ForAwaitOfVar:
		return "ForAwaitOfVar"
	case ForAwaitOfLet:
		return "ForAwaitOfLet"
	case ForAwaitOfConst:
		return "ForAwaitOfConst"
	default:
		return unknown
	}
}

func (ft ForType) printType(w writer, _ bool) {
	w.WriteString(ft.String())
}

// String implements the fmt.Stringer interface
func (e EqualityOperator) String() string {
	switch e {
	case EqualityNone:
		return ""
	case EqualityEqual:
		return "=="
	case EqualityNotEqual:
		return "!="
	case EqualityStrictEqual:
		return "==="
	case EqualityStrictNotEqual:
		return "!=="
	default:
		return unknown
	}
}

func (e EqualityOperator) printType(w writer, _ bool) {
	w.WriteString(e.String())
}

// String implements the fmt.Stringer interface
func (r RelationshipOperator) String() string {
	switch r {
	case RelationshipNone:
		return ""
	case RelationshipLessThan:
		return "<"
	case RelationshipGreaterThan:
		return ">"
	case RelationshipLessThanEqual:
		return "<="
	case RelationshipGreaterThanEqual:
		return ">="
	case RelationshipInstanceOf:
		return "instanceof"
	case RelationshipIn:
		return "in"
	default:
		return unknown
	}
}

func (r RelationshipOperator) tokenType() parser.TokenType {
	switch r {
	case RelationshipInstanceOf, RelationshipIn:
		return TokenKeyword
	default:
		return TokenPunctuator
	}
}

func (r RelationshipOperator) printType(w writer, _ bool) {
	w.WriteString(r.String())
}

// String implements the fmt.Stringer interface
func (s ShiftOperator) String() string {
	switch s {
	case ShiftNone:
		return ""
	case ShiftLeft:
		return "<<"
	case ShiftRight:
		return ">>"
	case ShiftUnsignedRight:
		return ">>>"
	default:
		return unknown
	}
}

func (s ShiftOperator) printType(w writer, _ bool) {
	w.WriteString(s.String())
}

// String implements the fmt.Stringer interface
func (a AdditiveOperator) String() string {
	switch a {
	case AdditiveNone:
		return ""
	case AdditiveAdd:
		return "+"
	case AdditiveMinus:
		return "-"
	default:
		return unknown
	}
}

func (a AdditiveOperator) printType(w writer, _ bool) {
	w.WriteString(a.String())
}

// String implements the fmt.Stringer interface
func (m MultiplicativeOperator) String() string {
	switch m {
	case MultiplicativeNone:
		return ""
	case MultiplicativeMultiply:
		return "*"
	case MultiplicativeDivide:
		return "/"
	case MultiplicativeRemainder:
		return "%"
	default:
		return unknown
	}
}

func (m MultiplicativeOperator) printType(w writer, _ bool) {
	w.WriteString(m.String())
}

// String implements the fmt.Stringer interface
func (u UnaryOperator) String() string {
	switch u {
	case UnaryNone:
		return ""
	case UnaryDelete:
		return "delete"
	case UnaryVoid:
		return "void"
	case UnaryTypeOf:
		return "typeof"
	case UnaryAdd:
		return "+"
	case UnaryMinus:
		return "-"
	case UnaryBitwiseNot:
		return "~"
	case UnaryLogicalNot:
		return "!"
	case UnaryAwait:
		return "await"
	default:
		return unknown
	}
}

func (u UnaryOperator) tokenType() parser.TokenType {
	switch u {
	case UnaryDelete, UnaryVoid, UnaryTypeOf:
		return TokenKeyword
	case UnaryAwait:
		return TokenIdentifier
	default:
		return TokenPunctuator
	}
}

func (u UnaryOperator) printType(w writer, _ bool) {
	w.WriteString(u.String())
}

// String implements the fmt.Stringer interface
func (u UpdateOperator) String() string {
	switch u {
	case UpdateNone:
		return ""
	case UpdatePostIncrement:
		return "++"
	case UpdatePostDecrement:
		return "--"
	case UpdatePreIncrement:
		return "++"
	case UpdatePreDecrement:
		return "--"
	default:
		return unknown
	}
}

func (u UpdateOperator) printType(w writer, _ bool) {
	w.WriteString(u.String())
}

// String implements the fmt.Stringer interface
func (l LetOrConst) String() string {
	if l {
		return "Const"
	}

	return "Let"
}

func (l LetOrConst) printType(w writer, _ bool) {
	w.WriteString(l.String())
}

// String implements the fmt.Stringer interface
func (a AssignmentOperator) String() string {
	switch a {
	case AssignmentNone:
		return ""
	case AssignmentAssign:
		return "="
	case AssignmentMultiply:
		return "*="
	case AssignmentDivide:
		return "/="
	case AssignmentRemainder:
		return "%="
	case AssignmentAdd:
		return "+="
	case AssignmentSubtract:
		return "-="
	case AssignmentLeftShift:
		return "<<="
	case AssignmentSignPropagatingRightShift:
		return ">>="
	case AssignmentZeroFillRightShift:
		return ">>>="
	case AssignmentBitwiseAND:
		return "&="
	case AssignmentBitwiseXOR:
		return "^="
	case AssignmentBitwiseOR:
		return "|="
	case AssignmentExponentiation:
		return "**="
	case AssignmentLogicalAnd:
		return "&&="
	case AssignmentLogicalOr:
		return "||="
	case AssignmentNullish:
		return "??="
	default:
		return unknown
	}
}

func (a AssignmentOperator) printType(w writer, _ bool) {
	w.WriteString(a.String())
}

const unknown = "Unknown"