elysium/parser.go

package main

import (
	"errors"
	"slices"
	"strconv"
	"strings"
)

type TypeType uint32

const (
	Type_Primitive TypeType = iota
	Type_Void
	Type_Named
	Type_Array
	Type_Tuple
)

type Type struct {
	Type  TypeType
	Value any
}

type NamedType struct {
	TypeName string
}

type ArrayType struct {
	ElementType Type
}

type TupleType struct {
	Types []Type
}

type StatementType uint32

const (
	Statement_Expression StatementType = iota
	Statement_Block
	Statement_Return
	Statement_DeclareLocalVariable
)

type Statement struct {
	Type  StatementType
	Value any
}

type BlockStatement struct {
	Block Block
}

type ReturnStatement struct {
	Value *Expression
}

type DeclareLocalVariableStatement struct {
	Variable    string
	Initializer Expression
}

type ExpressionType uint32

const (
	Expression_Assignment ExpressionType = iota
	Expression_Literal
	Expression_VariableReference
	Expression_Arithmetic
)

type Expression struct {
	Type  ExpressionType
	Value any
}

type AssignmentExpression struct {
	Variable string
	Value    Expression
}

type LiteralExpression struct {
	Type  PrimitiveType
	Value any
}

type VariableReferenceExpression struct {
	Variable string
}

type ArithmeticOperation uint32

const (
	Arithmetic_Add ArithmeticOperation = iota
	Arithmetic_Sub
	Arithmetic_Mul
	Arithmetic_Div
	Arithmetic_Mod
)

type ArithmeticExpression struct {
	Operation ArithmeticOperation
	Left      Expression
	Right     Expression
}

type Block struct {
	Statements []Statement
}

type ParsedParameter struct {
	Name string
	Type Type
}

type ParsedFunction struct {
	Name       string
	Parameters []ParsedParameter
	ReturnType Type
	Body       Block
}

type Import struct {
	Import string
}

type ParsedFile struct {
	Imports   []Import
	Functions []ParsedFunction
}

type Parser struct {
	Tokens   []LexToken
	Position uint64
}

func (p *Parser) error(message string) error {
	return errors.New(message + " (at " + strconv.FormatUint(p.Position, 10) + ")")
}

func (p *Parser) peekToken() *LexToken {
	if len(p.Tokens) == 0 {
		return nil
	}

	return &p.Tokens[0]
}

func (p *Parser) nextToken() *LexToken {
	if len(p.Tokens) == 0 {
		return nil
	}

	token := p.Tokens[0]
	p.Tokens = p.Tokens[1:]
	p.Position = token.Position
	return &token
}

func (p *Parser) expectSeparator(separators ...Separator) (Separator, error) {
	var separatorNames []string
	for _, sep := range separators {
		separatorNames = append(separatorNames, string(Separators[sep]))
	}

	separator := p.nextToken()
	if separator == nil || separator.Type != Type_Separator || !slices.Contains(separators, separator.Value.(Separator)) {
		return InvalidValue, p.error("expected one of " + strings.Join(separatorNames, " "))
	}

	return separator.Value.(Separator), nil
}

func (p *Parser) expectIdentifier() (string, error) {
	identifier := p.nextToken()
	if identifier == nil || identifier.Type != Type_Separator && identifier.Type != Type_Identifier {
		return "", p.error("expected identifier")
	}

	return identifier.Value.(string), nil
}

func (p *Parser) expectImport() (*Import, error) {
	var err error

	importToken := p.nextToken()
	if importToken == nil || importToken.Type != Type_Keyword || importToken.Value.(Keyword) != Keyword_Import {
		return nil, p.error("expected import")
	}

	identifier := p.nextToken()
	if identifier == nil || identifier.Type != Type_Identifier {
		return nil, p.error("expected identifier")
	}

	_, err = p.expectSeparator(Separator_Semicolon)
	if err != nil {
		return nil, err
	}

	return &Import{Import: identifier.Value.(string)}, nil
}

