Simplified file structure

src/errors/Base.go

@@ -0,0 +1,33 @@
+package errors
+
+var (
+	EmptySwitch                = &Base{"Empty switch"}
+	ExpectedFunctionName       = &Base{"Expected function name"}
+	ExpectedFunctionParameters = &Base{"Expected function parameters"}
+	ExpectedFunctionDefinition = &Base{"Expected function definition"}
+	ExpectedIfBeforeElse       = &Base{"Expected an 'if' block before 'else'"}
+	InvalidNumber              = &Base{"Invalid number"}
+	InvalidExpression          = &Base{"Invalid expression"}
+	InvalidRune                = &Base{"Invalid rune"}
+	InvalidStatement           = &Base{"Invalid statement"}
+	MissingBlockStart          = &Base{"Missing '{'"}
+	MissingBlockEnd            = &Base{"Missing '}'"}
+	MissingExpression          = &Base{"Missing expression"}
+	MissingGroupStart          = &Base{"Missing '('"}
+	MissingGroupEnd            = &Base{"Missing ')'"}
+	MissingMainFunction        = &Base{"Missing main function"}
+	MissingOperand             = &Base{"Missing operand"}
+	MissingType                = &Base{"Missing type"}
+	NotImplemented             = &Base{"Not implemented"}
+	UnknownType                = &Base{"Unknown type"}
+)
+
+// Base is the base class for errors that have no parameters.
+type Base struct {
+	Message string
+}
+
+// Error generates the string representation.
+func (err *Base) Error() string {
+	return err.Message
+}

src/errors/Error.go

@@ -0,0 +1,67 @@
+package errors
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"git.akyoto.dev/cli/q/src/fs"
+	"git.akyoto.dev/cli/q/src/token"
+)
+
+// Error is a compiler error at a given line and column.
+type Error struct {
+	Err      error
+	File     *fs.File
+	Stack    string
+	Position token.Position
+}
+
+// New generates an error message at the current token position.
+// The error message is clickable in popular editors and leads you
+// directly to the faulty file at the given line and position.
+func New(err error, file *fs.File, position token.Position) *Error {
+	return &Error{
+		Err:      err,
+		File:     file,
+		Position: position,
+		Stack:    Stack(),
+	}
+}
+
+// Error generates the string representation.
+func (e *Error) Error() string {
+	path := e.File.Path
+	cwd, err := os.Getwd()
+
+	if err == nil {
+		relativePath, err := filepath.Rel(cwd, e.File.Path)
+
+		if err == nil {
+			path = relativePath
+		}
+	}
+
+	line := 1
+	column := 1
+	lineStart := -1
+
+	for _, t := range e.File.Tokens {
+		if t.Position >= e.Position {
+			column = int(e.Position) - lineStart
+			break
+		}
+
+		if t.Kind == token.NewLine {
+			lineStart = int(t.Position)
+			line++
+		}
+	}
+
+	return fmt.Sprintf("%s:%d:%d: %s\n\n%s", path, line, column, e.Err, e.Stack)
+}
+
+// Unwrap returns the wrapped error.
+func (e *Error) Unwrap() error {
+	return e.Err
+}

src/errors/InvalidCharacter.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// InvalidCharacter error is created when an invalid character appears.
+type InvalidCharacter struct {
+	Character string
+}
+
+// Error generates the string representation.
+func (err *InvalidCharacter) Error() string {
+	return fmt.Sprintf("Invalid character '%s'", err.Character)
+}

src/errors/InvalidInstruction.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// InvalidInstruction error is created when an instruction is not valid.
+type InvalidInstruction struct {
+	Instruction string
+}
+
+// Error generates the string representation.
+func (err *InvalidInstruction) Error() string {
+	return fmt.Sprintf("Invalid instruction '%s'", err.Instruction)
+}

src/errors/InvalidOperator.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// InvalidOperator error is created when an operator is not valid.
+type InvalidOperator struct {
+	Operator string
+}
+
+// Error generates the string representation.
+func (err *InvalidOperator) Error() string {
+	return fmt.Sprintf("Invalid operator '%s'", err.Operator)
+}

src/errors/KeywordNotImplemented.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// KeywordNotImplemented error is created when we find a keyword without an implementation.
+type KeywordNotImplemented struct {
+	Keyword string
+}
+
+// Error generates the string representation.
+func (err *KeywordNotImplemented) Error() string {
+	return fmt.Sprintf("Keyword not implemented: '%s'", err.Keyword)
+}

src/errors/NumberExceedsBounds.go

@@ -0,0 +1,15 @@
+package errors
+
+import "fmt"
+
+// NumberExceedsBounds error is created when the number doesn't fit into the destination.
+type NumberExceedsBounds struct {
+	Number       int
+	Size         byte
+	ExpectedSize byte
+}
+
+// Error generates the string representation.
+func (err *NumberExceedsBounds) Error() string {
+	return fmt.Sprintf("Number %d needs %d bytes but the maximum is %d bytes", err.Number, err.Size, err.ExpectedSize)
+}

