Add Diagnostic Classes

Author: rcosta358

liquidjava-verifier/src/main/java/liquidjava/errors/ErrorPosition.java

@@ -1,18 +1,19 @@
 package liquidjava.errors;
 
+import spoon.reflect.cu.SourcePosition;
+
 public class ErrorPosition {
 
     private int lineStart;
     private int colStart;
-
     private int lineEnd;
     private int colEnd;
 
-    public ErrorPosition(int line1, int col1, int line2, int col2) {
-        lineStart = line1;
-        colStart = col1;
-        lineEnd = line2;
-        colEnd = col2;
+    public ErrorPosition(int lineStart, int colStart, int lineEnd, int colEnd) {
+        this.lineStart = lineStart;
+        this.colStart = colStart;
+        this.lineEnd = lineEnd;
+        this.colEnd = colEnd;
     }
 
     public int getLineStart() {
@@ -30,4 +31,10 @@ public int getLineEnd() {
     public int getColEnd() {
         return colEnd;
     }
+
+    public static ErrorPosition fromSpoonPosition(SourcePosition pos) {
+        if (pos == null || !pos.isValidPosition())
+            return null;
+        return new ErrorPosition(pos.getLine(), pos.getColumn(), pos.getEndLine(), pos.getEndColumn());
+    }
 }

liquidjava-verifier/src/main/java/liquidjava/errors/LJDiagnostics.java

@@ -0,0 +1,93 @@
+package liquidjava.errors;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import liquidjava.errors.errors.LJError;
+import liquidjava.errors.warnings.LJWarning;
+import liquidjava.processor.context.PlacementInCode;
+
+public class LJDiagnostics {
+    private static LJDiagnostics instance;
+
+    private ArrayList<LJError> errors;
+    private ArrayList<LJWarning> warnings;
+    private HashMap<String, PlacementInCode> translationMap;
+
+    private LJDiagnostics() {
+        this.errors = new ArrayList<>();
+        this.warnings = new ArrayList<>();
+        this.translationMap = new HashMap<>();
+    }
+
+    public static LJDiagnostics getInstance() {
+        if (instance == null)
+            instance = new LJDiagnostics();
+        return instance;
+    }
+
+    public void addError(LJError error) {
+        this.errors.add(error);
+    }
+
+    public void addWarning(LJWarning warning) {
+        this.warnings.add(warning);
+    }
+
+    public void setTranslationMap(HashMap<String, PlacementInCode> map) {
+        this.translationMap = map;
+    }
+
+    public boolean foundError() {
+        return !this.errors.isEmpty();
+    }
+
+    public boolean foundWarning() {
+        return !this.warnings.isEmpty();
+    }
+
+    public ArrayList<LJError> getErrors() {
+        return this.errors;
+    }
+
+    public ArrayList<LJWarning> getWarnings() {
+        return this.warnings;
+    }
+
+    public HashMap<String, PlacementInCode> getTranslationMap() {
+        return this.translationMap;
+    }
+
+    public LJError getError() {
+        return foundError() ? this.errors.get(0) : null;
+    }
+
+    public LJWarning getWarning() {
+        return foundWarning() ? this.warnings.get(0) : null;
+    }
+
+    public void clear() {
+        this.errors.clear();
+        this.warnings.clear();
+        this.translationMap.clear();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        if (foundError()) {
+            for (LJError error : errors) {
+                sb.append(error.toString()).append("\n");
+            }
+        } else {
+            if (foundWarning()) {
+                sb.append("Warnings:\n");
+                for (LJWarning warning : warnings) {
+                    sb.append(warning.getMessage()).append("\n");
+                }
+                sb.append("Passed Verification!\n");
+            }
+        }
+        return sb.toString();
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/CustomError.java

@@ -0,0 +1,13 @@
+package liquidjava.errors.errors;
+
+public class CustomError extends LJError {
+
+    public CustomError(String message) {
+        super("Found Error", message, null);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString(null);
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/GhostInvocationError.java

@@ -0,0 +1,26 @@
+package liquidjava.errors.errors;
+
+import liquidjava.rj_language.Predicate;
+import spoon.reflect.declaration.CtElement;
+
+// when a ghost call has wrong types or number of arguments
+public class GhostInvocationError extends LJError {
+
+    private Predicate expected;
+
+    public GhostInvocationError(CtElement element, Predicate expected) {
+        super("Ghost Invocation Error", "Invalid types or number of arguments in ghost invocation", element);
+        this.expected = expected;
+    }
+
+    public Predicate getExpected() {
+        return expected;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Expected: ").append(expected.toString()).append("\n");
+        return super.toString(sb.toString());
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/IllegalConstructorTransitionError.java

@@ -0,0 +1,17 @@
+package liquidjava.errors.errors;
+
+import spoon.reflect.declaration.CtElement;
+
+// when a constructor contains a @StateRefinement with a from state
+public class IllegalConstructorTransitionError extends LJError {
+
+    public IllegalConstructorTransitionError(CtElement element) {
+        super("Illegal Constructor Transition Error",
+                "Found constructor with 'from' state (should only have a 'to' state)", element);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString(null);
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/InvalidRefinementError.java

@@ -0,0 +1,25 @@
+package liquidjava.errors.errors;
+
+import spoon.reflect.declaration.CtElement;
+
+// when a refinement is invalid, e.g. is not a boolean expression
+public class InvalidRefinementError extends LJError {
+
+    private String refinement;
+
+    public InvalidRefinementError(String message, CtElement element, String refinement) {
+        super("Invalid Refinement", message, element);
+        this.refinement = refinement;
+    }
+
+    public String getRefinement() {
+        return refinement;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Refinement: ").append(refinement).append("\n");
+        return super.toString(sb.toString());
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/LJError.java

@@ -0,0 +1,65 @@
+package liquidjava.errors.errors;
+
+import liquidjava.errors.ErrorPosition;
+import liquidjava.utils.Utils;
+import spoon.reflect.cu.SourcePosition;
+import spoon.reflect.declaration.CtElement;
+
+// base class for all LiquidJava errors
+public abstract class LJError extends Exception {
+
+    private String title;
+    private String message;
+    private CtElement element;
+    private ErrorPosition position;
+    private SourcePosition location;
+
+    public LJError(String title, String message, CtElement element) {
+        super(message);
+        this.title = title;
+        this.message = message;
+        this.element = element;
+        try {
+            this.location = element.getPosition();
+            this.position = ErrorPosition.fromSpoonPosition(element.getPosition());
+        } catch (Exception e) {
+            this.location = null;
+            this.position = null;
+        }
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public CtElement getElement() {
+        return element;
+    }
+
+    public ErrorPosition getPosition() {
+        return position;
+    }
+
+    public SourcePosition getLocation() {
+        return location;
+    }
+
+    @Override
+    public abstract String toString();
+
+    public String toString(String extra) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(title).append(" at: \n").append(element.toString().replace("@liquidjava.specification.", "@"))
+                .append("\n\n");
+        sb.append(message).append("\n");
+        if (extra != null)
+            sb.append(extra).append("\n");
+        sb.append("Location: ").append(location != null ? Utils.stripParens(location.toString()) : "<unknown>")
+                .append("\n");
+        return sb.toString();
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/NotFoundError.java

@@ -0,0 +1,16 @@
+package liquidjava.errors.errors;
+
+import spoon.reflect.declaration.CtElement;
+
+// e.g. when a variable used in a refinement is not found
+public class NotFoundError extends LJError {
+
+    public NotFoundError(String message, CtElement element) {
+        super("Not Found Error", message, element);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString(null);
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/RefinementError.java

@@ -0,0 +1,27 @@
+package liquidjava.errors.errors;
+
+import liquidjava.rj_language.Predicate;
+import liquidjava.rj_language.opt.derivation_node.ValDerivationNode;
+import liquidjava.utils.Utils;
+import spoon.reflect.declaration.CtElement;
+
+// when a @Refinement is violated
+public class RefinementError extends LJError {
+
+    private Predicate expected;
+    private ValDerivationNode found;
+
+    public RefinementError(CtElement element, Predicate expected, ValDerivationNode found) {
+        super("Refinement Error", "Predicate refinement violation", element);
+        this.expected = expected;
+        this.found = found;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Expected: ").append(Utils.stripParens(expected.toString())).append("\n");
+        sb.append("Found: ").append(found.getValue());
+        return super.toString(sb.toString());
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/errors/errors/StateConflictError.java

@@ -0,0 +1,33 @@
+package liquidjava.errors.errors;
+
+import liquidjava.rj_language.Predicate;
+import spoon.reflect.declaration.CtElement;
+
+// when two incompatible states are found in a state set
+public class StateConflictError extends LJError {
+
+    private Predicate predicate;
+    private String className;
+
+    public StateConflictError(CtElement element, Predicate predicate, String className) {
+        super("State Conflict Error", "Found multiple disjoint states from a StateSet in refinement", element);
+        this.predicate = predicate;
+        this.className = className;
+    }
+
+    public Predicate getPredicate() {
+        return predicate;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Class: ").append(className).append("\n");
+        sb.append("Predicate: ").append(predicate.toString());
+        return super.toString(sb.toString());
+    }
+}