todo templates

Author: nedpals

error_templates/java/arithmetic_exception.go

@@ -2,17 +2,43 @@ package java
 
 import 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, gen *lib.ExplainGenerator) {
+	OnAnalyzeErrorFn: func(cd *lib.ContextData, err *lib.MainError) {
+		ctx := arithExceptionCtx{}
 		reason := cd.Variables["reason"]
 		switch reason {
 		case "/ by zero":
-			gen.Add("One of your variables initialized a double value by dividing a number to zero")
+			ctx.kind = dividedByZero
 		case "Non-terminating decimal expansion; no exact representable decimal result.":
-			gen.Add("TODO")
+			ctx.kind = nonTerminatingDecimal
 		default:
+			ctx.kind = unknown
+		}
+		err.Context = ctx
+	},
+	OnGenExplainFn: func(cd *lib.ContextData, gen *lib.ExplainGenerator) {
+		ctx := cd.MainError.Context.(arithExceptionCtx)
+		switch ctx.kind {
+		case dividedByZero:
+			ctx.kind = dividedByZero
+			gen.Add("One of your variables initialized a double value by dividing a number to zero")
+		case nonTerminatingDecimal:
+			gen.Add("TODO")
+		case unknown:
 			gen.Add("Unknown ArithmeticException")
 		}
 	},

error_templates/java/null_pointer_exception.go

@@ -5,59 +5,30 @@ import (
 	"github.com/nedpals/errgoengine/languages/java"
 )
 
-// const ()
+type exceptionLocationKind int
+
+const (
+	fromUnknown          exceptionLocationKind = 0
+	fromFunctionArgument exceptionLocationKind = iota
+	fromSystemOut        exceptionLocationKind = iota
+	fromArrayAccess      exceptionLocationKind = iota
+	fromExpression       exceptionLocationKind = iota
+	fromMethodInvocation exceptionLocationKind = iota
+)
 
-// type nullPointerExceptionCtx struct {
-// 	isSystemOut bool
-// }
+type nullPointerExceptionCtx struct {
+	kind exceptionLocationKind
+	// symbolInvolved lib.SyntaxNode
+	methodName string
+	origin     string
+}
 
 // TODO: unit testing
 var NullPointerException = lib.ErrorTemplate{
 	Name:    "NullPointerException",
 	Pattern: runtimeErrorPattern("java.lang.NullPointerException", ""),
-	// OnAnalyzeErrorFn: func(cd *lib.ContextData, m *lib.MainError) {
-	// 	ctx := nullPointerExceptionCtx{}
-
-	// 	// if the offending line is an offending method call, get the argument that triggered the null error
-	// 	if cd.MainError.Nearest.Type() == "expression_statement" {
-	// 		exprNode := cd.MainError.Nearest.NamedChild(0)
-
-	// 		// NOTE: i hope we will be able to parse the entire
-	// 		// java system library without hardcoding the definitions lol
-	// 		if exprNode.Type() == "method_invocation" {
-	// 			objNode := exprNode.ChildByFieldName("object")
-	// 			// check if this is just simple printing
-	// 			if objNode.Text() == "System.out" {
-	// 				isSystemOut = true
-	// 			} else if retType := cd.Analyzer.AnalyzeNode(exprNode); retType == java.BuiltinTypes.NullSymbol {
-	// 				cd.MainError.Nearest = exprNode
-	// 			}
-
-	// 			if objNode.Type() == "array_access" {
-	// 				// inArray = true
-	// 				cd.MainError.Nearest = exprNode
-	// 			} else {
-	// 				arguments := exprNode.ChildByFieldName("arguments")
-	// 				for i := 0; i < int(arguments.NamedChildCount()); i++ {
-	// 					argNode := arguments.NamedChild(i)
-	// 					retType := cd.Analyzer.AnalyzeNode(argNode)
-
-	// 					if retType == java.BuiltinTypes.NullSymbol || argNode.Type() == "array_access" {
-	// 						cd.MainError.Nearest = argNode
-	// 						break
-	// 					}
-	// 				}
-	// 			}
-	// 		}
-	// 	}
-	// },
-	OnGenExplainFn: func(cd *lib.ContextData, gen *lib.ExplainGenerator) {
-		// TODO: create a function that will find the node with a null return type
-		// sb := &strings.Builder{}
-		isSystemOut := false
-		// inArray := false
-		methodName := ""
-		origin := ""
+	OnAnalyzeErrorFn: func(cd *lib.ContextData, err *lib.MainError) {
+		ctx := nullPointerExceptionCtx{}
 
 		// if the offending line is an offending method call, get the argument that triggered the null error
 		if cd.MainError.Nearest.Type() == "expression_statement" {
@@ -69,14 +40,16 @@ var NullPointerException = lib.ErrorTemplate{
 				objNode := exprNode.ChildByFieldName("object")
 				// check if this is just simple printing
 				if objNode.Text() == "System.out" {
-					isSystemOut = true
+					ctx.kind = fromSystemOut
 				} else if retType := cd.Analyzer.AnalyzeNode(exprNode); retType == java.BuiltinTypes.NullSymbol {
 					cd.MainError.Nearest = exprNode
+					ctx.kind = fromMethodInvocation
 				}
 
 				if objNode.Type() == "array_access" {
 					// inArray = true
 					cd.MainError.Nearest = exprNode
+					ctx.kind = fromArrayAccess
 				} else {
 					arguments := exprNode.ChildByFieldName("arguments")
 					for i := 0; i < int(arguments.NamedChildCount()); i++ {
@@ -85,42 +58,53 @@ var NullPointerException = lib.ErrorTemplate{
 
 						if retType == java.BuiltinTypes.NullSymbol || argNode.Type() == "array_access" {
 							cd.MainError.Nearest = argNode
+							ctx.kind = fromFunctionArgument
 							break
 						}
 					}
 				}
+			} else if exprNode.Type() == "assignment_expression" {
+				// right := exprNode.ChildByFieldName("right")
+				//
+			}
+
+			// identify the *MAIN* culprit
+			mainNode := cd.MainError.Nearest
+			switch mainNode.Type() {
+			case "method_invocation":
+				nameNode := mainNode.ChildByFieldName("name")
+				ctx.methodName = nameNode.Text()
+				ctx.origin = mainNode.ChildByFieldName("object").Text()
+			default:
+				ctx.origin = mainNode.Text()
 			}
-		}
 
-		// identify the *MAIN* culprit
-		mainNode := cd.MainError.Nearest
-		switch mainNode.Type() {
-		case "method_invocation":
-			nameNode := mainNode.ChildByFieldName("name")
-			methodName = nameNode.Text()
-			origin = mainNode.ChildByFieldName("object").Text()
-		default:
-			origin = mainNode.Text()
+			err.Context = ctx
 		}
+	},
+	OnGenExplainFn: func(cd *lib.ContextData, gen *lib.ExplainGenerator) {
+		// TODO: create a function that will find the node with a null return type
+		ctx := cd.MainError.Context.(nullPointerExceptionCtx)
 
-		if isSystemOut {
-			if len(methodName) != 0 {
-				gen.Add("Your program tried to print the value of \"%s\" method from \"%s\" which is a null.", methodName, origin)
-			} else {
-				gen.Add("Your program tried to print the value of \"%s\" which is a null", origin)
+		if ctx.kind == fromSystemOut {
+			gen.Add("Your program tried to print the value of ")
+			if len(ctx.methodName) != 0 {
+				gen.Add("\"%s\" method from ", ctx.methodName)
 			}
-		} else if len(methodName) != 0 {
+			gen.Add("\"%s\" which is a null.", ctx.origin)
+			return
+		} else if len(ctx.methodName) != 0 {
 			// if inArray {
 			// 	gen.Add("Your program tried to execute the \"%s\" method from \"%s\" which is a null.", )
 			// } else {
-			gen.Add("Your program tried to execute the \"%s\" method from \"%s\" which is a null.", methodName, origin)
+			gen.Add("Your program tried to execute the \"%s\" method from \"%s\" which is a null.", ctx.methodName, ctx.origin)
 			// }
+			return
 		}
 
 		gen.Add("Your program try to access or manipulate an object reference that is currently pointing to `null`, meaning it doesn't refer to any actual object in memory. This typically happens when you forget to initialize an object before using it, or when you try to access an object that hasn't been properly assigned a value. ")
 	},
 	OnGenBugFixFn: func(cd *lib.ContextData, gen *lib.BugFixGenerator) {
-		// TODO:
 
 	},
 }

error_templates/java/test_files/non_static_method_access_error/test.txt

@@ -7,4 +7,16 @@ Main.java:9: error: non-static method printMessage() cannot be referenced from a
 ===
 template: "Java.NonStaticMethodAccessError"
 ---
-aa
+# NonStaticMethodAccessError
+In the `Main` class, you have invoked the `printMessage` method inside the `main` static method. 
+                
+```
+        // Attempt to call the non-static method without creating an object
+        printMessage(); // This will result in an error
+        ^^^^^^^^^^^^
+    }
+}
+
+```
+## Steps to fix
+1. Fix 1

error_templates/java/test_files/null_pointer_exception/test.txt

@@ -5,4 +5,7 @@ Exception in thread "main" java.lang.NullPointerException
 ===
 template: "Java.NullPointerException"
 ---
+# NullPointerException
 Your program tried to print the value of "toUpperCase" method from "test" which is a null.
+## Steps to fix
+1. Go to blabla

error_templates/java/test_files/unknown_variable_error/test.txt

@@ -9,4 +9,15 @@ Program.java:3: error: cannot find symbol
 ===
 template: "Java.UnknownVariableError"
 ---
+# UnknownVariableError
 The program cannot find variable "a"
+```
+    public static void main(String[] args) {
+        System.out.println(a);
+                           ^
+    }
+}
+
+```
+## Steps to fix
+Nothing to fix

error_templates/java/test_files/unreachable_statement_error/test.txt

@@ -7,4 +7,16 @@ Unreachable.java:5: error: unreachable statement
 ===
 template: "Java.UnreachableStatementError"
 ---
-You have code below after you returned a value
+# UnreachableStatementError
+Portions of the code weren't accessible because you returned a value on top of it.
+
+```
+        return;
+        System.out.println("c");
+        ^^^^^^^^^^^^^^^^^^^^^^^
+    }
+}
+
+```
+## Steps to fix
+Nothing to fix

error_templates/java/unknown_variable_error.go

@@ -1,17 +1,44 @@
 package java
 
 import (
+	"fmt"
+	"strings"
+
 	lib "github.com/nedpals/errgoengine"
 )
 
+type unknownVarErrorCtx struct {
+	rootNode   lib.SyntaxNode
+	parentNode lib.SyntaxNode
+}
+
 var UnknownVariableError = lib.ErrorTemplate{
 	Name:              "UnknownVariableError",
 	Pattern:           comptimeErrorPattern("cannot find symbol", `symbol:\s+variable (?P<variable>\S+)`),
 	StackTracePattern: comptimeStackTracePattern,
+	OnAnalyzeErrorFn: func(cd *lib.ContextData, m *lib.MainError) {
+		variable := cd.Variables["variable"]
+		query := fmt.Sprintf("((identifier) @symbol (#eq? @symbol \"%s\"))", variable)
+
+		lib.QueryNode(m.Nearest, strings.NewReader(query), func(ctx lib.QueryNodeCtx) bool {
+			match := ctx.Cursor.FilterPredicates(ctx.Match, []byte(m.Nearest.Doc.Contents))
+			for _, c := range match.Captures {
+				node := lib.WrapNode(m.Nearest.Doc, c.Node)
+				m.Context = unknownVarErrorCtx{m.Nearest, node.Parent()}
+				m.Nearest = node
+				return false
+			}
+			return true
+		})
+	},
 	OnGenExplainFn: func(cd *lib.ContextData, gen *lib.ExplainGenerator) {
 		gen.Add(`The program cannot find variable "%s"`, cd.Variables["variable"])
 	},
 	OnGenBugFixFn: func(cd *lib.ContextData, gen *lib.BugFixGenerator) {
-		// TODO:
+		ctx := cd.MainError.Context.(unknownVarErrorCtx)
+		variable := cd.Variables["variable"]
+		gen.AddStep("(%s) Create a variable named \"%s\". For example: ", ctx.parentNode.Type(), variable).
+			// TODO: use variable type from the inferred parameter
+			AddFix(fmt.Sprintf("String %s = \"\";", variable), ctx.rootNode.StartPosition(), false)
 	},
 }