func (p *Parser) expectType() (*Type, error) {
	var err error

	tok := p.nextToken()
	if tok == nil {
		return nil, p.error("expected type")
	}

	if tok.Type == Type_Keyword && tok.Value.(Keyword) == Keyword_Void {
		return &Type{Type: Type_Void, Value: nil}, nil
	}

	if tok.Type == Type_Separator && tok.Value.(Separator) == Separator_OpenParen {
		// Tuple type
		var types []Type
		for {
			var parsedType *Type
			parsedType, err = p.expectType()
			if err != nil {
				return nil, err
			}

			types = append(types, *parsedType)

			var sep Separator
			sep, err = p.expectSeparator(Separator_Comma, Separator_CloseParen)
			if err != nil {
				return nil, err
			}

			if sep == Separator_CloseParen {
				break
			}
		}

		if len(types) == 0 {
			return nil, p.error("empty tuple")
		}

		return &Type{Type: Type_Tuple, Value: TupleType{Types: types}}, nil
	}

	if tok.Type == Type_Identifier {
		return &Type{Type: Type_Named, Value: tok.Value}, nil
	}

	return nil, p.error("expected type")
}

func (p *Parser) expectBlock() (*Block, error) {
	_, err := p.expectSeparator(Separator_OpenCurly)
	if err != nil {
		return nil, err
	}

	var statements []Statement
	for {
		token := p.peekToken()
		if token == nil {
			return nil, p.error("expected statement or }")
		}

		if token.Type == Type_Separator && token.Value.(Separator) == Separator_CloseCurly {
			p.nextToken()
			break
		}

		// TODO: parse statement
		p.nextToken()
	}

	return &Block{Statements: statements}, nil
}

func (p *Parser) expectFunction() (*ParsedFunction, error) {
	var err error

	var name string
	var parameters []ParsedParameter
	var returnType *Type
	var body *Block

	returnType, err = p.expectType()
	if err != nil {
		return nil, err
	}

	name, err = p.expectIdentifier()
	if err != nil {
		return nil, err
	}

	_, err = p.expectSeparator(Separator_OpenParen)
	if err != nil {
		return nil, err
	}

	for {
		token := p.peekToken()
		if token == nil {
			return nil, p.error("incomplete function declaration")
		}

		if token.Type == Type_Separator && token.Value.(Separator) == Separator_CloseParen {
			p.nextToken()
			break
		}

		if len(parameters) > 0 {
			_, err := p.expectSeparator(Separator_Comma)
			if err != nil {
				return nil, err
			}
		}

		var paramType *Type
		paramType, err = p.expectType()
		if err != nil {
			return nil, err
		}

		var paramName string
		paramName, err = p.expectIdentifier()
		if err != nil {
			return nil, err
		}

		parameters = append(parameters, ParsedParameter{Name: paramName, Type: *paramType})
	}

	body, err = p.expectBlock()
	if err != nil {
		return nil, err
	}

	return &ParsedFunction{Name: name, Parameters: parameters, ReturnType: *returnType, Body: *body}, nil
}

func (p *Parser) parseFile() (*ParsedFile, error) {
	var err error

	var functions []ParsedFunction
	var imports []Import

	for {
		token := p.peekToken()
		if token == nil {
			break
		}

		if token.Type == Type_Keyword && token.Value.(Keyword) == Keyword_Import {
			var parsedImport *Import
			parsedImport, err = p.expectImport()
			if err != nil {
				return nil, err
			}

			imports = append(imports, *parsedImport)
			continue
		}

		var parsedFunction *ParsedFunction
		parsedFunction, err = p.expectFunction()
		if err != nil {
			return nil, err
		}

		functions = append(functions, *parsedFunction)
	}

	return &ParsedFile{Imports: imports, Functions: functions}, nil
}