extensibility improvements

Author: StevenArzt

src/main/java/soot/LambdaMetaFactory.java

@@ -165,15 +165,15 @@ public synchronized SootMethodRef makeLambdaHelper(List<? extends Value> bootstr
     final boolean readableClassnames = true;
     if (readableClassnames) {
       // class names cannot contain <>
-      String implMethodName = implMethod.getMethodRef().name();
+      String implMethodName = implMethod.getMethodRef().getName();
       String dummyName = "<init>".equals(implMethodName) ? "init" : implMethodName;
       // XXX: $ causes confusion in inner class inference; remove for now
       dummyName = dummyName.replaceAll("\\$", "_");
       className = enclosingClassnamePrefix + dummyName + "__" + uniqSupply();
     } else {
       className = "soot.dummy.lambda" + uniqSupply();
     }
-    SootClass tclass = new SootClass(className);
+    SootClass tclass = Scene.v().makeSootClass(className);
     tclass.setModifiers(Modifier.PUBLIC | Modifier.FINAL);
     tclass.setSuperclass(Scene.v().getObjectType().getSootClass());
     tclass.addInterface(functionalInterfaceToImplement);
@@ -189,17 +189,17 @@ public synchronized SootMethodRef makeLambdaHelper(List<? extends Value> bootstr
     // It contains fields for all the captures in the lambda
     List<SootField> capFields = new ArrayList<SootField>(capTypes.size());
     for (int i = 0; i < capTypes.size(); i++) {
-      SootField f = new SootField("cap" + i, capTypes.get(i), 0);
+      SootField f = Scene.v().makeSootField("cap" + i, capTypes.get(i), 0);
       capFields.add(f);
       tclass.addField(f);
     }
 
     // if the implMethod is a new private static in the enclosing class, make it public access so
     // it can be invoked from the thunk class
     if (MethodHandle.Kind.REF_INVOKE_STATIC.getValue() == implMethod.getKind()) {
-      if (implMethod.getMethodRef().declaringClass().getName().equals(enclosingClassname)) {
-        SootMethod method
-            = implMethod.getMethodRef().declaringClass().getMethod(implMethod.getMethodRef().getSubSignature());
+      SootClass declClass = implMethod.getMethodRef().getDeclaringClass();
+      if (declClass.getName().equals(enclosingClassname)) {
+        SootMethod method = declClass.getMethod(implMethod.getMethodRef().getSubSignature());
         int modifiers = method.getModifiers() & ~Modifier.PRIVATE;
         modifiers = modifiers | Modifier.PUBLIC;
         method.setModifiers(modifiers);
@@ -209,13 +209,13 @@ public synchronized SootMethodRef makeLambdaHelper(List<? extends Value> bootstr
     MethodSource ms = new ThunkMethodSource(capFields, samMethodType, implMethod, instantiatedMethodType);
 
     // Bootstrap method creates a new instance of this class
-    SootMethod tboot = new SootMethod("bootstrap$", capTypes, functionalInterfaceToImplement.getType(),
+    SootMethod tboot = Scene.v().makeSootMethod("bootstrap$", capTypes, functionalInterfaceToImplement.getType(),
         Modifier.PUBLIC | Modifier.STATIC);
     tclass.addMethod(tboot);
     tboot.setSource(ms);
 
     // Constructor just copies the captures
-    SootMethod tctor = new SootMethod("<init>", capTypes, VoidType.v(), Modifier.PUBLIC);
+    SootMethod tctor = Scene.v().makeSootMethod("<init>", capTypes, VoidType.v(), Modifier.PUBLIC);
     tclass.addMethod(tctor);
     tctor.setSource(ms);
 
@@ -251,7 +251,8 @@ public synchronized SootMethodRef makeLambdaHelper(List<? extends Value> bootstr
   private void addDispatch(String name, SootClass tclass, MethodType implMethodType, MethodType instantiatedMethodType,
       List<SootField> capFields, MethodHandle implMethod) {
     ThunkMethodSource ms = new ThunkMethodSource(capFields, implMethodType, implMethod, instantiatedMethodType);
-    SootMethod m = new SootMethod(name, implMethodType.getParameterTypes(), implMethodType.getReturnType(), Modifier.PUBLIC);
+    SootMethod m = Scene.v().makeSootMethod(name, implMethodType.getParameterTypes(), implMethodType.getReturnType(),
+        Modifier.PUBLIC);
     tclass.addMethod(m);
     m.setSource(ms);
   }
@@ -294,10 +295,6 @@ public Wrapper() {
 
     }
 
-    private boolean isWrapper(Type t) {
-      return wrapperTypes.containsKey(t);
-    }
-
   }
 
   private class ThunkMethodSource implements MethodSource {
@@ -463,7 +460,7 @@ private void getInvokeBody(SootClass tclass, JimpleBody jb) {
       }
       Iterator<Local> iplItr = instParamLocals.iterator();
       if (capFields.size() == 0 && iplItr.hasNext() && needsReceiver) {
-        RefType receiverType = implMethod.getMethodRef().declaringClass().getType();
+        RefType receiverType = implMethod.getMethodRef().getDeclaringClass().getType();
         Local l = adapt(iplItr.next(), receiverType, jb, us, lc);
         args.add(l);
       }
@@ -476,7 +473,7 @@ private void getInvokeBody(SootClass tclass, JimpleBody jb) {
       while (iplItr.hasNext()) {
         Local pl = iplItr.next();
 
-        Type to = implMethod.getMethodRef().parameterType(j);
+        Type to = implMethod.getMethodRef().getParameterType(j);
 
         Local l = adapt(pl, to, jb, us, lc);
         args.add(l);
@@ -648,7 +645,7 @@ private Local wideningPrimitiveConversion(Local fromLocal, Type to, JimpleBody j
     private void invokeImplMethod(JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc, List<Local> args) {
       Value value = _invokeImplMethod(jb, us, lc, args);
 
-      if (value instanceof InvokeExpr && soot.VoidType.v().equals(implMethod.getMethodRef().returnType())) {
+      if (value instanceof InvokeExpr && soot.VoidType.v().equals(implMethod.getMethodRef().getReturnType())) {
         // implementation method is void
         us.add(Jimple.v().newInvokeStmt(value));
         us.add(Jimple.v().newReturnVoidStmt());
@@ -702,7 +699,7 @@ private Value _invokeImplMethod(JimpleBody jb, PatchingChain<Unit> us, LocalGene
             return Jimple.v().newVirtualInvokeExpr(args.get(0), methodRef, rest(args));
           }
         case REF_INVOKE_CONSTRUCTOR:
-          RefType type = methodRef.declaringClass().getType();
+          RefType type = methodRef.getDeclaringClass().getType();
           NewExpr newRef = Jimple.v().newNewExpr(type);
           Local newLocal = lc.generateLocal(type);
           us.add(Jimple.v().newAssignStmt(newLocal, newRef));

src/main/java/soot/asm/AsmClassSource.java

@@ -37,9 +37,9 @@
  * 
  * @author Aaloan Miftah
  */
-class AsmClassSource extends ClassSource {
+public class AsmClassSource extends ClassSource {
 
-  private FoundFile foundFile;
+  protected FoundFile foundFile;
 
   /**
    * Constructs a new ASM class source.
@@ -49,7 +49,7 @@ class AsmClassSource extends ClassSource {
    * @param data
    *          stream containing data for class.
    */
-  AsmClassSource(String cls, FoundFile foundFile) {
+  protected AsmClassSource(String cls, FoundFile foundFile) {
     super(cls);
     if (foundFile == null) {
       throw new IllegalStateException("Error: The FoundFile must not be null.");

src/main/java/soot/asm/SootClassBuilder.java

@@ -59,19 +59,19 @@
  * @author Aaloan Miftah
  */
 @SuppressWarnings({ "unchecked", "rawtypes" })
-class SootClassBuilder extends ClassVisitor {
+public class SootClassBuilder extends ClassVisitor {
 
-  private TagBuilder tb;
-  private final SootClass klass;
-  final Set<soot.Type> deps;
+  protected TagBuilder tb;
+  protected final SootClass klass;
+  protected final Set<soot.Type> deps;
 
   /**
    * Constructs a new Soot class builder.
    *
    * @param klass
    *          Soot class to build.
    */
-  SootClassBuilder(SootClass klass) {
+  protected SootClassBuilder(SootClass klass) {
     super(Opcodes.ASM5);
     this.klass = klass;
     this.deps = new HashSet();

src/main/java/soot/javaToJimple/IInitialResolver.java

@@ -39,8 +39,13 @@ public class Dependencies {
     public final Set<Type> typesToHierarchy, typesToSignature;
 
     public Dependencies() {
-      typesToHierarchy = new HashSet<Type>();
-      typesToSignature = new HashSet<Type>();
+      typesToHierarchy = new HashSet<>();
+      typesToSignature = new HashSet<>();
+    }
+
+    public Dependencies(Set<Type> typesToHierarchy, Set<Type> typesToSignature) {
+      this.typesToHierarchy = typesToHierarchy == null ? new HashSet<>() : typesToHierarchy;
+      this.typesToSignature = typesToSignature == null ? new HashSet<>() : typesToSignature;
     }
   }