Merge branch 'improve-1'

Author: nedpals

.gitignore

@@ -1,3 +1,5 @@
+.DS_Store
+
 # If you prefer the allow list template instead of the deny list, see community template:
 # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
 #
@@ -20,4 +22,6 @@
 # Go workspace file
 go.work
 
-bin
+bin
+
+*.class

PROMPT.txt

@@ -0,0 +1,94 @@
+Pretend that you are a debugging assistant for novice programmers and your responses must be backed by the Kolb Experiential Learning Theory.
+
+You will be given the language used, error code, the source code/s (with the filename/s), and the corresponding error message.
+
+The structure should look like this:
+
+Language: {{language}}
+Error Code: {{error_code}}
+Source code:
+{{filename}}
+```
+{{source code}}
+```
+Error message:
+```
+{{error_message}}
+```
+
+The target audience of this would be students from the Philippines who don't know how to read the error messages or does not know how to do debugging. They also have a short attention span so longer explanations do not work for them. This is learning by doing so make them understand and gradually do not rely on this tool.
+
+---
+
+The format should be like this (STICK TO THIS!):
+# {{error_code}}
+{{general description of the error}}
+{{explanation local to the file}}
+
+## Steps to fix
+{{for every bug fix suggestion}}
+### {{suggestion number}}. {{suggestion title}}
+{{step number}}. {{short simple explanation of the fix}}
+{{if there are code changes}}
+```diff
+{{two lines before the offending line/s}}
+- {{offending line/s}}
++ {{propose code}}
+{{two lines after the offending line/s if available}}
+```
+{{endif}}
+{{endfor}}
+
+"Steps to fix" notes:
+- Offending code must be surrounded by two lines above it and two lines below it
+- Proposed code must be indicated by "+" before, offending code / code must be denoted by "-"
+- If error is on multiple files, rely on the stack trace if present.
+- Code modification is not necessary.
+- You may give more than one bug fix suggestion.
+
+DO NOT APOLGIZE. just straight return the provided result in the desired format.
+
+===
+
+TEST FILE PROMPT
+
+Pretend that you are unit test case generator for a debugging assistant for novice programmers and your responses must be backed by the Kolb Experiential Learning Theory.
+
+The structure of the input will look like this:
+
+template: {{language}}.{{error_code}}
+error type: {{runtime or compile-time}}
+description: {{error description}}
+{{if example_error_message}}
+example error message:
+```
+{{example_error_message}}
+```
+{{endif}}
+
+The target audience of this would be students from the Philippines who don't know how to read the error messages or does not know how to do debugging. They also have a short attention span so longer explanations do not work for them. This is learning by doing so make them understand and gradually do not rely on this tool.
+
+---
+
+The expected output should be a unit test case which consists of a sample test program and test template. The format should be like this (STICK TO THIS!):
+
+Source code:
+```
+// {{name}}.{{language extension}}
+{{program code}}
+```
+
+Test template:
+```
+template: "{{language}}.{{error_code}}"
+---
+{{if example_error_message}}
+{{example_error_message}}
+{{else}}
+{{generated compiler/runtime error message similar to language's compiler}}
+{{endif}}
+```
+
+Notes:
+- Filename / class name should be short
+- No need to add comments in the source code. Make it simple to reproduce as possible

context.go

@@ -4,9 +4,10 @@ type MainError struct {
 	ErrorNode *StackTraceEntry
 	Document  *Document
 	Nearest   SyntaxNode
+	Context   any
 }
 
