Fix Aggregator, TypeAssigner, LocalNameStandardizer

shared-test-resources/bugfixes/Issue739_Aggregator.java

@@ -0,0 +1,9 @@
+public class Issue739_Aggregator  {
+    public static void main(String[] args) {
+        int a = Integer.valueOf(args[0]);
+        int b = a;
+        int c = b;
+        System.out.println(a + b + c);
+
+    }
+}

sootup.callgraph/src/main/java/sootup/callgraph/AbstractCallGraphAlgorithm.java

@@ -268,7 +268,7 @@ protected Stream<MethodSignature> resolveAllStaticInitializerCallsFromSourceMeth
             classType ->
                 Stream.concat(
                     Stream.of(classType),
-                    view.getTypeHierarchy().incompleteSuperClassesOf(classType).stream()))
+                    view.getTypeHierarchy().superClassesOf(classType).stream()))
         .filter(Objects::nonNull)
         .map(classType -> view.getMethod(classType.getStaticInitializer()))
         .filter(Optional::isPresent)
@@ -291,7 +291,7 @@ protected final <T extends Method> T findMethodInHierarchy(
     if (optSc.isPresent()) {
       SootClass<?> sc = optSc.get();
 
-      List<ClassType> superClasses = view.getTypeHierarchy().incompleteSuperClassesOf(sc.getType());
+      List<ClassType> superClasses = view.getTypeHierarchy().superClassesOf(sc.getType());
       Set<ClassType> interfaces = view.getTypeHierarchy().implementedInterfacesOf(sc.getType());
       superClasses.addAll(interfaces);
 
@@ -364,7 +364,7 @@ public CallGraph addClass(@Nonnull CallGraph oldCallGraph, @Nonnull JavaClassTyp
     processWorkList(view, workList, processed, updated);
 
     // Step 2: Add edges from old methods to methods overridden in the new class
-    List<ClassType> superClasses = view.getTypeHierarchy().incompleteSuperClassesOf(classType);
+    List<ClassType> superClasses = view.getTypeHierarchy().superClassesOf(classType);
     Set<ClassType> implementedInterfaces =
         view.getTypeHierarchy().implementedInterfacesOf(classType);
     Stream<ClassType> superTypes =

sootup.callgraph/src/test/java/sootup/callgraph/CallGraphTestBase.java

@@ -7,6 +7,7 @@
 import org.junit.Test;
 import sootup.core.model.SootClass;
 import sootup.core.model.SootMethod;
+import sootup.core.model.SourceType;
 import sootup.core.signatures.MethodSignature;
 import sootup.java.bytecode.inputlocation.JavaClassPathAnalysisInputLocation;
 import sootup.java.core.JavaIdentifierFactory;
@@ -36,7 +37,7 @@ private JavaView createViewForClassPath(String classPath, boolean useSourceCodeF
         JavaProject.builder(new JavaLanguage(8))
             .addInputLocation(
                 new JavaClassPathAnalysisInputLocation(
-                    System.getProperty("java.home") + "/lib/rt.jar"));
+                    System.getProperty("java.home") + "/lib/rt.jar", SourceType.Library));
     if (useSourceCodeFrontend) {
       javaProjectBuilder.addInputLocation(new JavaSourcePathAnalysisInputLocation(classPath));
     } else {

sootup.core/src/main/java/sootup/core/jimple/common/expr/AbstractInstanceInvokeExpr.java

@@ -48,14 +48,10 @@ public Local getBase() {
   @Override
   @Nonnull
   public List<Value> getUses() {
-    List<Value> list = new ArrayList<>();
-
     List<? extends Value> args = getArgs();
-    if (args != null) {
-      list.addAll(args);
-      for (Value arg : args) {
-        list.addAll(arg.getUses());
-      }
+    List<Value> list = new ArrayList<>(args);
+    for (Value arg : args) {
+      list.addAll(arg.getUses());
     }
     list.addAll(base.getUses());
     list.add(base);

sootup.core/src/main/java/sootup/core/jimple/common/stmt/AbstractDefinitionStmt.java

@@ -61,11 +61,11 @@ public List<LValue> getDefs() {
   public final List<Value> getUses() {
     final List<Value> defsuses = getLeftOp().getUses();
     final Value rightOp = getRightOp();
-    final List<Value> uses = rightOp.getUses();
-    List<Value> list = new ArrayList<>(defsuses.size() + uses.size() + 1);
+    final List<Value> rightOpUses = rightOp.getUses();
+    List<Value> list = new ArrayList<>(defsuses.size() + rightOpUses.size() + 1);
     list.addAll(defsuses);
     list.add(rightOp);
-    list.addAll(uses);
+    list.addAll(rightOpUses);
     return list;
   }
 

sootup.core/src/main/java/sootup/core/model/Body.java

@@ -28,9 +28,12 @@
 import java.util.*;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import sootup.core.graph.*;
+import sootup.core.graph.MutableBlockStmtGraph;
+import sootup.core.graph.MutableStmtGraph;
+import sootup.core.graph.StmtGraph;
 import sootup.core.jimple.basic.*;
-import sootup.core.jimple.common.ref.*;
+import sootup.core.jimple.common.ref.JParameterRef;
+import sootup.core.jimple.common.ref.JThisRef;
 import sootup.core.jimple.common.stmt.*;
 import sootup.core.signatures.MethodSignature;
 import sootup.core.util.Copyable;
@@ -597,19 +600,17 @@
    * @param stmts The searched list of statements
    * @return A map of Locals and their using statements
    */
-  public static Map<LValue, Collection<Stmt>> collectUses(Collection<Stmt> stmts) {
-    Map<LValue, Collection<Stmt>> allUses = new HashMap<>();
+  public static Map<Value, Collection<Stmt>> collectUses(Collection<Stmt> stmts) {
+    Map<Value, Collection<Stmt>> allUses = new HashMap<>();
     for (Stmt stmt : stmts) {
       Collection<Value> uses = stmt.getUses();
       for (Value value : uses) {
-        if (value instanceof LValue) {
-          Collection<Stmt> localUses = allUses.get(value);
-          if (localUses == null) {
-            localUses = new ArrayList<>();
-          }
-          localUses.add(stmt);
-          allUses.put((LValue) value, localUses);
+        Collection<Stmt> localUses = allUses.get(value);
+        if (localUses == null) {
+          localUses = new ArrayList<>();
         }
+        localUses.add(stmt);
+        allUses.put(value, localUses);
       }
     }
     return allUses;

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

@@ -181,8 +181,7 @@ public static boolean canDispatch(
   private static List<SootClass<?>> findSuperClassesInclusive(
       View<? extends SootClass<?>> view, ClassType classType) {
     return Stream.concat(
-            Stream.of(classType),
-            view.getTypeHierarchy().incompleteSuperClassesOf(classType).stream())
+            Stream.of(classType), view.getTypeHierarchy().superClassesOf(classType).stream())
         .flatMap(t -> view.getClass(t).map(Stream::of).orElseGet(Stream::empty))
         .collect(Collectors.toList());
   }

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

@@ -154,7 +154,7 @@ default boolean isSubtype(@Nonnull Type supertype, @Nonnull Type potentialSubtyp
         return (supertypeName.equals("java.lang.Object")
                 && !potentialSubtypeName.equals("java.lang.Object"))
             || supertype.equals(superClassOf((ClassType) potentialSubtype))
-            || incompleteSuperClassesOf((ClassType) potentialSubtype).contains(supertype)
+            || superClassesOf((ClassType) potentialSubtype).contains(supertype)
             || implementedInterfacesOf((ClassType) potentialSubtype).contains(supertype);
       } else if (potentialSubtype instanceof ArrayType) {
         // Arrays are subtypes of java.lang.Object, java.io.Serializable and java.lang.Cloneable
@@ -169,27 +169,12 @@ default boolean isSubtype(@Nonnull Type supertype, @Nonnull Type potentialSubtyp
     }
   }
 
-  /**
-   * Returns all superclasses of <code>classType</code> up to <code>java.lang.Object</code>, which
-   * will be the last entry in the list. i.e. its ordered from bottom level to top level.
-   */
-  @Nonnull
-  default List<ClassType> superClassesOf(@Nonnull ClassType classType) {
-    List<ClassType> superClasses = new ArrayList<>();
-    ClassType currentSuperClass = superClassOf(classType);
-    while (currentSuperClass != null) {
-      superClasses.add(currentSuperClass);
-      currentSuperClass = superClassOf(currentSuperClass);
-    }
-    return superClasses;
-  }
-
   /**
    * Returns all superclasses of <code>classType</code> up to <code>java.lang.Object</code>, which
    * will be the last entry in the list, or till one of the superclasses is not contained in view.
    */
   @Nonnull
-  default List<ClassType> incompleteSuperClassesOf(@Nonnull ClassType classType) {
+  default List<ClassType> superClassesOf(@Nonnull ClassType classType) {
     List<ClassType> superClasses = new ArrayList<>();
     ClassType currentSuperClass = null;
     try {

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

@@ -36,7 +36,6 @@
 import javax.annotation.Nullable;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.SimpleDirectedGraph;
-import sootup.core.frontend.ResolveException;
 import sootup.core.model.SootClass;
 import sootup.core.typehierarchy.ViewTypeHierarchy.ScanResult.Edge;
 import sootup.core.typehierarchy.ViewTypeHierarchy.ScanResult.EdgeType;
@@ -67,10 +66,10 @@
   public Set<ClassType> implementersOf(@Nonnull ClassType interfaceType) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(interfaceType);
     if (vertex == null) {
-      throw new ResolveException("Could not find " + interfaceType + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + interfaceType + "' in hierarchy.");
     }
     if (vertex.type != VertexType.Interface) {
-      throw new IllegalArgumentException(interfaceType + " is not an interface.");
+      throw new IllegalArgumentException("'" + interfaceType + "' is not an interface.");
     }
     return subtypesOf(interfaceType);
   }
@@ -80,10 +79,10 @@
   public Set<ClassType> subclassesOf(@Nonnull ClassType classType) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(classType);
     if (vertex == null) {
-      throw new ResolveException("Could not find " + classType + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + classType + "' in hierarchy.");
     }
     if (vertex.type != VertexType.Class) {
-      throw new IllegalArgumentException(classType + " is not a class.");
+      throw new IllegalArgumentException("'" + classType + "' is not a class.");
     }
     return subtypesOf(classType);
   }
@@ -94,7 +93,7 @@
     ScanResult scanResult = lazyScanResult.get();
     Vertex vertex = scanResult.typeToVertex.get(type);
     if (vertex == null) {
-      throw new ResolveException("Could not find " + type + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + type + "' in hierarchy.");
     }
 
     Set<ClassType> subclasses = new HashSet<>();
@@ -110,7 +109,7 @@
     ScanResult scanResult = lazyScanResult.get();
     Vertex vertex = scanResult.typeToVertex.get(type);
     if (vertex == null) {
-      throw new ResolveException("Could not find " + type + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + type + "' in hierarchy.");
     }
 
     Set<ClassType> subclasses = new HashSet<>();
@@ -141,7 +140,7 @@
   }
 
   @Nonnull
-  public List<Vertex> superClassesOf(@Nonnull Vertex classVertex, boolean includingSelf) {
+  protected List<Vertex> superClassesOf(@Nonnull Vertex classVertex, boolean includingSelf) {
     ScanResult scanResult = lazyScanResult.get();
     Graph<Vertex, Edge> graph = scanResult.graph;
 
@@ -167,21 +166,21 @@
     return superClasses;
   }
 
-  public Stream<Vertex> directlyImplementedInterfacesOf(@Nonnull Vertex classVertex) {
+  protected Stream<Vertex> directlyImplementedInterfacesOf(@Nonnull Vertex classVertex) {
     Graph<Vertex, Edge> graph = lazyScanResult.get().graph;
     return graph.outgoingEdgesOf(classVertex).stream()
         .filter(edge -> edge.type == EdgeType.ClassDirectlyImplements)
         .map(graph::getEdgeTarget);
   }
 
-  public Stream<Vertex> directlyExtendedInterfacesOf(@Nonnull Vertex interfaceVertex) {
+  protected Stream<Vertex> directlyExtendedInterfacesOf(@Nonnull Vertex interfaceVertex) {
     Graph<Vertex, Edge> graph = lazyScanResult.get().graph;
     return graph.outgoingEdgesOf(interfaceVertex).stream()
         .filter(edge -> edge.type == EdgeType.InterfaceDirectlyExtends)
         .map(graph::getEdgeTarget);
   }
 
-  public Stream<Vertex> directSuperClassOf(@Nonnull Vertex classVertex) {
+  protected Stream<Vertex> directSuperClassOf(@Nonnull Vertex classVertex) {
     Graph<Vertex, Edge> graph = lazyScanResult.get().graph;
     return graph.outgoingEdgesOf(classVertex).stream()
         .filter(edge -> edge.type == EdgeType.ClassDirectlyExtends)
@@ -191,7 +190,7 @@
   public Set<ClassType> directlyImplementedInterfacesOf(@Nonnull ClassType classType) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(classType);
     if (vertex == null) {
-      throw new IllegalStateException("Could not find '" + classType + "' in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + classType + "' in hierarchy.");
     }
     if (vertex.type != VertexType.Class) {
       throw new IllegalArgumentException(classType + " is not a class.");
@@ -205,7 +204,7 @@
   public Set<ClassType> directlyExtendedInterfacesOf(@Nonnull ClassType interfaceType) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(interfaceType);
     if (vertex == null) {
-      throw new IllegalStateException("Could not find " + interfaceType + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find " + interfaceType + " in hierarchy.");
     }
     if (vertex.type != VertexType.Interface) {
       throw new IllegalArgumentException(interfaceType + " is not a class.");
@@ -229,7 +228,7 @@
   public ClassType directSuperClassOf(@Nonnull ClassType classType) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(classType);
     if (vertex == null) {
-      throw new IllegalStateException("Could not find " + classType + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find " + classType + " in hierarchy.");
     }
     Graph<Vertex, Edge> graph = lazyScanResult.get().graph;
     List<Vertex> list =
@@ -242,7 +241,7 @@
       /* is java.lang.Object */
       return null;
     } else if (list.size() > 1) {
-      throw new RuntimeException(classType + "cannot have multiple superclasses");
+      throw new IllegalArgumentException(classType + "cannot have multiple superclasses");
     } else {
       return list.get(0).javaClassType;
     }
@@ -255,7 +254,8 @@
     Vertex vertex = scanResult.typeToVertex.get(type);
 
     if (vertex == null) {
-      throw new IllegalStateException("Could not find " + type + " in hierarchy for view " + view);
+      throw new IllegalArgumentException(
+          "Could not find " + type + " in hierarchy for view " + view);
     }
 
     switch (vertex.type) {
@@ -299,21 +299,25 @@
   @Nullable
   @Override
   public ClassType superClassOf(@Nonnull ClassType classType) {
-    return sootClassFor(classType).getSuperclass().orElse(null);
+    final Optional<? extends SootClass<?>> classOpt = view.getClass(classType);
+    if (!classOpt.isPresent()) {
+      throw new IllegalArgumentException("Could not find '" + classType + "' in the view.");
+    }
+    return classOpt.get().getSuperclass().orElse(null);
   }
 
   public boolean isInterface(@Nonnull ClassType type) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(type);
     if (vertex == null) {
-      throw new RuntimeException("Could not find " + type + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + type + "' in hierarchy.");
     }
     return vertex.type == VertexType.Interface;
   }
 
   public boolean isClass(@Nonnull ClassType type) {
     Vertex vertex = lazyScanResult.get().typeToVertex.get(type);
     if (vertex == null) {
-      throw new RuntimeException("Could not find " + type + " in hierarchy.");
+      throw new IllegalArgumentException("Could not find '" + type + "' in hierarchy.");
     }
     return vertex.type == VertexType.Class;
   }
@@ -416,19 +420,14 @@
     return interfaceVertex;
   }
 
-  @Nonnull
-  private SootClass<?> sootClassFor(@Nonnull ClassType classType) {
-    return view.getClassOrThrow(classType);
-  }
-
   @Override
   public void addType(@Nonnull SootClass<?> sootClass) {
     ScanResult scanResult = lazyScanResult.get();
     addSootClassToGraph(sootClass, scanResult.typeToVertex, scanResult.graph);
   }
 
   /** Holds a vertex for each {@link ClassType} encountered during the scan. */
-  static class ScanResult {
+  protected static class ScanResult {
 
     enum VertexType {
       Class,
@@ -439,7 +438,7 @@
      * @see #javaClassType
      * @see #type
      */
-    static class Vertex {
+    protected static class Vertex {
       @Nonnull final ClassType javaClassType;
       @Nonnull final VertexType type;
 
@@ -449,7 +448,7 @@
       }
     }
 
-    enum EdgeType {
+    protected enum EdgeType {
       /** Edge to an interface vertex this interface extends directly, non-transitively. */
       InterfaceDirectlyExtends,
       /** Edge to an interface extending this interface directly, non-transitively. */
@@ -459,7 +458,7 @@
     }
 
     /** @see #type */
-    static class Edge {
+    protected static class Edge {
       @Nonnull final EdgeType type;
 
       Edge(@Nonnull EdgeType type) {