better formatting of generic error messages

Author: bafto

src/ddperror/error.go

@@ -2,6 +2,8 @@ package ddperror
 
 import (
 	"fmt"
+	"path/filepath"
+	"strings"
 
 	"github.com/DDP-Projekt/Kompilierer/src/token"
 )
@@ -16,22 +18,52 @@ const (
 
 // Error type for ddp-errors
 type Error struct {
-	Code  Code        // the error code
-	Range token.Range // the range the error spans in its source
-	Msg   string      // the error message
-	File  string      // the filepath (or uri, url or whatever) in which the error occured
-	Level Level       // the level of the error
+	Code                 Code        // the error code
+	Range                token.Range // the range the error spans in its source
+	Msg                  string      // the error message
+	File                 string      // the filepath (or uri, url or whatever) in which the error occured
+	Level                Level       // the level of the error
+	WrappedGenericErrors []Error     // optional slice of generic errors wrapped by this error
 }
 
 // simple string representation of the error
 // should only be used for debugging
 // the error-handlers handle the real formatting
 func (err Error) String() string {
-	return fmt.Sprintf("(%04d) %s (Z: %d, S: %d): %s", err.Code, err.File, err.Range.Start.Line, err.Range.Start.Column, err.Msg)
+	msg := strings.Builder{}
+	printIndentedError(&msg, err, 0)
+	return msg.String()
+}
+
+const ERROR_INDENT = "    "
+
+func printIndentedError(builder *strings.Builder, err Error, indent int) {
+	printN(builder, indent, ERROR_INDENT)
+
+	if indent == 0 {
+		builder.WriteString(err.Msg)
+	} else {
+		fmt.Fprintf(builder, "(%04d) %s (Z: %d, S: %d): %s", err.Code, shortFileName(err.File), err.Range.Start.Line, err.Range.Start.Column, err.Msg)
+	}
+
+	if len(err.WrappedGenericErrors) != 0 {
+		builder.WriteString(":")
+		for _, err := range err.WrappedGenericErrors {
+			builder.WriteString("\n")
+			printIndentedError(builder, err, indent+1)
+			if len(err.WrappedGenericErrors) != 0 {
+				builder.WriteString("\n")
+			}
+		}
+	}
+}
+
+func shortFileName(s string) string {
+	return filepath.Base(s)
 }
 
 func (err Error) Error() string {
-	return err.Msg
+	return err.String()
 }
 
 // create a new Error from the given parameters

src/ddperror/handler.go

@@ -16,7 +16,7 @@ func EmptyHandler(Error) {}
 // creates a basic handler that prints the formatted error on a line
 func MakeBasicHandler(w io.Writer) Handler {
 	return func(err Error) {
-		fmt.Fprintf(w, "%s: %s\n", makeErrorHeader(err, ""), err.Msg)
+		fmt.Fprintf(w, "%s: %s\n", makeErrorHeader(err, ""), err)
 	}
 }
 
@@ -36,13 +36,6 @@ func MakeAdvancedHandler(file string, src []byte, w io.Writer) Handler {
 			return
 		}
 
-		// helper function to print s n-times
-		printN := func(n int, s string) {
-			for i := 0; i < n; i++ {
-				fmt.Fprint(w, s)
-			}
-		}
-
 		// helper to find the maximum of two uints
 		uMax := func(a, b uint) uint {
 			if a > b {
@@ -75,29 +68,29 @@ func MakeAdvancedHandler(file string, src []byte, w io.Writer) Handler {
 
 			if lineIndex == rnge.Start.Line-1 {
 				startLen := replaceAndCount(line[:rnge.Start.Column-1])
-				printN(startLen, " ")
+				printN(w, startLen, " ")
 				restLen := replaceAndCount(line[rnge.Start.Column-1:])
 				if rnge.Start.Line == rnge.End.Line {
 					restLen = replaceAndCount(line[rnge.Start.Column-1 : rnge.End.Column-1])
 				}
-				printN(restLen, "^")
+				printN(w, restLen, "^")
 			} else if lineIndex < rnge.End.Line-1 {
-				printN(lineStart, " ")
-				printN(lineLen-lineStart, "^")
+				printN(w, lineStart, " ")
+				printN(w, lineLen-lineStart, "^")
 			} else {
 				restLen := replaceAndCount(line[:rnge.End.Column-1])
 				if lineStart < restLen {
-					printN(lineStart, " ")
-					printN(lineLen-lineStart, "^")
+					printN(w, lineStart, " ")
+					printN(w, lineLen-lineStart, "^")
 				} else {
-					printN(restLen, "^")
+					printN(w, restLen, "^")
 				}
 			}
 			fmt.Fprint(w, "\n")
 		}
 
-		fmt.Fprintf(w, "\n%s.\n\n", err.Msg)
-		printN(maxLineCount, "-")
+		fmt.Fprintf(w, "\n%s.\n\n", err)
+		printN(w, maxLineCount, "-")
 		fmt.Fprint(w, "\n\n")
 	}
 }
@@ -150,3 +143,10 @@ func (m *Collector) GetHandler() Handler {
 		m.Errors = append(m.Errors, err)
 	}
 }