-func (err MainError) DocumentPath() string {
+func (err *MainError) DocumentPath() string {
 	return err.ErrorNode.DocumentPath
 }
 
@@ -17,7 +18,7 @@ type ContextData struct {
 	CurrentDocumentPath string
 	Variables           map[string]string
 	TraceStack          TraceStack
-	MainError           MainError
+	MainError           *MainError
 }
 
 func NewContextData(store *Store, workingPath string) *ContextData {
@@ -30,7 +31,7 @@ func NewContextData(store *Store, workingPath string) *ContextData {
 }
 
 func (data *ContextData) MainDocumentPath() string {
-	if data.MainError.ErrorNode != nil {
+	if data.MainError != nil && data.MainError.ErrorNode != nil {
 		return data.MainError.DocumentPath()
 	}
 	return data.CurrentDocumentPath

errgoengine.go

@@ -12,14 +12,21 @@ import (
 type ErrgoEngine struct {
 	SharedStore    *Store
 	ErrorTemplates ErrorTemplates
-	FS             fs.ReadFileFS
+	FS             *MultiReadFileFS
+	OutputGen      *OutputGenerator
 }
 
 func New() *ErrgoEngine {
+	filesystems := make([]fs.ReadFileFS, 2)
+	filesystems[0] = &RawFS{}
+
 	return &ErrgoEngine{
 		SharedStore:    NewEmptyStore(),
 		ErrorTemplates: ErrorTemplates{},
-		FS:             &RawFS{},
+		FS: &MultiReadFileFS{
+			FSs: filesystems,
+		},
+		OutputGen: &OutputGenerator{},
 	}
 }
 
@@ -32,6 +39,7 @@ func (e *ErrgoEngine) Analyze(workingPath, msg string) (*CompiledErrorTemplate,
 	// initial context data extraction
 	contextData := NewContextData(e.SharedStore, workingPath)
 	contextData.Analyzer = template.Language.AnalyzerFactory(contextData)
+	e.FS.FSs[1] = template.Language.stubFs
 
 	groupNames := template.Pattern.SubexpNames()
 	for _, submatches := range template.Pattern.FindAllStringSubmatch(msg, -1) {
@@ -86,6 +94,11 @@ func (e *ErrgoEngine) Analyze(workingPath, msg string) (*CompiledErrorTemplate,
 			return nil, nil, err
 		}
 
+		// Skip stub files
+		if len(contents) == 0 {
+			continue
+		}
+
 		var selectedLanguage *Language
 		existingDoc, docExists := contextData.Documents[node.DocumentPath]
 
@@ -122,28 +135,38 @@ func (e *ErrgoEngine) Analyze(workingPath, msg string) (*CompiledErrorTemplate,
 	// get nearest node
 	doc := contextData.Documents[mainTraceNode.DocumentPath]
 	nearest := doc.Tree.RootNode().NamedDescendantForPointRange(
-		sitter.Point{Row: uint32(mainTraceNode.Line)},
-		sitter.Point{Row: uint32(mainTraceNode.Line)},
+		sitter.Point{Row: uint32(mainTraceNode.StartPos.Line)},
+		sitter.Point{Row: uint32(mainTraceNode.EndPos.Line)},
 	)
 
-	if nearest.StartPoint().Row != uint32(mainTraceNode.Line) {
+	if nearest.StartPoint().Row != uint32(mainTraceNode.StartPos.Line) {
 		cursor := sitter.NewTreeCursor(nearest)
-		nearest = nearestNodeFromPos(cursor, mainTraceNode.Position)
+		nearest = nearestNodeFromPos(cursor, mainTraceNode.StartPos)
 	}
 
-	contextData.MainError = MainError{
+	// further analyze main error
+	contextData.MainError = &MainError{
 		ErrorNode: &mainTraceNode,
 		Document:  doc,
 		Nearest:   WrapNode(doc, nearest),
 	}
 
+	if contextData.MainError != nil && template.OnAnalyzeErrorFn != nil {
+		template.OnAnalyzeErrorFn(contextData, contextData.MainError)
+	}
+
 	return template, contextData, nil
 }
 
 func (e *ErrgoEngine) Translate(template *CompiledErrorTemplate, contextData *ContextData) string {
+	expGen := &ExplainGenerator{errorName: template.Name}
+	fixGen := &BugFixGenerator{}
+
 	// execute error generator function
-	explanation := template.OnGenExplainFn(contextData)
-	// TODO: execute bug fix generator function
-	_ = template.OnGenBugFixFn(contextData)
-	return explanation
+	template.OnGenExplainFn(contextData, expGen)
+	template.OnGenBugFixFn(contextData, fixGen)
+
+	output := e.OutputGen.Generate(contextData, expGen, fixGen)
+	defer e.OutputGen.Reset()
+	return output
 }

error_template.go

@@ -6,10 +6,13 @@ import (
 	"strings"
 )
 
+type GenAnalyzeErrorFn func(cd *ContextData, m *MainError)
+
 type ErrorTemplate struct {
 	Name              string
 	Pattern           string
 	StackTracePattern string
+	OnAnalyzeErrorFn  GenAnalyzeErrorFn
 	OnGenExplainFn    GenExplainFn
 	OnGenBugFixFn     GenBugFixFn
 }

error_template_test.go

@@ -9,6 +9,10 @@ import (
 
 type TestAnalyzer struct{}
 
+func (TestAnalyzer) FallbackSymbol() lib.Symbol {
+	return nil
+}
+
 func (TestAnalyzer) AnalyzeNode(lib.SyntaxNode) lib.Symbol {
 	return nil
 }
@@ -24,16 +28,17 @@ var testLanguage = &lib.Language{
 	LocationConverter: func(path, pos string) lib.Location {
 		return lib.Location{
 			DocumentPath: path,
-			Position:     lib.Position{0, 0, 0},
+			StartPos:     lib.Position{0, 0, 0},
+			EndPos:       lib.Position{0, 0, 0},
 		}
 	},
 	AnalyzerFactory: func(cd *lib.ContextData) lib.LanguageAnalyzer {
 		return TestAnalyzer{}
 	},
 }
 
-func emptyExplainFn(cd *lib.ContextData) string      { return "" }
-func emptyBugFixFn(cd *lib.ContextData) []lib.BugFix { return make([]lib.BugFix, 0) }
+func emptyExplainFn(cd *lib.ContextData, gen *lib.ExplainGenerator) {}
+func emptyBugFixFn(cd *lib.ContextData, gen *lib.BugFixGenerator)   {}
 
 func setupTemplate(template lib.ErrorTemplate) (*lib.CompiledErrorTemplate, error) {
 	errorTemplates := lib.ErrorTemplates{}

error_templates/java/arithmetic_exception.go

@@ -1,23 +1,108 @@
 package java
 
-import lib "github.com/nedpals/errgoengine"
+import (
+	"strings"
+
+	lib "github.com/nedpals/errgoengine"
+)
+
+type arithExceptionKind int
+
+const (
+	unknown               arithExceptionKind = 0
+	dividedByZero         arithExceptionKind = iota
+	nonTerminatingDecimal arithExceptionKind = iota
+)
+
+type arithExceptionCtx struct {
+	kind arithExceptionKind
+}
 
 var ArithmeticException = lib.ErrorTemplate{
 	Name:    "ArithmeticException",
 	Pattern: runtimeErrorPattern("java.lang.ArithmeticException", "(?P<reason>.+)"),
-	OnGenExplainFn: func(cd *lib.ContextData) string {
+	OnAnalyzeErrorFn: func(cd *lib.ContextData, err *lib.MainError) {
+		ctx := arithExceptionCtx{}
 		reason := cd.Variables["reason"]
+		query := ""
+
 		switch reason {
 		case "/ by zero":
-			return "One of your variables initialized a double value by dividing a number to zero"
+			ctx.kind = dividedByZero
+			query = "(_) \"/\" ((decimal_integer_literal) @literal (#eq? @literal \"0\"))"
 		case "Non-terminating decimal expansion; no exact representable decimal result.":
-			return "TODO"
+			ctx.kind = nonTerminatingDecimal
+			query = "(method_invocation) @methodCall (#eq? @methodCall \".divide\")"
 		default:
-			return "Unknown ArithmeticException"
+			ctx.kind = unknown
+		}
+
+		if len(query) != 0 {
+			lib.QueryNode(cd.MainError.Nearest, strings.NewReader(query), func(ctx lib.QueryNodeCtx) bool {
+				match := ctx.Cursor.FilterPredicates(ctx.Match, []byte(cd.MainError.Nearest.Doc.Contents))
+				for _, c := range match.Captures {
+					node := lib.WrapNode(cd.MainError.Nearest.Doc, c.Node)
+					err.Nearest = node
+					return false
+				}
+				return true
+			})
+		}
+
+		err.Context = ctx
+	},
+	OnGenExplainFn: func(cd *lib.ContextData, gen *lib.ExplainGenerator) {
+		ctx := cd.MainError.Context.(arithExceptionCtx)
+		switch ctx.kind {
+		case dividedByZero:
+			gen.Add("This error is raised when you try to perform arithmetic operations that are not mathematically possible, such as division by zero.")
+		case nonTerminatingDecimal:
+			gen.Add("This error is raised when dividing two `BigDecimal` numbers, and the division operation results in a non-terminating decimal expansion, meaning the division produces a non-repeating and non-terminating decimal.")
+		case unknown:
+			gen.Add("You just encountered an unknown `ArithmeticException` error of which we cannot explain to you properly.")
 		}
 	},
-	OnGenBugFixFn: func(cd *lib.ContextData) []lib.BugFix {
-		// TODO:
-		return make([]lib.BugFix, 0)
+	OnGenBugFixFn: func(cd *lib.ContextData, gen *lib.BugFixGenerator) {
+		ctx := cd.MainError.Context.(arithExceptionCtx)
+		switch ctx.kind {
+		case dividedByZero:
+			gen.Add("Avoid dividing by zero.", func(s *lib.BugFixSuggestion) {
+				s.AddStep("To fix the 'ArithmeticException: / by zero', you need to ensure you are not dividing by zero, which is mathematically undefined.").
+					AddFix(lib.FixSuggestion{
+						NewText:       "1",
+						Description:   "This adjustment replaces the division by zero with a value that is not zero, ensuring the operation is valid. Division by zero is mathematically undefined, causing an 'ArithmeticException'. By changing the denominator to a non-zero value, you prevent the error.",
+						StartPosition: cd.MainError.Nearest.StartPosition(),
+						EndPosition:   cd.MainError.Nearest.EndPosition(),
+					})
+			})
+		case nonTerminatingDecimal:
+			gen.Add("Ensure precise division", func(s *lib.BugFixSuggestion) {
+				s.AddStep("To fix the 'ArithmeticException: Non-terminating decimal expansion', you need to ensure the division operation is precise.").
+					AddFix(lib.FixSuggestion{
+						NewText:       ", RoundingMode.HALF_UP)",
+						StartPosition: cd.MainError.Nearest.EndPosition(),
+						EndPosition:   cd.MainError.Nearest.EndPosition(),
+					})
+			})
+
+			if parent := cd.MainError.Nearest.Parent(); parent.Type() == "block" {
+				gen.Add("Catch ArithmeticException", func(s *lib.BugFixSuggestion) {
+					firstChild := parent.FirstNamedChild()
+					lastChild := parent.LastNamedChild()
+
+					s.AddStep("Handle the ArithmeticException by wrapping the division operation in a try-catch block to manage the potential exception and inform the user about the non-terminating result.").
+						AddFix(lib.FixSuggestion{
+							NewText:       "try {",
+							StartPosition: firstChild.StartPosition(),
+							EndPosition:   firstChild.StartPosition(),
+						}).
+						AddFix(lib.FixSuggestion{
+							NewText:       "} catch (ArithmeticException e) {\n\tSystem.out.println(\"Non-terminating result: \" + e.getMessage());\n}",
+							StartPosition: lastChild.StartPosition(),
+							EndPosition:   lastChild.StartPosition(),
+						})
+				})
+			}
+		}
 	},
 }