statement.go

package parser

import (
	"fmt"
	"slices"

	"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"
)

func (p *Parser) ParseVarTypeAnnotation(left []ast.Assignable) ast.Statement {
	p.Advance() // :
	typ := p.ParseType(DefaultTypeBindingPower)
	switch curr := p.Curr(); curr.Kind {
	default:
		if !isAssignment(curr.Kind) {
			p.Error(klarerrs.ExpectedToken(lexer.ColonEqual, curr))
			return &ast.BadExpression{Value: typ}
		}
		p.Error(klarerrs.Node(klarerrs.ErrInvalidTypeAnnotation, typ))
		fallthrough
	case lexer.Equal, lexer.PlusEqual, lexer.MinusEqual:
		err := klarerrs.Node(klarerrs.ErrInvalidTypeAnnotation, typ)
		if curr.Kind == lexer.Equal {
			err.HintWithDiff("Did you mean to use ':=' instead of '='?", klarerrs.NewDiff(
				"",
				klarerrs.AddedString{Pos: curr.Position, String: ":"},
			))
		}
		p.Error(err)
		fallthrough
	case lexer.ColonEqual:
		return p.ParseAssignment(left, typ)
	}
}

// ParseAssignment parses a variable declaration or reassignment statement.
func (p *Parser) ParseAssignment(lhs []ast.Assignable, explicitType ast.Type) ast.Statement {
	op := p.Advance()
	expLen := len(lhs)
	rhs := make([]ast.Expression, 0, expLen)
	for p.HasTokens() {
		rhs = append(rhs, p.ParseExpression(ExpressionBindingPower))
		if p.CurrKind() != lexer.Comma {
			break
		}
		p.Advance() // ,
	}
	rhs = slices.Clip(rhs)
	if gotLen := len(rhs); gotLen > 1 && gotLen != expLen {
		err := klarerrs.Slice(klarerrs.ErrMismatchedAssignment, rhs)
		err.Label = fmt.Sprintf("%d values were provided", gotLen)
		plural := "s were"
		if expLen == 1 {
			plural = " was"
		}
		err.Highlights = append(err.Highlights, klarerrs.Highlight{
			Range: ranges.Range{
				Start: lhs[0].GetRange().Start,
				End:   lhs[len(lhs)-1].GetRange().End,
			},
			Message: fmt.Sprintf("%d variable%s provided", expLen, plural),
		})
		err.Params = klarerrs.ErrorParams{"left": expLen, "right": gotLen}
		p.Error(err)
	}
	if op.Kind == lexer.ColonEqual {
		return &ast.VariableDeclaration{
			Variables:    lhs,
			ExplicitType: explicitType,
			Values:       rhs,
		}
	}
	return &ast.AssignmentStatement{
		Assignee: lhs,
		Operator: newOperator(op),
		Values:   rhs,
	}
}

func (p *Parser) ParseCommaStatement(first ast.Expression) ast.Statement {
	items := make([]ast.Assignable, 1, 2)
	items[0] = p.validateAssignable(first)
	for p.CurrKind() == lexer.Comma {
		p.Advance()
		items = append(items, p.ParseAssignable())
	}
	if curr := p.CurrKind(); isAssignment(curr) {
		return p.ParseAssignment(items, nil)
	} else if curr == lexer.Colon {
		return p.ParseVarTypeAnnotation(items)
	}
	p.Error(klarerrs.Slice(klarerrs.ErrInvalidComma, items))
	return &ast.BadExpression{Value: items[0]}
}

