InvokeArgumentValidator changes

sootup.core/src/main/java/sootup/core/typehierarchy/TypeHierarchy.java

@@ -162,10 +162,10 @@
             || supertypeName.equals("java.io.Serializable")
             || supertypeName.equals("java.lang.Cloneable");
       } else {
-        throw new AssertionError("potentialSubtype has unexpected type");
+        throw new IllegalStateException("potentialSubtype has unexpected type");
       }
     } else {
-      throw new AssertionError("supertype has unexpected type");
+      throw new IllegalStateException("supertype has unexpected type");
     }
   }
 
@@ -200,6 +200,6 @@
   Set<ClassType> directlyExtendedInterfacesOf(@Nonnull ClassType type);
 
   // checks if a Type is contained int the TypeHierarchy - should return the equivalent to
-  // View.getClass(...).isPresent()
+  // View.getClass(...).isPresent() - the opposite is not true!
   boolean contains(ClassType type);
 }

sootup.core/src/main/java/sootup/core/types/PrimitiveType.java

@@ -22,6 +22,10 @@
  * #L%
  */
 
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.util.Map;
+import java.util.Set;
 import javax.annotation.Nonnull;
 import sootup.core.jimple.visitor.TypeVisitor;
 
@@ -50,12 +54,54 @@
     return name;
   }
 
+  @Nonnull
+  public abstract String getBoxedName();
+
   @Override
   @Nonnull
   public String toString() {
     return name;
   }
 
+  private static final Map<Class<? extends PrimitiveType>, Set<Class<? extends PrimitiveType>>>
+      implicitConversionMap =
+          ImmutableMap
+              .<Class<? extends PrimitiveType>, Set<Class<? extends PrimitiveType>>>builder()
+              .put(
+                  ByteType.class,
+                  ImmutableSet.of(
+                      ShortType.class,
+                      IntType.class,
+                      LongType.class,
+                      FloatType.class,
+                      DoubleType.class))
+              .put(
+                  ShortType.class,
+                  ImmutableSet.of(IntType.class, LongType.class, FloatType.class, DoubleType.class))
+              .put(
+                  CharType.class,
+                  ImmutableSet.of(IntType.class, LongType.class, FloatType.class, DoubleType.class))
+              .put(
+                  IntType.class, ImmutableSet.of(LongType.class, FloatType.class, DoubleType.class))
+              .put(LongType.class, ImmutableSet.of(FloatType.class, DoubleType.class))
+              .put(FloatType.class, ImmutableSet.of(DoubleType.class))
+              .build();
+
+  /**
+   * @param fromType e.g. the method argument
+   * @param toType e.g. the method parameter
+   * @return true if type conversion is possible
+   */
+  public static boolean isImplicitlyConvertibleTo(
+      @Nonnull PrimitiveType fromType, @Nonnull PrimitiveType toType) {
+    Class<? extends PrimitiveType> fromTypeClass = fromType.getClass();
+    Class<? extends PrimitiveType> toTypeClass = toType.getClass();
+    return implicitConversionMap.containsKey(fromTypeClass)
+            && implicitConversionMap.get(fromTypeClass).contains(toTypeClass)
+        || IntType.class.isAssignableFrom(fromTypeClass)
+            && implicitConversionMap.get(IntType.class).contains(toTypeClass);
+  }
+
   @Nonnull
   public static ByteType getByte() {
     return ByteType.getInstance();
@@ -107,6 +153,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Byte";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseByteType();
@@ -124,6 +176,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Short";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseShortType();
@@ -145,6 +203,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Integer";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseIntType();
@@ -162,6 +226,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Double";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseDoubleType();
@@ -179,6 +249,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Long";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseLongType();
@@ -196,6 +272,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Float";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseFloatType();
@@ -213,6 +295,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Character";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseCharType();
@@ -234,6 +322,12 @@
       return INSTANCE;
     }
 
