I have a question regarding class loading and static initializers, related to https://dev.clojure.org/jira/browse/CLJ-1743

Consider then following snippet:

(ns javafx
  (:import (javafx.scene.control Cell))

(defn f [] Cell)

Cell here is a JavaFX class that has a static initializer that requires the JavaFX platform to be initialized before it is executed

so requiring or compiling this namespace fails with a CompilerException java.lang.ExceptionInInitializerError

It seems like the bytecode for the static initialization of the f function does the following:

0: ldc           #21                 // String javafx.scene.control.Cell
         2: invokestatic  #27                 // Method clojure/lang/RT.classForName:(Ljava/lang/String;)Ljava/lang/Class;
         5: putstatic     #15                 // Field const__0:Ljava/lang/Object;
         8: return

ie. loads a constant string, and calls RT.classForName

causing the load of the class and the call to the static initializer

Java would instead use a Class entry in the constant pool, and just use that in the implementation of f:

0: ldc           #2                  // class javafx/scene/control/Cell
         2: areturn

where #2 is a Class entry in the constant pool

My question is, is there a reason clojure could not do the same here, avoiding the RT.classForName call?

I see the patch proposed for CLJ-1743 uses RT.classForNameNonLoading

yes, embedding the class in the constant pool is too static

because of dynamic class loading?

yes

ok. in the snippet i showed, would it be reasonable to emit a RT.classForNameNonLoading for Cell?

I don't know

I would be more inclined to attempt to use reflection to work around jfx loading issues than anything else

It's ok to workaround now, with JDK9 you can simply do a (Platform/startup #(compile 'javafx)) in this case

ugh, don't do that

compile is for aot compiling, aot compiling at runtime is silly

not sure I follow, we AOT compile our app, so need to be able to compile the parts that use JavaFX classes too

wouldn't make that call "at runtime", but as part of building our app

I would at the very least change it to require

but I guess it depends how as part of your build you are running (Platform/startup #(compile 'javafx)), e.g. if you just have it in the middle of a source file that is being compiled (in which case the compile will also attempt to run at runtime) or if you have it part of some build script that isn't being compiled

so, a gross simplification of what we have is something like this:

(defn aot
  []
  (binding [*compile-path* "build/classes"]
    (compile 'some-main-ns)))

(aot)

that's in a .clj file that we invoke using clojure.main to AOT our main ns

that doesn't work if 'some-main-ns transitively depends on something that imports a JavaFX class

doing (Platform/startup #(aot)) works

and is admittedly a hack