Checkerframework Implementation

build.gradle

@@ -3,8 +3,11 @@ plugins {
 	id 'application'
 	id("com.diffplug.spotless") version "7.0.4"
 	id 'jacoco'
+	id("org.checkerframework").version("0.6.61")
 }
 
+apply plugin: "org.checkerframework"
+
 group = 'com.example'
 version = '1.0'
 
@@ -27,6 +30,11 @@ dependencies {
 	implementation 'org.checkerframework:checker:3.21.0'
 	annotationProcessor 'org.checkerframework:checker:3.21.0'
 
+	// Specify Checker Framework v3.52.0
+	compileOnly("org.checkerframework:checker-qual:3.52.0")
+	testCompileOnly("org.checkerframework:checker-qual:3.52.0")
+	checkerFramework("org.checkerframework:checker:3.52.0")
+
 	// Apache Commons
 	implementation 'commons-io:commons-io:2.16.1'
 
@@ -49,6 +57,12 @@ dependencies {
 	runtimeOnly 'org.apache.logging.log4j:log4j-layout-template-json'
 }
 
+checkerFramework {
+// Define which checkers to run
+checkers = [
+	"org.checkerframework.checker.nullness.NullnessChecker",
+]
+}
 
 spotless {
 

src/main/java/AddNullCheckBeforeDereferenceRefactoring.java

@@ -16,8 +16,10 @@
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.text.edits.TextEditGroup;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.checkerframework.checker.nullness.qual.*;
 
 /**
  * A refactoring module that replaces checks on variables whose nullness is
@@ -51,7 +53,7 @@ public class AddNullCheckBeforeDereferenceRefactoring extends Refactoring {
 	 * key, ensuring global uniqueness. Two variables who have the same name but
 	 * have different scopes will have different IBinding instances.
 	 */
-	private final Map<IBinding, Expression> validRefactors;
+	private final Map<@NonNull IBinding, @NonNull Expression> validRefactors;
 
 	/** Default constructor (for RefactoringEngine integration) */
 	public AddNullCheckBeforeDereferenceRefactoring() {
@@ -60,7 +62,7 @@ public AddNullCheckBeforeDereferenceRefactoring() {
 	}
 
 	@Override
-	public boolean isApplicable(ASTNode node) {
+	public boolean isApplicable(@NonNull ASTNode node) {
 		if (node instanceof VariableDeclarationFragment varFrag) {
 			return isApplicable(varFrag);
 		}
@@ -77,7 +79,7 @@ public boolean isApplicable(ASTNode node) {
 		return false;
 	}
 
-	private boolean isApplicable(VariableDeclarationFragment var) {
+	private boolean isApplicable(@NonNull VariableDeclarationFragment var) {
 		Expression initializer = var.getInitializer();
 		if (initializer == null)
 			return false;
@@ -111,7 +113,7 @@ private boolean isApplicable(VariableDeclarationFragment var) {
 		return false;
 	}
 
-	private boolean isApplicable(IfStatement ifStmt) {
+	private boolean isApplicable(@NonNull IfStatement ifStmt) {
 		Expression ifStmtCondition = ifStmt.getExpression();
 		LOGGER.debug("Analyzing if-statement: %s", ifStmtCondition);
 		List<Expression> conditionFragments = Refactoring.getSubExpressions(ifStmtCondition);
@@ -145,7 +147,7 @@ private boolean isApplicable(IfStatement ifStmt) {
 	}
 
 	@Override
-	public void apply(ASTNode node, ASTRewrite rewriter) {
+	public void apply(@NonNull ASTNode node, @NonNull ASTRewrite rewriter) {
 		if (!(node instanceof IfStatement ifStmt)) {
 			return;
 		}
@@ -173,15 +175,22 @@ public void apply(ASTNode node, ASTRewrite rewriter) {
 			}
 
 			Expression ternary = validRefactors.get(varName.resolveBinding());
+			if (ternary == null) {
+				continue;
+			}
 
 			AST ast = node.getAST();
 			ParenthesizedExpression pExpression = ast.newParenthesizedExpression();
-			pExpression.setExpression((Expression) ASTNode.copySubtree(ast, ternary));
+			Expression expr = (Expression) ASTNode.copySubtree(ast, ternary);
+			if (expr == null) {
+				continue;
+			}
+			pExpression.setExpression(expr);
 
 			LOGGER.debug("[DEBUG] Replacing Variable: " + varName);
 			LOGGER.debug("[DEBUG] New Value: " + pExpression);
 
-			rewriter.replace(condition, pExpression, null);
+			rewriter.replace(condition, pExpression, new TextEditGroup(""));
 		}
 
 	}
@@ -190,7 +199,7 @@ public void apply(ASTNode node, ASTRewrite rewriter) {
 	 * Checks Assignment node to see if it re-assigns an existing valid refactoring,
 	 * and if so removes it from validRefactors
 	 */
-	private void verifyRefactors(Assignment assignmentNode) {
+	private void verifyRefactors(@NonNull Assignment assignmentNode) {
 		Expression lhs = assignmentNode.getLeftHandSide();
 		if (!(lhs instanceof SimpleName varName)) {
 			return;

src/main/java/BooleanFlagRefactoring.java

@@ -2,6 +2,7 @@
 import java.util.List;
 import java.util.Map;
 
+import org.checkerframework.checker.nullness.qual.*;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.Assignment;
@@ -18,6 +19,7 @@
 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 import org.eclipse.jdt.core.dom.InfixExpression.Operator;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.text.edits.TextEditGroup;
 
 /**
  * This class represents a refactoring in which boolean flags are replaced with
@@ -30,7 +32,7 @@ public class BooleanFlagRefactoring extends Refactoring {
 	 * List of variable names identified as boolean flags, along with their
 	 * corresponding initializer expression
 	 */
-	private final Map<IBinding, Expression> flagExpressions;
+	private final Map<IBinding, @NonNull Expression> flagExpressions;
 
 	/** Default constructor (for RefactoringEngine integration) */
 	public BooleanFlagRefactoring() {
@@ -39,7 +41,7 @@ public BooleanFlagRefactoring() {
 	}
 
 	@Override
-	public boolean isApplicable(ASTNode node) {
+	public boolean isApplicable(@NonNull ASTNode node) {
 		if (node instanceof VariableDeclarationStatement stmt) {
 			return isApplicable(stmt);
 		} else if (node instanceof IfStatement ifStmt) {
@@ -54,7 +56,7 @@ public boolean isApplicable(ASTNode node) {
 	 * Checks to see if a VariableDeclarationStatement defines a boolean flag that
 	 * represents another variable's nullness
 	 */
-	private boolean isApplicable(VariableDeclarationStatement stmt) {
+	private boolean isApplicable(@NonNull VariableDeclarationStatement stmt) {
 		boolean isBooleanDeclaration = (stmt.getType() instanceof PrimitiveType pType
 				&& pType.getPrimitiveTypeCode() == PrimitiveType.BOOLEAN);
 
@@ -66,7 +68,10 @@ private boolean isApplicable(VariableDeclarationStatement stmt) {
 		AST ast = stmt.getAST();
 
 		// Search through all declared variables in declaration node for a booleanflag
-		for (VariableDeclarationFragment frag : (List<VariableDeclarationFragment>) stmt.fragments()) {
+		@SuppressWarnings("unchecked") // Silence type warnings; fragments() documentation guarantees type is
+		// valid.
+		List<VariableDeclarationFragment> fragments = (List<VariableDeclarationFragment>) stmt.fragments();
+		for (VariableDeclarationFragment frag : fragments) {
 			Expression varInitializer = frag.getInitializer();
 			if (varInitializer == null) {
 				continue;
@@ -92,7 +97,7 @@ && getNullComparisonVariable(infix) != null) {
 	 * Analyzes an IfStatement to see if it contains a check utilizing an identified
 	 * boolean flag
 	 */
-	private boolean isApplicable(IfStatement ifStmt) {
+	private boolean isApplicable(@NonNull IfStatement ifStmt) {
 		List<Expression> exprFragments = Refactoring.getSubExpressions(ifStmt.getExpression());
 		for (Expression expr : exprFragments) {
 			if (expr instanceof InfixExpression infix && isEqualityOperator(infix.getOperator())) {
@@ -111,15 +116,15 @@ private boolean isApplicable(IfStatement ifStmt) {
 		return false;
 	}
 
-	private boolean isFlag(SimpleName potentialFlag) {
+	private boolean isFlag(@NonNull SimpleName potentialFlag) {
 		return flagExpressions.get(potentialFlag.resolveBinding()) != null;
 	}
 
-	private boolean isEqualityOperator(Operator op) {
+	private boolean isEqualityOperator(@NonNull Operator op) {
 		return (op == Operator.NOT_EQUALS || op == Operator.EQUALS);
 	}
 
-	private SimpleName getNullComparisonVariable(InfixExpression infix) {
+	private @Nullable SimpleName getNullComparisonVariable(@NonNull InfixExpression infix) {
 		Expression leftOperand = infix.getLeftOperand();
 		Expression rightOperand = infix.getRightOperand();
 		if (leftOperand instanceof SimpleName varName && rightOperand instanceof NullLiteral) {
@@ -132,7 +137,7 @@ private SimpleName getNullComparisonVariable(InfixExpression infix) {
 	}
 
 	@Override
-	public void apply(ASTNode node, ASTRewrite rewriter) {
+	public void apply(@NonNull ASTNode node, @NonNull ASTRewrite rewriter) {
 		if (!(node instanceof IfStatement ifStmt)) {
 			return;
 		}
@@ -148,13 +153,13 @@ public void apply(ASTNode node, ASTRewrite rewriter) {
 		}
 	}
 
-	private void apply(ASTRewrite rewriter, SimpleName flagName) {
+	private void apply(@NonNull ASTRewrite rewriter, @Nullable SimpleName flagName) {
 		if (flagName == null || !isFlag(flagName)) {
 			return;
 		}
 		Expression newExpr = flagExpressions.get(flagName.resolveBinding());
 		if (newExpr != null) {
-			rewriter.replace(flagName, newExpr, null);
+			rewriter.replace(flagName, newExpr, new TextEditGroup(""));
 		}
 
 	}
@@ -163,7 +168,7 @@ private void apply(ASTRewrite rewriter, SimpleName flagName) {
 	 * Checks Assignment node to see if it re-assigns an existing boolean flag, and
 	 * if so removes the flag from flagExpressions
 	 */
-	private void checkReassignment(Assignment assignmentNode) {
+	private void checkReassignment(@NonNull Assignment assignmentNode) {
 		Expression lhs = assignmentNode.getLeftHandSide();
 		if (!(lhs instanceof SimpleName varName)) {
 			return;

src/main/java/NestedNullRefactoring.java

@@ -2,7 +2,8 @@
 import java.util.Dictionary;
 import java.util.Hashtable;
 import java.util.List;
-
+import org.checkerframework.checker.nullness.qual.*;
+import org.eclipse.text.edits.TextEditGroup;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.Block;
@@ -32,14 +33,14 @@
 public class NestedNullRefactoring extends Refactoring {
 	public static final String NAME = "NestedNullRefactoring";
 
-	private final Dictionary<IMethodBinding, Expression> applicableMethods;
+	private final Dictionary<IMethodBinding, @NonNull Expression> applicableMethods;
 
 	public NestedNullRefactoring() {
 		applicableMethods = new Hashtable<>();
 	}
 
 	@Override
-	public boolean isApplicable(ASTNode node) {
+	public boolean isApplicable(@NonNull ASTNode node) {
 		if (node instanceof MethodInvocation invocation) {
 			return isApplicableImpl(invocation);
 		}
@@ -55,7 +56,7 @@ public boolean isApplicable(ASTNode node) {
 	 * Returns true iff the provided invocation is of a registered one-line method
 	 * that returns the result of a null check
 	 */
-	private boolean isApplicableImpl(MethodInvocation invocation) {
+	private boolean isApplicableImpl(@NonNull MethodInvocation invocation) {
 		if (applicableMethods.get(invocation.resolveMethodBinding()) != null) {
 			System.out.println("[DEBUG] Invocation of applicable method found");
 			return true;
@@ -67,7 +68,7 @@ private boolean isApplicableImpl(MethodInvocation invocation) {
 	 * Returns true iff Node is a one-line private method that returns the result of
 	 * a null check
 	 */
-	private boolean isApplicableImpl(MethodDeclaration declaration) {
+	private boolean isApplicableImpl(@NonNull MethodDeclaration declaration) {
 		// getReturnType() is deprecated and replaced by getReturnType2()
 		Type retType = declaration.getReturnType2();
 		boolean returnsBoolean = (retType.isPrimitiveType()
@@ -90,7 +91,12 @@ private boolean isApplicableImpl(MethodDeclaration declaration) {
 		}
 
 		Block body = declaration.getBody();
-		List<Statement> stmts = body.statements();
+		if (body == null) {
+			return false;
+		}
+
+		@SuppressWarnings("unchecked") // Silence type warnings; statements() documentation guarantees type is valid.
+		List<Statement> stmts = (List<Statement>) body.statements();
 
 		boolean isOneLine = stmts.size() == 1;
 		if (!isOneLine) {
@@ -104,7 +110,7 @@ private boolean isApplicableImpl(MethodDeclaration declaration) {
 
 		// Checks that the return statement is of a single equality check
 		Expression retExpr = ((ReturnStatement) stmt).getExpression();
-		if (!(retExpr instanceof InfixExpression)) {
+		if (retExpr == null || !(retExpr instanceof InfixExpression)) {
 			return false;
 		}
 
@@ -118,7 +124,11 @@ private boolean isApplicableImpl(MethodDeclaration declaration) {
 			if ((isValidOperand(leftOperand) && rightOperand instanceof NullLiteral)
 					|| (isValidOperand(rightOperand) && leftOperand instanceof NullLiteral)) {
 				System.out.println("[DEBUG] Found one line null check method: " + declaration.getName());
-				applicableMethods.put((declaration.resolveBinding()), retExpr);
+				IMethodBinding binding = declaration.resolveBinding();
+				if (binding == null) {
+					return false;
+				}
+				applicableMethods.put((binding), retExpr);
 			}
 		}
 		return false;
@@ -128,12 +138,12 @@ private boolean isApplicableImpl(MethodDeclaration declaration) {
 	 * Returns true iff the provided expression can be on one side of a refactorable
 	 * null equality check, i.e. it represents a valid variable or constant.
 	 */
-	private boolean isValidOperand(Expression operand) {
+	private boolean isValidOperand(@NonNull Expression operand) {
 		return (operand instanceof SimpleName || operand instanceof FieldAccess || operand instanceof QualifiedName);
 	}
 
 	@Override
-	public void apply(ASTNode node, ASTRewrite rewriter) {
+	public void apply(@NonNull ASTNode node, @NonNull ASTRewrite rewriter) {
 		// Check if Method Invocation is in applicableMethods
 		if (node instanceof MethodInvocation invocation) {
 			replace(node, rewriter, invocation);
@@ -143,8 +153,13 @@ public void apply(ASTNode node, ASTRewrite rewriter) {
 		}
 	}
 
-	private void replace(ASTNode node, ASTRewrite rewriter, MethodInvocation invocation) {
-		Expression expr = (applicableMethods.get((invocation.resolveMethodBinding())));
+	private void replace(@NonNull ASTNode node, @NonNull ASTRewrite rewriter, @NonNull MethodInvocation invocation) {
+		IMethodBinding binding = invocation.resolveMethodBinding();
+		if (binding == null) {
+			return;
+		}
+
+		Expression expr = (applicableMethods.get(binding));
 		if (expr == null) {
 			System.err.println("Cannot find applicable method for refactoring. ");
 			return;
@@ -158,7 +173,7 @@ private void replace(ASTNode node, ASTRewrite rewriter, MethodInvocation invocat
 		pExpr.setExpression(copiedExpression);
 
 		System.out.println("Refactoring " + node + "\n\tReplacing \n\t" + invocation + "\n\tWith \n\t" + pExpr);
-		rewriter.replace(invocation, pExpr, null);
+		rewriter.replace(invocation, pExpr, new TextEditGroup(""));
 
 	}