+    @Nonnull
+    @Override
+    public String getBoxedName() {
+      return "Boolean";
+    }
+
     @Override
     public void accept(@Nonnull TypeVisitor v) {
       v.caseBooleanType();

sootup.core/src/main/java/sootup/core/validation/InvokeArgumentValidator.java

@@ -22,8 +22,17 @@
  * #L%
  */
 
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import sootup.core.IdentifierFactory;
+import sootup.core.jimple.basic.Immediate;
+import sootup.core.jimple.common.expr.AbstractInvokeExpr;
+import sootup.core.jimple.common.stmt.Stmt;
 import sootup.core.model.Body;
+import sootup.core.signatures.MethodSignature;
+import sootup.core.typehierarchy.TypeHierarchy;
+import sootup.core.types.*;
 import sootup.core.views.View;
 
 /**
@@ -33,15 +42,99 @@
  * @author Steven Arzt
  */
 public class InvokeArgumentValidator implements BodyValidator {
-
   @Override
   public List<ValidationException> validate(Body body, View view) {
-    // TODO: check copied code from old soot
-    /*
-     * for (Unit u : body.getUnits()) { Stmt s = (Stmt) u; if (s.containsInvokeExpr()) { InvokeExpr iinvExpr =
-     * s.getInvokeExpr(); SootMethod callee = iinvExpr.getMethod(); if (callee != null && iinvExpr.getArgCount() !=
-     * callee.getParameterCount()) { exceptions.add(new ValidationException(s, "Invalid number of arguments")); } } }
-     */
-    return null;
+    List<ValidationException> validationException = new ArrayList<>();
+
+    TypeHierarchy typeHierarchy = view.getTypeHierarchy();
+    IdentifierFactory identifierFactory = view.getIdentifierFactory();
+
+    for (Stmt stmt : body.getStmts()) {
+      if (!stmt.containsInvokeExpr()) {
+        continue;
+      }
+
+      AbstractInvokeExpr invExpr = stmt.getInvokeExpr();
+      MethodSignature callee = invExpr.getMethodSignature();
+      List<Immediate> args = invExpr.getArgs();
+      List<Type> parameterTypes = callee.getParameterTypes();
+
+      if (invExpr.getArgCount() != parameterTypes.size()) {
+        validationException.add(
+            new ValidationException(
+                stmt,
+                "Argument count '"
+                    + invExpr.getArgCount()
+                    + "' does not match the number of expected parameters '"
+                    + parameterTypes.size()
+                    + "'."));
+        continue;
+      }
+
+      // check argument type
+      ReferenceType argClassType;
+      Iterator<Type> iterParameters = parameterTypes.iterator();
+      for (Immediate arg : args) {
+        Type argType = arg.getType();
+        Type parameterType = iterParameters.next();
+
+        // handle implicit conversion cases. e.g., `int` is used as an argument of a `double`
+        // parameter
+        if (argType instanceof PrimitiveType) {
+          if (parameterType instanceof PrimitiveType) {
+
+            if (argType == parameterType) {
+              continue;
+            }
+
+            if (!PrimitiveType.isImplicitlyConvertibleTo(
+                (PrimitiveType) argType, (PrimitiveType) parameterType)) {
+              validationException.add(
+                  new ValidationException(
+                      stmt,
+                      String.format(
+                          "Invalid argument type - type conversion is not applicable to '%s' and the provided '%s'.",
+                          parameterType, argType)));
+            }
+            continue;
+          }
+
+          // prepare autoboxing test
+          argClassType = identifierFactory.getBoxedType(((PrimitiveType) argType));
+
+        } else {
+          argClassType = (ReferenceType) argType;
+        }
+
+        // non-primitive type cases, primitive+autoboxing
+        if (argClassType == parameterType) {
+          continue;
+        }
+
+        // check if the (base-) type is contained in the typehierarchy - else it throws exceptions
+        // TODO: incorporate into api after #874 is done
+        if (parameterType instanceof ClassType
+            && !typeHierarchy.contains((ClassType) parameterType)) {
+          continue;
+        }
+
+        if (parameterType instanceof ArrayType) {
+          Type baseType = ((ArrayType) parameterType).getBaseType();
+          if (baseType instanceof ClassType && !typeHierarchy.contains((ClassType) baseType)) {
+            continue;
+          }
+        }
+
+        if (!typeHierarchy.isSubtype(parameterType, argClassType)) {
+          validationException.add(
+              new ValidationException(
+                  stmt,
+                  String.format(
+                      "Invalid argument type. Required '%s' but provided was '%s'.",
+                      parameterType, argType)));
+        }
+      }
+    }
+    return validationException;
   }
 }

sootup.java.bytecode/src/main/java/sootup/java/bytecode/inputlocation/ArchiveBasedAnalysisInputLocation.java

@@ -99,8 +99,14 @@
     try {
       FileSystem fs = fileSystemCache.get(path);
       final Path archiveRoot = fs.getPath("/");
-      return getClassSourceInternal(
-          (JavaClassType) type, archiveRoot, new AsmJavaClassProvider(view));
+      JavaClassType javaClassType = null;
+
+      // FIXME: This is a temporary workaround to prevent a casting exception when passing an
+      // anonymous
+      // ClassType object e.g. from a JimpleAnalysisInputLocation
+      if (type instanceof JavaClassType) javaClassType = (JavaClassType) type;
+      else javaClassType = new JavaClassType(type.getClassName(), type.getPackageName());
+      return getClassSourceInternal(javaClassType, archiveRoot, new AsmJavaClassProvider(view));
     } catch (ExecutionException e) {
       throw new RuntimeException("Failed to retrieve file system from cache for " + path, e);
     }

sootup.java.core/src/main/java/sootup/java/core/JavaIdentifierFactory.java

@@ -236,10 +236,7 @@
   @Override
   @Nonnull
   public JavaClassType getBoxedType(@Nonnull PrimitiveType primitiveType) {
-    String name = primitiveType.getName();
-    StringBuilder boxedname = new StringBuilder(name);
-    boxedname.setCharAt(0, Character.toUpperCase(boxedname.charAt(0)));
-    return getClassType(boxedname.toString(), "java.lang");
+    return getClassType(primitiveType.getBoxedName(), "java.lang");
   }
 
   @Override