Clarify error messages in FieldRefValidator

src/main/java/soot/jimple/validation/FieldRefValidator.java

@@ -27,8 +27,16 @@
 import soot.Body;
 import soot.ResolutionFailedException;
 import soot.SootField;
+import soot.SootFieldRef;
 import soot.SootMethod;
 import soot.Unit;
+import soot.baf.BafBody;
+import soot.baf.FieldArgInst;
+import soot.baf.FieldGetInst;
+import soot.baf.FieldPutInst;
+import soot.baf.Inst;
+import soot.baf.StaticGetInst;
+import soot.baf.StaticPutInst;
 import soot.jimple.FieldRef;
 import soot.jimple.InstanceFieldRef;
 import soot.jimple.StaticFieldRef;
@@ -37,6 +45,10 @@
 import soot.validation.UnitValidationException;
 import soot.validation.ValidationException;
 
+/**
+ * @author Alexandre Bartel
+ * @author Timothy Hoffman
+ */
 public enum FieldRefValidator implements BodyValidator {
   INSTANCE;
 
@@ -49,46 +61,100 @@ public static FieldRefValidator v() {
    */
   @Override
   public void validate(Body body, List<ValidationException> exceptions) {
-    SootMethod method = body.getMethod();
+    final SootMethod method = body.getMethod();
     if (method.isAbstract()) {
       return;
     }
 
+    final ValidatorImpl<?> vi;
+    if (body instanceof BafBody) {
+      vi = new ValidatorImpl<Inst>(body, exceptions) {
+        @Override
+        public void check(Unit unit) {
+          Inst inst = (Inst) unit;
+          if (inst.containsFieldRef()) {
+            assert (inst instanceof FieldArgInst); // interface that defines getFieldRef()
+            check(unit, ((FieldArgInst) unit).getFieldRef(), inst);
+          }
+        }
+
+        @Override
+        protected boolean isValidStaticRef(Inst refToCheck) {
+          return (refToCheck instanceof StaticPutInst) || (refToCheck instanceof StaticGetInst);
+        }
+
+        @Override
+        protected boolean isValidNonStaticRef(Inst refToCheck) {
+          return (refToCheck instanceof FieldPutInst) || (refToCheck instanceof FieldGetInst);
+        }
+      };
+    } else {
+      vi = new ValidatorImpl<FieldRef>(body, exceptions) {
+        @Override
+        public void check(Unit unit) {
+          Stmt stmt = (Stmt) unit;
+          if (stmt.containsFieldRef()) {
+            FieldRef ref = stmt.getFieldRef();
+            check(unit, ref.getFieldRef(), ref);
+          }
+        }
+
+        @Override
+        protected boolean isValidStaticRef(FieldRef refToCheck) {
+          return (refToCheck instanceof StaticFieldRef);
+        }
+
+        @Override
+        protected boolean isValidNonStaticRef(FieldRef refToCheck) {
+          return (refToCheck instanceof InstanceFieldRef);
+        }
+      };
+    }
+
+    // Run the validator on all units in the body
     for (Unit unit : body.getUnits().getNonPatchingChain()) {
-      Stmt s = (Stmt) unit;
-      if (!s.containsFieldRef()) {
-        continue;
+      vi.check(unit);
+    }
+  }
+
+  private static abstract class ValidatorImpl<T> {
+
+    private final Body body;
+    private final List<ValidationException> exs;
+
+    public ValidatorImpl(Body body, List<ValidationException> exceptions) {
+      this.body = body;
+      this.exs = exceptions;
+    }
+
+    public abstract void check(Unit unit);
+
+    protected abstract boolean isValidStaticRef(T refToCheck);
+
+    protected abstract boolean isValidNonStaticRef(T refToCheck);
+
+    protected final void check(Unit unit, SootFieldRef sRef, T refToCheck) {
+      SootField field;
+      try {
+        field = sRef.resolve();
+      } catch (ResolutionFailedException e) {
+        exs.add(new UnitValidationException(unit, body, "Unable to resolve SootFieldRef " + sRef + ": " + e.getMessage()));
+        field = null;
       }
-      FieldRef fr = s.getFieldRef();
-
-      if (fr instanceof StaticFieldRef) {
-        StaticFieldRef v = (StaticFieldRef) fr;
-        try {
-          SootField field = v.getField();
-          if (field == null) {
-            exceptions.add(new UnitValidationException(unit, body, "Resolved field is null: " + fr.toString()));
-          } else if (!field.isStatic() && !field.isPhantom()) {
-            exceptions
-                .add(new UnitValidationException(unit, body, "Trying to get a static field which is non-static: " + v));
+      if (field == null) {
+        exs.add(new UnitValidationException(unit, body, "SootFieldRef resolved to null: " + sRef));
+      } else if (!field.isPhantom()) {
+        if (field.isStatic()) {
+          if (!isValidStaticRef(refToCheck)) {
+            String s = refToCheck.getClass().getName();
+            exs.add(new UnitValidationException(unit, body, "Used " + s + " for static field " + sRef));
           }
-        } catch (ResolutionFailedException e) {
-          exceptions.add(new UnitValidationException(unit, body, "Trying to get a static field which is non-static: " + v));
-        }
-      } else if (fr instanceof InstanceFieldRef) {
-        InstanceFieldRef v = (InstanceFieldRef) fr;
-
-        try {
-          SootField field = v.getField();
-          if (field == null) {
-            exceptions.add(new UnitValidationException(unit, body, "Resolved field is null: " + fr.toString()));
-          } else if (field.isStatic() && !field.isPhantom()) {
-            exceptions.add(new UnitValidationException(unit, body, "Trying to get an instance field which is static: " + v));
+        } else {
+          if (!isValidNonStaticRef(refToCheck)) {
+            String s = refToCheck.getClass().getName();
+            exs.add(new UnitValidationException(unit, body, "Used " + s + " for non-static field " + sRef));
           }
-        } catch (ResolutionFailedException e) {
-          exceptions.add(new UnitValidationException(unit, body, "Trying to get an instance field which is static: " + v));
         }
-      } else {
-        throw new AssertionError("unknown field ref: " + fr);
       }
     }
   }