// The following shows how to convert a Project with Java 8 Lambda expression to OPAL's 3-address code.
// (If you just need the "resolved bytecode" representation, nothing special needs to be done.)

// The following code snippet can be pasted to the console and readily be executed when you
// 1) start `sbt`
// 2) change the project `project OPAL-DeveloperTools`
// 3) start the `console`

import java.io.File
import java.nio.file.Files
import java.nio.file.FileSystems
import org.opalj.br.analyses._
import org.opalj.tac._

val targetFolder = Files.createTempDirectory("OPAL")
println("target folder: "+targetFolder)

// 1. Load the project
val p = Project(new File("OPAL/bi/target/scala-2.12/test-classes/lambdas-1.8-g-parameters-genericsignature.jar"))

// 2. get the Key to make it possible to get the 3-address code
val tacKey = p.get(DefaultTACAIKey)

for {cf <- p.allProjectClassFiles /*.par does not work for Scala 2.12.4 console! */}{
    // 3. convert all methods with a body to the 3-address code
    val classBody = 
        for {
            m <- cf.methods 
            if m.body.isDefined
        } yield {
            println("processing: "+m.toJava)
            val c @ TACode(param,stmts,cfg,ehs,lnt) = tacKey(m) // Here, we don't do anything special with the params, stmts,...
            m.toJava(ToTxt(c).mkString("\n\t","\n\t","\n"))
        }
    // 4. write the 3-address code to the disc    
    val targetFileName = org.opalj.io.sanitizeFileName(cf.fqn+".class.tac")
    val targetFile = targetFolder.resolve(FileSystems.getDefault.getPath(targetFileName))
    println("creating: "+targetFile)
    Files.createDirectories(targetFile.getParent)
    Files.write(targetFile,classBody.mkString("\n\n").getBytes)
}


/*  EXAMPLE
    Let's assume the original Java Source code would be:

    public ArrayList<Object> someBiConsumer() {
	    final ArrayList<Object> al = new ArrayList<>();
	    BiConsumer<HashMap<String, String>, HashMap<String, String>> bi = (x, y) -> {
	        al.addAll(x.keySet());
	        al.addAll(y.values());
        };
        al.add(bi);
        return al;
    }

    For the above method the Java compiler would generate the following method for the code
    of the lambda expression (the name "lambda$29" is chosen by the compiler):

    private static void lambda$29(java.util.ArrayList,java.util.HashMap,java.util.HashMap){ 
	      /* PARAMETERS:
	         param1: useSites={1,3} (origin=-2)
	         param2: useSites={0} (origin=-3)
	         param3: useSites={2} (origin=-4)
	      */
	    0: lv0 = {param2}/*java.util.HashMap*/.keySet()
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 0 →
	    1: /*expression value is ignored:*/{param1}/*java.util.ArrayList*/.addAll({lv0})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 1 →
	    2: lv2 = {param3}/*java.util.HashMap*/.values()
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 2 →
	    3: /*expression value is ignored:*/{param1}/*java.util.ArrayList*/.addAll({lv2})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 3 →
	    4: return
    }

    In this case, the rewritten code of someBiConsumer - using OPAL's 3 address code - would be:

    public java.util.ArrayList someBiConsumer(){ /* PARAMETERS: param0: useSites={} (origin=-1) */
	    0: lv0 = new ArrayList
	    1: {lv0}/*(non-virtual) java.util.ArrayList*/.<init>()
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 1 →
	    2: lv2 = Lambda$d5:6e.$newInstance({lv0})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 2 →
	    3: /*expression value is ignored:*/{lv0}/*java.util.ArrayList*/.add({lv2})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 3 →
	    4: return {lv0}
    }

    Additionally, a new class to would have been created:
    Lambda$d5:6e{ 
    public static Lambda$d5:6e $newInstance(java.util.ArrayList){ 
	      /* PARAMETERS:
	         param1: useSites={1} (origin=-2)
	      */
	    0: lv0 = new Lambda$d5:6e
	    1: {lv0}/*(non-virtual) Lambda$d5:6e*/.<init>({param1})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 1 →
	    2: return {lv0}
    }

    public void <init>(java.util.ArrayList){ 
	      /* PARAMETERS:
	         param0: useSites={0,1} (origin=-1)
	         param1: useSites={1} (origin=-2)
	      */
	    0: {param0}/*(non-virtual) java.lang.Object*/.<init>()
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 0 →
	    1: {param0}/*Lambda$d5:6e*/.staticParameter0 = {param1}
	    2: return
    }

    public void accept(java.lang.Object,java.lang.Object){ 
	      /* PARAMETERS:
	         param0: useSites={2} (origin=-1)
	         param1: useSites={0,2} (origin=-2)
	         param2: useSites={1,2} (origin=-3)
	      */
	    0: (java.util.HashMap) {param1}
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 0 →
	    1: (java.util.HashMap) {param2}
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 1 →
	    2: {param0}/*Lambda$d5:6e*/.accept({param1}, {param2})
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 2 →
	    3: return
    }

    public void accept(java.util.HashMap,java.util.HashMap){ 
	      /* PARAMETERS:
	         param0: useSites={0} (origin=-1)
	         param1: useSites={1} (origin=-2)
	         param2: useSites={1} (origin=-3)
	      */
	    0: lv0 = {param0}/*Lambda$d5:6e*/.staticParameter0
	    1: lambdas.Lambdas.lambda$29({lv0}, {param1}, {param2}) // <= CALL THE LAMBDA METHOD
	      // ⚡️ <uncaught exception ⇒ abnormal return>
	
	      // 1 →
	    2: return
    }

    }// END OF CLASS
*/