Implemented error messages

src/errors/Base.go

@@ -0,0 +1,11 @@
+package errors
+
+// 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/build/token"
+)
+
+// Error is a compiler error at a given line and column.
+type Error struct {
+	Path   string
+	Line   int
+	Column int
+	Err    error
+	Stack  string
+}
+
+// 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, path string, tokens []token.Token, cursor int) *Error {
+	var (
+		lineCount = 1
+		lineStart = -1
+	)
+
+	for i := range cursor {
+		if tokens[i].Kind == token.NewLine {
+			lineCount++
+			lineStart = int(tokens[i].Position)
+		}
+	}
+
+	var column int
+
+	if cursor < len(tokens) {
+		column = tokens[cursor].Position - lineStart
+	} else {
+		lastToken := tokens[len(tokens)-1]
+		column = lastToken.Position - lineStart + len(lastToken.Text())
+	}
+
+	return &Error{path, lineCount, column, err, Stack()}
+}
+
+// Error generates the string representation.
+func (e *Error) Error() string {
+	path := e.Path
+	cwd, err := os.Getwd()
+
+	if err == nil {
+		relativePath, err := filepath.Rel(cwd, e.Path)
+
+		if err == nil {
+			path = relativePath
+		}
+	}
+
+	return fmt.Sprintf("%s:%d:%d: %s\n\n%s", path, e.Line, e.Column, e.Err, e.Stack)
+}
+
+// Unwrap returns the wrapped error.
+func (e *Error) Unwrap() error {
+	return e.Err
+}

src/errors/Error_test.go

@@ -0,0 +1,32 @@
+package errors_test
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.akyoto.dev/cli/q/src/build"
+	"git.akyoto.dev/cli/q/src/errors"
+	"git.akyoto.dev/go/assert"
+)
+
+func TestErrors(t *testing.T) {
+	tests := []struct {
+		File          string
+		ExpectedError error
+	}{
+		{"ExpectedFunctionParameters.q", errors.ExpectedFunctionParameters},
+		{"ExpectedFunctionDefinition.q", errors.ExpectedFunctionDefinition},
+	}
+
+	for _, test := range tests {
+		name := strings.TrimSuffix(test.File, ".q")
+
+		t.Run(name, func(t *testing.T) {
+			b := build.New(filepath.Join("testdata", test.File))
+			_, err := b.Run()
+			assert.NotNil(t, err)
+			assert.Contains(t, err.Error(), test.ExpectedError.Error())
+		})
+	}
+}

src/errors/ScanErrors.go

@@ -0,0 +1,11 @@
+package errors
+
+var (
+	MissingBlockStart          = &Base{"Missing '{'"}
+	MissingBlockEnd            = &Base{"Missing '}'"}
+	MissingGroupStart          = &Base{"Missing '('"}
+	MissingGroupEnd            = &Base{"Missing ')'"}
+	ExpectedFunctionName       = &Base{"Expected function name"}
+	ExpectedFunctionParameters = &Base{"Expected function parameters"}
+	ExpectedFunctionDefinition = &Base{"Expected function definition"}
+)

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/testdata/ExpectedFunctionDefinition.q

@@ -0,0 +1 @@
+main()

src/errors/testdata/ExpectedFunctionParameters.q

@@ -0,0 +1 @@
+main