src/errors/Stack.go

@@ -0,0 +1,30 @@
+package errors
+
+import (
+	"runtime"
+	"strings"
+)
+
+// Stack generates a stack trace.
+func Stack() string {
+	var (
+		final  []string
+		buffer = make([]byte, 4096)
+		n      = runtime.Stack(buffer, false)
+		stack  = string(buffer[:n])
+		lines  = strings.Split(stack, "\n")
+	)
+
+	for i := 6; i < len(lines); i += 2 {
+		line := strings.TrimSpace(lines[i])
+		space := strings.LastIndex(line, " ")
+
+		if space != -1 {
+			line = line[:space]
+		}
+
+		final = append(final, line)
+	}
+
+	return strings.Join(final, "\n")
+}

src/errors/TypeMismatch.go

@@ -0,0 +1,26 @@
+package errors
+
+import "fmt"
+
+// TypeMismatch represents an error where a type requirement was not met.
+type TypeMismatch struct {
+	Encountered   string
+	Expected      string
+	ParameterName string
+	IsReturn      bool
+}
+
+// Error generates the string representation.
+func (err *TypeMismatch) Error() string {
+	subject := "type"
+
+	if err.IsReturn {
+		subject = "return type"
+	}
+
+	if err.ParameterName != "" {
+		return fmt.Sprintf("Expected parameter '%s' of %s '%s' (encountered '%s')", err.ParameterName, subject, err.Expected, err.Encountered)
+	}
+
+	return fmt.Sprintf("Expected %s '%s' instead of '%s'", subject, err.Expected, err.Encountered)
+}

src/errors/UnknownCLIParameter.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// UnknownCLIParameter error is created when a command line parameter is not recognized.
+type UnknownCLIParameter struct {
+	Parameter string
+}
+
+// Error generates the string representation.
+func (err *UnknownCLIParameter) Error() string {
+	return fmt.Sprintf("Unknown parameter '%s'", err.Parameter)
+}

src/errors/UnknownFunction.go

@@ -0,0 +1,18 @@
+package errors
+
+import "fmt"
+
+// UnknownFunction represents unknown function errors.
+type UnknownFunction struct {
+	Name        string
+	CorrectName string
+}
+
+// Error generates the string representation.
+func (err *UnknownFunction) Error() string {
+	if err.CorrectName != "" {
+		return fmt.Sprintf("Unknown function '%s', did you mean '%s'?", err.Name, err.CorrectName)
+	}
+
+	return fmt.Sprintf("Unknown function '%s'", err.Name)
+}

src/errors/UnknownIdentifier.go

@@ -0,0 +1,18 @@
+package errors
+
+import "fmt"
+
+// UnknownIdentifier represents unknown variables.
+type UnknownIdentifier struct {
+	Name        string
+	CorrectName string
+}
+
+// Error generates the string representation.
+func (err *UnknownIdentifier) Error() string {
+	if err.CorrectName != "" {
+		return fmt.Sprintf("Unknown identifier '%s', did you mean '%s'?", err.Name, err.CorrectName)
+	}
+
+	return fmt.Sprintf("Unknown identifier '%s'", err.Name)
+}

src/errors/UnknownPackage.go

@@ -0,0 +1,18 @@
+package errors
+
+import "fmt"
+
+// UnknownPackage represents unknown package errors.
+type UnknownPackage struct {
+	Name        string
+	CorrectName string
+}
+
+// Error generates the string representation.
+func (err *UnknownPackage) Error() string {
+	if err.CorrectName != "" {
+		return fmt.Sprintf("Unknown package '%s', did you mean '%s'?", err.Name, err.CorrectName)
+	}
+
+	return fmt.Sprintf("Unknown package '%s'", err.Name)
+}

src/errors/UnusedImport.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// UnusedImport error is created when an import is never used.
+type UnusedImport struct {
+	Package string
+}
+
+// Error generates the string representation.
+func (err *UnusedImport) Error() string {
+	return fmt.Sprintf("Unused import '%s'", err.Package)
+}

src/errors/UnusedVariable.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// UnusedVariable error is created when a defined variable is never used.
+type UnusedVariable struct {
+	Name string
+}
+
+// Error generates the string representation.
+func (err *UnusedVariable) Error() string {
+	return fmt.Sprintf("Unused variable '%s'", err.Name)
+}

src/errors/VariableAlreadyExists.go

@@ -0,0 +1,13 @@
+package errors
+
+import "fmt"
+
+// VariableAlreadyExists is used when existing variables are used for new variable declarations.
+type VariableAlreadyExists struct {
+	Name string
+}
+
+// Error generates the string representation.
+func (err *VariableAlreadyExists) Error() string {
+	return fmt.Sprintf("Variable '%s' already exists", err.Name)
+}