+
+// helper function to print s n-times
+func printN(w io.Writer, n int, s string) {
+	for i := 0; i < n; i++ {
+		fmt.Fprint(w, s)
+	}
+}

src/parser/alias.go

@@ -130,18 +130,6 @@ func (p *parser) alias() ast.Expression {
 		}
 	}
 
-	createInstantiationError := func(decl *ast.FuncDecl, errs []ddperror.Error) ddperror.Error {
-		msg := strings.Builder{}
-		msg.WriteString(fmt.Sprintf("Es gab Fehler beim Instanziieren der generischen Funktion '%s':", decl.Name()))
-
-		for _, err := range errs {
-			msg.WriteString("\n\t")
-			msg.WriteString(err.String())
-		}
-
-		return ddperror.New(ddperror.SEM_ERROR_INSTANTIATING_GENERIC_FUNCTION, ddperror.LEVEL_ERROR, p.previous().Range, msg.String(), p.module.FileName)
-	}
-
 	type checkAliasResult struct {
 		alias                   ast.Alias
 		errs                    []ddperror.Error
@@ -174,7 +162,14 @@ func (p *parser) alias() ast.Expression {
 
 	// generic aliases may not be called with typeSensitive = false
 	if funcAlias, ok := mostFitting.alias.(*ast.FuncAlias); ok && ast.IsGeneric(funcAlias.Func) {
-		p.errVal(createInstantiationError(funcAlias.Func, mostFitting.errs))
+		p.errVal(ddperror.Error{
+			Code:                 ddperror.SEM_ERROR_INSTANTIATING_GENERIC_FUNCTION,
+			Level:                ddperror.LEVEL_ERROR,
+			Range:                p.previous().Range,
+			Msg:                  fmt.Sprintf("Es gab Fehler beim Instanziieren der generischen Funktion '%s'", funcAlias.Func.Name()),
+			File:                 p.module.FileName,
+			WrappedGenericErrors: mostFitting.errs,
+		})
 		p.cur = start
 		return nil
 	}

src/parser/declarations.go

@@ -1233,7 +1233,7 @@ func (p *parser) aliasDecl() ast.Statement {
 	// scan the raw alias withouth the ""
 	var alias *ast.FuncAlias
 	var pTokens []*token.Token
-	if aliasTokens, err := scanner.ScanAlias(*aliasTok, func(err ddperror.Error) { p.err(err.Code, err.Range, err.Msg) }); err == nil && len(aliasTokens) < 2 { // empty strings are not allowed (we need at leas 1 token + EOF)
+	if aliasTokens, err := scanner.ScanAlias(*aliasTok, func(err ddperror.Error) { p.errVal(err) }); err == nil && len(aliasTokens) < 2 { // empty strings are not allowed (we need at leas 1 token + EOF)
 		p.err(ddperror.SEM_MALFORMED_ALIAS, aliasTok.Range, "Ein Alias muss mindestens 1 Symbol enthalten")
 	} else if err := p.validateFunctionAlias(aliasTokens, funDecl.Parameters); err == nil { // check that the alias fits the function
 		if ok, isFun, existingAlias, toks := p.aliasExists(aliasTokens); ok {

src/parser/statements.go

@@ -154,7 +154,7 @@ func (p *parser) finishStatement(stmt ast.Statement) ast.Statement {
 	if p.peek().Type == token.COUNT_MAL {
 		p.checkStatement(stmt)
 		if err != nil {
-			p.err(err.Code, err.Range, err.Msg)
+			p.errVal(*err)
 		}
 	} else {
 		p.cur = cur