added better error handling for query parsing ⭐ (#126)

* added better error handling for query parsing ⭐

* let the repl continue when the query has syntax errors

Author: shivasurya

sourcecode-parser/antlr/listener_impl.go

@@ -1,6 +1,7 @@
 package parser
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/antlr4-go/antlr/v4"
@@ -24,6 +25,15 @@ type SelectList struct {
 	Alias  string
 }
 
+type customErrorListener struct {
+	*antlr.DefaultErrorListener
+	errors []string
+}
+
+func (l *customErrorListener) SyntaxError(_ antlr.Recognizer, _ interface{}, line, column int, msg string, _ antlr.RecognitionException) {
+	l.errors = append(l.errors, fmt.Sprintf("line %d:%d %s", line, column, msg))
+}
+
 func NewCustomQueryListener() *CustomQueryListener {
 	return &CustomQueryListener{
 		BaseQueryListener: BaseQueryListener{},
@@ -88,14 +98,28 @@ func (l *CustomQueryListener) ExitAndExpression(ctx *AndExpressionContext) {
 	}
 }
 
-func ParseQuery(inputQuery string) Query {
+func ParseQuery(inputQuery string) (Query, error) {
 	inputStream := antlr.NewInputStream(inputQuery)
 	lexer := NewQueryLexer(inputStream)
 	stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
 	p := NewQueryParser(stream)
 
+	errorListener := &customErrorListener{}
+	p.RemoveErrorListeners()
+	p.AddErrorListener(errorListener)
+
 	listener := NewCustomQueryListener()
-	antlr.ParseTreeWalkerDefault.Walk(listener, p.Query())
+	tree := p.Query()
+
+	if len(errorListener.errors) > 0 {
+		return Query{}, fmt.Errorf("\n%s", strings.Join(errorListener.errors, "\n"))
+	}
+
+	antlr.ParseTreeWalkerDefault.Walk(listener, tree)
 
-	return Query{SelectList: listener.selectList, Expression: listener.expression.String(), Condition: listener.condition}
+	return Query{
+		SelectList: listener.selectList,
+		Expression: listener.expression.String(),
+		Condition:  listener.condition,
+	}, nil
 }

sourcecode-parser/antlr/listener_impl_test.go

@@ -62,7 +62,11 @@ func TestParseQuery(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := ParseQuery(tt.input)
+			result, err := ParseQuery(tt.input)
+			if err != nil {
+				t.Errorf("ParseQuery() error = %v", err)
+				return
+			}
 			if !reflect.DeepEqual(result, tt.expectedQuery) {
 				t.Errorf("ParseQuery() = %v, want %v", result, tt.expectedQuery)
 			}

sourcecode-parser/cmd/query.go

@@ -98,26 +98,31 @@ func executeCLIQuery(project, query, output string, stdin bool) (string, error)
 				return "Okay, Bye!", nil
 			}
 			result, err := processQuery(input, codeGraph, output)
-			fmt.Println(result)
 			if err != nil {
 				analytics.ReportEvent(analytics.ErrorProcessingQuery)
-				return "", fmt.Errorf("error processing query: %w", err)
+				err := fmt.Errorf("PathFinder Query syntax error: %w", err)
+				fmt.Println(err)
+			} else {
+				fmt.Println(result)
 			}
 		}
 	} else {
 		// read from command line
 		result, err := processQuery(query, codeGraph, output)
 		if err != nil {
 			analytics.ReportEvent(analytics.ErrorProcessingQuery)
-			return "", fmt.Errorf("error processing query: %w", err)
+			return "", fmt.Errorf("PathFinder Query syntax error: %w", err)
 		}
 		return result, nil
 	}
 }
 
 func processQuery(input string, codeGraph *graph.CodeGraph, output string) (string, error) {
 	fmt.Println("Executing query: " + input)
-	parsedQuery := parser.ParseQuery(input)
+	parsedQuery, err := parser.ParseQuery(input)
+	if err != nil {
+		return "", err
+	}
 	// split the input string if WHERE
 	parsedQuery.Expression = strings.Split(input, "WHERE")[1]
 	entities := graph.QueryEntities(codeGraph, parsedQuery)