javap | javap pastebin for viewing the bytecode of small pieces

The LocalVariableTable describes the scope of the variable - the portion of the bytecode in which the variable is accessible.

In a class, the parameter of a non-abstract method has a scope - it's accessible in the whole of the body of the method. Even when the method is "empty", the bytecode still consists of a single return command.

(There's also the implicit this variable in an instance method, which is also accessible in the whole body of the method).

In an abstract interface method (i.e. not a default or static method), there's no bytecode in which that variable is accessible, because the method has no body, and thus no bytecode. Hence, there's no need for the LocalVariableTable.

An abstract method (whether in an interface or a class) is just a specification which says "implementors need to provide this". There is no implementation, no body etc.

Make sure in Properties > Project: Java Build Path tab Source the correct output folder(s) are configured.

Check your class path for any "leftovers" from the old system. It looks like you are not inspecting the correct files. Maybe you have the FileDetailsServlet in a wrong version as depencency somewhere, or just in a "standalone" JAR- or WAR-file.

It is also important that Eclipse settings alone will maybe not cover, how the used container serves the servlet, so which technology do you use to run the FileDetailsServlet? That's the crucial point: this thing that you use to run (Tomcat, Jetty, other container, maybe included in a fat WAR or fat JAR file from Sprint Boot or another similar technology) has to use the correct .class file.

As you are using Tomcat as container: You should check the class files inside the folder webapps/appname folder below your tomcat folder (replace appname with the deployment context name) Take care: when you run tomcat from Eclipse this could be somewhere completely different than the installation folder on disk, but I don't have an Eclipse installation ready to check that.

The parameterless constructor here only exists in the compiled Java class, and not in your Kotlin code. As far as Kotlin code is concerned, your Student class has one single constructor, with 2 optional parameters.

The Kotlin reflection API is designed to be platform-independent, so you have to use Java reflection to get the parameter constructor.

If you just want to see if you can call createInstance safely, you can just check if the class has a single constructor whose parameters are all optional. This is documented:

Creates a new instance of the class, calling a constructor which either has no parameters or all parameters of which are optional. If there are no or many such constructors, an exception is thrown.

What does this typeSwitch() method do?

The invokeDynamic instruction (upon first being hit) calls the SwitchBootstraps.typeSwitch() method. This method then returns what method call should be executed (this is what invokedynamic generally does).

The last argument of the SwitchBootstraps.typeSwitch() method (the labels parameter) is in this case the list of classes in the switch: Number.class, Enum.class, String.class

The SwitchBootstraps.typeSwitch() bootstrap method checks the labels parameter for correctness and then returns a ConstantCallSite for the SwitchBootstraps.doTypeSwitch() method that does the effective handling (i.e. the final execution of the invokeDynamic instruction).

If you look at what SwitchBootstraps.doTypeSwitch() does: it iterates over the list of classes and returns the first found match.

What's the purpose of the additional int passed?

The additional parameter (startIndex) is needed because of this case:

The MethodParameters attribute is used to indicate that parameters are final. https://docs.oracle.com/javase/specs/jvms/se17/html/jvms-4.html#jvms-4.7.24

In order for javac to add this attribute, you need to pass the -parameters option.

jenkins will work with java 8 on mint 20 and 21. If you have different java versions installed on your system then select the jdk8 as default by

Frontend compilers generate code using simple patterns, and they rely on optimization passes to clean things up. At the point that the x == y expression is generated, the compiler doesn't "know" that the very next thing is a return statement. It could potentially check this, but that extra step can be handled just as easily with some sort of peephole optimizer.

The benefit of a peephole optimizer is that it can perform cascading optimizations, that is, the result of one optimization can feed into the next one. The code that generated the x == y expression doesn't really have any way of performing anything more than one optimization step without adding more complexity.

The java compiler used to have an optimization feature, but this was ditched in favor of HotSpot, which can perform even more powerful optimizations. Performing optimizations in the java compiler would slow it down and not really improve things all that much.

Hmm, grabbing the name of the method which implements the body of the lambda out of a javap decompile is a neat trick for identifying the target method. I'm not sure why Byteman is failing to inject coe. Could you report this via the Byteman JIRA instance? I'll investigate and report the outcome on the JIRA. It may actually be possible to make this work.