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

func (p *Parser) ParseType(bp BindingPower) ast.Type {
	kind := p.CurrKind()
	left, handled := p.handleTypeNUD(kind)
	if !handled {
		p.nudError()
		return &ast.BadExpression{Token: kind}
	}
	return p.ParseTypeLED(left, bp)
}

func (p *Parser) ParseTypeLED(left ast.Type, bp BindingPower) ast.Type {
	var handled bool
	for TypeBindingPowerMap[p.CurrKind()] > bp {
		kind := p.CurrKind()
		left, handled = p.handleTypeLED(
			kind, left, TypeBindingPowerMap[p.CurrKind()],
		)
		if !handled {
			p.unexpectedTokenError()
			return &ast.BadExpression{Token: kind, Value: left}
		}
	}
	return left
}

func (p *Parser) ParseListType() *ast.ListType {
	// Skip the [
	p.Advance()
	typ := p.ParseType(DefaultTypeBindingPower)
	p.Expect(lexer.RightBracket)
	return &ast.ListType{Value: typ}
}

func (p *Parser) ParseTypeAlias() ast.Type {
	typ := p.Advance().Source
	if primType, is := ast.PrimitiveTypeMap[typ]; is {
		return &ast.PrimitiveType{Primitive: primType}
	}
	return &ast.TypeAlias{Identifier: typ}
}

func (p *Parser) ParseOptionalType(left ast.Type, bp BindingPower) *ast.OptionalType {
	// Skip the ?
	p.Expect(lexer.Question)
	return &ast.OptionalType{Value: left}
}

func (p *Parser) ParseUnionType(left ast.Type, bp BindingPower) *ast.UnionType {
	u := &ast.UnionType{}
	u.Options = make([]ast.Type, 1, 2)
	if left != nil {
		u.Options[0] = left
	}
	for p.CurrKind() == lexer.Stroke {
		p.Advance()
		u.Options = append(u.Options, p.ParseType(bp))
	}
	return u
}

func (p *Parser) ParseGenericType(left ast.Type, bp BindingPower) *ast.GenericType {
	switch left.(type) {
	case *ast.TypeAlias, *ast.QualifiedTypeAlias, *ast.PrimitiveType:
	default:
		p.ErrorLabelled(
			klarerrs.Node(klarerrs.ErrNonNameInGeneric, left),
			"This must be a name of a type",
		)
	}
	params := make([]ast.Type, 0, 1)
	p.Expect(lexer.LessThan)
	if p.CurrKind() == lexer.GreaterThan {
		// At least 1 parameter required
		p.Error(klarerrs.Token(klarerrs.ErrEmptyGeneric, p.Curr()))
		params = nil
	}
	parseSeries(
		p, &params,
		func() ast.Type { return p.ParseType(DefaultTypeBindingPower) },
		lexer.GreaterThan, lexer.Comma, false,
	)
	return &ast.GenericType{Name: left, Parameters: params}
}

func (p *Parser) ParseFunctionType() *ast.FunctionType {
	p.Advance() // func
	if p.CurrKind() == lexer.Arrow {
		p.Advance()
		return &ast.FunctionType{ReturnType: p.ParseType(DefaultTypeBindingPower)}
	}
	fn := &ast.FunctionType{}
	if p.CurrKind() == lexer.LeftParenthesis {
		fn.Parameters = toTupleType(p.ParseTupleType())
	} else {
		p.Error(klarerrs.Token(klarerrs.ErrParenFuncTypeParams, p.Curr()))
		// Parse without parentheses
		fn.Parameters.Values = p.parseFuncTypeWithoutParen()
	}
	if p.CurrKind() == lexer.Arrow {
		p.Advance()
		fn.ReturnType = p.ParseType(DefaultTypeBindingPower)
	}
	return fn
}

func (p *Parser) parseFuncTypeWithoutParen() (values []*ast.TypePair) {
	for p.HasTokens() {
		pair := &ast.TypePair{}
		if p.PeekKind() == lexer.Colon {
			pair.Keys = append(pair.Keys, p.ParseIdentOrDiscard())
			p.Advance() // :
		}
		pair.Value = p.ParseType(DefaultTypeBindingPower)
		values = append(values, pair)
		if p.CurrKind() != lexer.Comma {
			break
		}
		p.Advance()
	}
	return
}

func (p *Parser) ParseRestType() *ast.RestType {
	p.Advance() // ...
	return &ast.RestType{Value: p.ParseType(VariadicTypeBindingPower)}
}

func (p *Parser) ParseTypeNamespace(left *ast.TypeAlias, bp BindingPower) *ast.QualifiedTypeAlias {
	return &ast.QualifiedTypeAlias{
		Namespace: ast.Identifier{
			Name:     left.Identifier,
			Position: left.Range.Start,
			Len:      left.Range.LineLength(),
		},
		Dot:        p.Advance().Position, // .
		Identifier: p.ParseIdentifier(),
	}
}

func (p *Parser) ParseMapType() *ast.MapType {
	p.Advance() // #{
	key := p.ParseType(DefaultTypeBindingPower)
	p.Expect(lexer.Colon)
	val := p.ParseType(DefaultTypeBindingPower)
	if p.CurrKind() == lexer.Newline {
		p.Advance()
	}
	p.Expect(lexer.RightCurlyBrace)
	return &ast.MapType{Key: key, Value: val}
}

func toTupleType(t ast.Type) *ast.TupleType {
	switch t := t.(type) {
	case *ast.TupleType:
		return t
	case *ast.ParenType:
		return &ast.TupleType{
			BaseNode: t.BaseNode,
			Values:   []*ast.TypePair{{Value: t.Type}},
		}
	default:
		panic("invalid type parameter list")
	}
}