// Soft keywords are not allowed in module names
func (p *Parser) ParseImportStatement() *ast.ImportStatement {
	i := &ast.ImportStatement{}
	p.Advance() // import
	if p.CurrKind() == lexer.Newline {
		p.Advance()
	}
	if c := p.CurrKind(); c == lexer.Dot || c == lexer.LeftCurlyBrace {
		p.Error(klarerrs.Token(klarerrs.ErrImportExpectedModule, p.Curr()))
		if c == lexer.Dot {
			p.Advance()
		}
		goto unqualifiedImport
	}
	// Parse maybe alias
	if p.isEqual(p.Peek()) {
		i.Alias = new(p.ParseIdentOrDiscard())
		p.Advance() // =
	}
	// First part of module
	i.Module = append(i.Module, p.Expect(lexer.Identifier).Source)
	for p.CurrKind() == lexer.Dot {
		p.Advance()
		// Wildcard import
		if curr := p.CurrKind(); curr == lexer.Asterisk {
			i.Wildcard = true
			wc := p.Advance()
			if p.CurrKind() == lexer.Dot {
				p.Error(klarerrs.Token(klarerrs.ErrImportInvalidWildcard, wc))
				continue
			}
			break
		} else if curr == lexer.LeftCurlyBrace {
			break
		}
		i.Module = append(i.Module, p.Expect(lexer.Identifier).Source)
	}
unqualifiedImport:
	// Unqualified import
	if p.CurrKind() == lexer.LeftCurlyBrace {
		if p.PeekBehind().Kind != lexer.Dot {
			p.ErrorLabelled(
				klarerrs.Token(klarerrs.ErrDotBeforeUnqualifiedImp, p.Curr()),
				"Expected '.{' instead",
			)
		}
		p.Advance() // {
		switch {
		case i.Wildcard:
			// Wildcard and unqualified import //nolint:dupword
			// import module.*.{...}
			p.Error(klarerrs.Token(klarerrs.ErrWildcardWithUnqualified, p.PeekBehind()))
		case p.CurrKind() == lexer.RightCurlyBrace:
			p.Error(klarerrs.Token(klarerrs.ErrEmptyUnqualifiedImport, p.Curr()))
		}
		for p.WhileNot(lexer.RightCurlyBrace) {
			u := &ast.IdentifierPair{Name: p.ParseIdentifier()}
			// Alias
			if p.CurrKind() == lexer.As {
				p.Advance()
				u.Label = p.ParseIdentifier()
			}
			i.UnqualifiedImports = append(i.UnqualifiedImports, u)
			if p.CurrKind() != lexer.RightCurlyBrace {
				p.ExpectOneOf(lexer.Comma, lexer.Newline)
			}
		}
		p.Expect(lexer.RightCurlyBrace, noAdvance)
	}

	return i
}

func (p *Parser) ParseReturnStatement() *ast.ReturnStatement {
	p.Expect(lexer.Return)
	if c := p.CurrKind(); c == lexer.Newline || c == lexer.Comma {
		return &ast.ReturnStatement{}
	}
	return &ast.ReturnStatement{Value: p.ParseExpression(DefaultBindingPower)}
}

func (p *Parser) ParseForStatement() *ast.ForStatement {
	p.Expect(lexer.For)
	f := &ast.ForStatement{}
	if p.CurrKind() == lexer.LeftCurlyBrace {
		p.Error(klarerrs.Token(klarerrs.ErrNoForIterator, p.Curr()))
	} else {
		f.Variables, f.In, f.Iterator = p.parseForVariables()
	}
	f.Label = p.tryParseLoopLabel()
	f.Body = p.ParseBlock()
	return f
}

func (p *Parser) parseForVariables() (
	vars []*ast.AssignableTypePair, in lexer.Position, iter ast.Expression,
) {
	var first ast.Expression
	if p.CurrKind() != lexer.Underscore {
		first = p.ParseExpressionFilter(excludeIf(lexer.In), bpOf(lexer.In), 0)
		if p.CurrKind() == lexer.LeftCurlyBrace {
			// for 5 {}
			return nil, in, first
		}
	}
	var assg ast.Assignable
	if first != nil {
		assg = p.validateAssignable(first)
	}
	p.parseAssignableTypePairs(&vars, assg, true)
	in = p.Expect(lexer.In).Position
	return vars, in, p.ParseExpression(ExpressionBindingPower)
}

func (p *Parser) ParseWhileStatement() *ast.WhileStatement {
	p.Advance() // while
	w := &ast.WhileStatement{}
	if curr := p.CurrKind(); curr != lexer.LeftCurlyBrace && curr != lexer.Colon {
		w.Condition = p.ParseExpression(ExpressionBindingPower)
	} // Otherwise, it's an infinite loop
	w.Label = p.tryParseLoopLabel()
	w.Body = p.ParseBlock()
	return w
}

func (p *Parser) tryParseLoopLabel() *ast.Identifier {
	if p.CurrKind() != lexer.Colon {
		return nil
	}
	p.Advance()
	return new(p.ParseIdentifier())
}

func (p *Parser) ParseBlock() *ast.Block {
	var body []ast.Statement
	start := p.Expect(lexer.LeftCurlyBrace, noAdvance).Position
	for p.WhileNot(lexer.RightCurlyBrace) {
		body = append(body, p.ParseStatement(0))
	}
	end := p.Expect(lexer.RightCurlyBrace, noAdvance).Position
	return &ast.Block{
		Body:     body,
		BaseNode: ast.BaseNode{Range: ranges.Range{start, end}},
	}
}

func (p *Parser) ParseStopStatement() *ast.StopStatement {
	p.Advance() // stop
	return &ast.StopStatement{Label: p.tryParseLoopLabel()}
}

func (p *Parser) ParseNextStatement() *ast.NextStatement {
	p.Advance() // next
	return &ast.NextStatement{Label: p.tryParseLoopLabel()}
}