[jvm] auto-detect Java SAM interfaces; honor SAM in overload resolution (#12901)

* [jvm] auto-detect Java SAM interfaces; honor SAM in overload resolution

Two related changes that together make Haxe match javac's lambda-vs-SAM
conversion rules on the JVM target.

1. Structural SAM detection in javaModern.ml

Previously, only interfaces carrying @FunctionalInterface were tagged
CFunctionalInterface and so eligible for implicit conversion from a
function value. The annotation is documentation in javac too — what
makes a type lambda-convertible is having exactly one abstract instance
method, per JLS §9.8. The Android SDK rarely annotates its listeners,
which forced every consumer of the JVM target to hand-roll adapter
classes for View.OnClickListener, DialogInterface.OnClickListener,
MediaPlayer.OnCompletionListener and so on.

This patch auto-tags any .jar-imported interface as @:functionalInterface
when it has exactly one abstract instance method, excluding:
  - static / default / private / synthetic methods,
  - constructors,
  - Object members re-declared as abstract (equals/hashCode/toString,
    matched by name+arity since their signatures on j.l.Object are
    unambiguous — JLS §9.8 excludes these from the SAM count).

The explicit @FunctionalInterface annotation path is preserved.

2. SAM-aware overload candidate filtering

overloadResolution.ml's unify_cf used strict Type.unify to filter
candidates before the cast layer could fire. A function value passed to
an overload whose parameter is a SAM class would be discarded at the
filter step. Now, when strict unify fails, the filter retries via the
SAM conversion path — unifying the function's TFun against the SAM
method's signature, mirroring what AbstractCast does at cast time. Only
candidates whose SAM signature actually matches the function shape
survive, so this isn't a blind accept.

Two supporting fixes round this out:

  - overloads.ml rate_conv: added a TInst(SAM), TFun case so specificity
    ranking works when two SAM-parametered overloads both accept the
    same function. The rate descends through the SAM method's signature
    rather than raising Not_found, which previously discarded the
    candidate during reduce_compatible.

  - tOther.ml get_singular_interface_field and the parallel walker in
    genjvm.ml's check_functional_interface now exclude equals/hashCode/
    toString by name+arity, matching the new exclusion in javaModern so
    interfaces like Comparator (abstract equals re-declared) — and the
    Android SDK's various 'override equals' interfaces — are still
    detected as SAMs at both typer and codegen stages.

Tests:

  - tests/unit/.../IssueFunctionalInterfaceOverload.hx exercises the
    overload disambiguation path with two @:functionalInterface
    interfaces of disjoint shape (Int,Int -> Int vs String -> String).
  - tests/misc/jvm/projects/StructuralSam/ ships a .java file with six
    interface shapes — plain SAM, abstract-equals re-declaration,
    default/static method skipping, multi-abstract non-SAM, generic-arg
    SAM, and overloaded call sites — none annotated @FunctionalInterface.
    Runs the generated jar end-to-end to verify both type-checking and
    runtime closure-adapter dispatch.

Limitations matching javac:

  - Abstract-class SAMs (e.g. android.content.BroadcastReceiver) remain
    unsupported; javac doesn't allow lambda conversion to those either.
  - Two SAM-parametered overloads where both signatures would accept
    the same function value remain ambiguous and require explicit
    disambiguation.

* [jvm] skip JDK-internal packages in structural SAM detection

Auto-tagging every structurally-SAM interface as @:functionalInterface
swept in sun.reflect.ConstructorAccessor, sun.nio.ch.Interruptible,
sun.reflect.generics.tree.TypeTree and similar JDK-internal classes.
The existing JFI matcher then made every signature-matching closure
declare `implements sun.reflect.ConstructorAccessor`, which compiles
fine against the extern jar but fails to defineClass at runtime on
JDK 9+ — sun.* was moved to jdk.internal.* and is inaccessible to
application code.

This broke unit tests at startup: Issue5556 was the first class to
trigger loading the affected closure adapter, raising
NoClassDefFoundError before any test ran.

User code can't legitimately target these internal packages anyway,
so the fix is to exclude sun.*, com.sun.*, and jdk.internal.* from
structural detection. Classes that actually carry @FunctionalInterface
are still honored (none of the affected internal classes do, so this
is safe). Issue5556 serves as the regression test — its closure
adapter previously implemented sun.reflect.ConstructorAccessor and
now no longer does.

* [jvm] only implement SAM interfaces the program actually uses

Structural SAM detection tags every single-abstract-method interface on
the --java-lib classpath as @:functionalInterface, and a closure then
implements every one of them whose signature structurally matches. That
includes interfaces transitively loaded from the SDK jar but never named
in user code — e.g. compiling against android-34 drags in
android.os.OutcomeReceiver (API 33) and SplashScreen.OnExitAnimationListener
(API 31). A closure implementing those hard-fails class linking
(NoClassDefFoundError) the moment it loads on an older runtime, crashing
the app at activity instantiation.

Restrict the promiscuous binding to interfaces the program genuinely
converts a function to:

  - new com.functional_interfaces_used set (shared across cloned contexts,
    exposed on Gctx.t for the generator);
  - AbstractCast records each interface as its SAM-conversion branch fires,
    keyed by the @:native path since Native.apply_native_paths rewrites
    cl_path between typing and generation;
  - genjvm's Preprocessor only registers an interface in
    gctx.functional_interfaces when it is in that set, resolved by physical
    class identity in the modules loop (before check_path can rewrite the
    path again).

StructuralSam gains an Unused interface — structurally identical to
OnClick but never used as a conversion target — and asserts a closure
implements OnClick but not Unused.

* [jvm] derive used SAM interfaces from the AST, not just AbstractCast

The functional_interfaces_used set populated by AbstractCast only covers
interfaces reached through an implicit SAM conversion typed from source.
That misses two cases: an explicit `cast` of a closure to a functional
interface bypasses AbstractCast entirely, and an `--hxb-lib` build never
re-runs typing so the set is empty — closures then fail to implement the
interface and hard-cast at runtime (Issue9576, Issue11236,
IssueFunctionalInterfaceOverload under the hxb-lib CI configs).

Additionally scan the AST of non-extern types in genjvm's Preprocessor:
field/static/constructor signatures and their cf_overloads, plus the
etype of every sub-expression (which catches the TFun type of a called
extern method whose parameter is a SAM interface). This is independent
of how the module was loaded. Restricting the scan to non-extern types
keeps incidental SAM interfaces from a --java-lib classpath out of the
set unless user code actually references them.

* [tests] move test to TestJava

* [jvm] route check_functional_interface through get_singular_interface_field

The JLS §9.8 SAM rule (exclude default methods and Object members) was
duplicated between tOther and genjvm; the latter now just calls the
shared helper.

* [jvm] drop functional_interfaces_used; AST scan is the sole source

AbstractCast was writing into a Hashtbl on the common context to track
which SAM interfaces a program converts a function to, with @:native
re-keying to bridge the typing↔generation path rewrite. The genjvm
preprocessor already walks the AST and collects every SAM-typed TInst
it sees, which strictly subsumes the AbstractCast set (it also catches
explicit casts and --hxb-lib builds). Remove the redundant bookkeeping
and the field on common.context / Gctx.t.

* [jvm] swap fi_used_classes List.memq for path-keyed Hashtbl

Avoid an O(n*m) lookup over the SAM-used list during the interface
preprocessing loop. The list is finalized into a Hashtbl after loop 1
completes (and therefore after check_path's cl_path rewrites), so
keying by cl_path is stable.

* [jvm] drop functional_interface_lut; compute SAM field on demand

The LUT memoized get_singular_interface_field per class, populated by
typeloadFields.check_functional_interface and re-checked lazily by
AbstractCast (#11549, for display-mode flows where init_class hadn't
run yet by the time a SAM conversion was queried). It was a global
mutable hashtbl on common.context whose only reader was AbstractCast.

The cached computation is a walk over a SAM interface's field list —
typically under 10 entries, and short-circuits on the second non-default
method, so the perf delta from recomputing is well below noise. Doing
that directly in AbstractCast collapses the two load paths into one and
removes the field from common.context.

Also drops the now-no-op typeloadFields.check_functional_interface
(its only effect was populating the LUT) and the bridge call that
re-invoked it from init_class when the flag was set via @:functionalInterface
meta in typeloadModule.

* [jvm] extract collect_used_functional_interfaces

Move the SAM-usage AST scan out of preprocess and into its own
top-level function in the Preprocessor module that returns the
path-keyed hashtbl. The scan now runs after the check_path loop so
cl_paths are stable when we record them.

Author: kLabz

src/codegen/javaModern.ml

@@ -985,16 +985,68 @@ module Converter = struct
 			in
 			add_meta (Meta.Annotation,args,p)
 		end;
+		let has_fi_annotation = ref false in
 		List.iter (fun attr -> match attr with
 			| AttrVisibleAnnotations ann ->
 				List.iter (function
 					| { ann_type = TObject( (["java";"lang"], "FunctionalInterface"), [] ) } ->
-						add_meta (Meta.FunctionalInterface,[],p);
+						has_fi_annotation := true
 					| _ -> ()
 				) ann
 			| _ ->
 				()
 		) jc.jc_attributes;
+		(* Match javac's SAM rule: an interface is functional if it declares exactly
+		   one abstract instance method (ignoring static/default/private/synthetic
+		   methods, constructors, and Object members re-declared as abstract). The
+		   @FunctionalInterface annotation is advisory in javac — Android SDK
+		   listeners are rarely annotated, so structural detection unlocks lambdas
+		   for them without per-extern opt-in. *)
+		(* JLS §9.8 excludes methods that would be members of Object from the SAM
+		   count. Match by name+arity rather than full descriptor — equals's exact
+		   param encoding can vary across class-file shapes (raw Object, generic
+		   erasure variants), and equals/hashCode/toString have unique arities on
+		   java.lang.Object so name+arity is unambiguous. *)
+		let is_object_redeclaration jf = match jf.jf_name, jf.jf_descriptor with
+			| "equals", TMethod([_],_) -> true
+			| "hashCode", TMethod([],_) -> true
+			| "toString", TMethod([],_) -> true
+			| _ -> false
+		in
+		(* Skip JDK-internal packages: sun.*, com.sun.*, jdk.internal.*. They host
+		   many single-method classes (sun.reflect.ConstructorAccessor,
+		   sun.nio.ch.Interruptible, sun.reflect.generics.tree.TypeTree, ...) that
+		   compile-time externs see but the runtime JDK may not expose — sun.* was
+		   moved to jdk.internal.* in JDK 9+ and is inaccessible to app code.
+		   Auto-tagging them as functional interfaces makes the JFI matcher emit
+		   `implements sun.reflect.ConstructorAccessor` on every matching closure,
+		   which then fails to defineClass at runtime. User code can't target these
+		   anyway, so structural detection must skip them. The @FunctionalInterface
+		   annotation path is still honored (none of the affected JDK-internal
+		   classes carry it, so this is a safe restriction). *)
+		let is_jdk_internal_package pack = match pack with
+			| "sun" :: _ -> true
+			| "com" :: "sun" :: _ -> true
+			| "jdk" :: "internal" :: _ -> true
+			| _ -> false
+		in
+		let is_structural_sam = is_interface
+			&& not (is_jdk_internal_package (fst jc.jc_path))
+			&& (
+				let count = List.fold_left (fun acc jf ->
+					if AccessFlags.has_flag jf.jf_flags MAbstract
+						&& not (AccessFlags.has_flag jf.jf_flags MStatic)
+						&& not (AccessFlags.has_flag jf.jf_flags MPrivate)
+						&& not (AccessFlags.has_flag jf.jf_flags MSynthetic)
+						&& jf.jf_name <> "<init>"
+						&& not (is_object_redeclaration jf)
+					then acc + 1 else acc
+				) 0 jc.jc_methods in
+				count = 1
+			)
+		in
+		if !has_fi_annotation || is_structural_sam then
+			add_meta (Meta.FunctionalInterface,[],p);
 		let d = {
 			d_name = (class_name,p);
 			d_doc = None;

src/codegen/overloads.ml

@@ -192,6 +192,17 @@ struct
 				raise Not_found)
 		| TFun _, TFun _ -> (* unify will make sure they are compatible *)
 			cacc,0
+		(* SAM conversion: lambda passed where a functional-interface class is
+		   expected. Rate by how closely the lambda's signature matches the SAM
+		   method's signature so specificity ordering still works between two
+		   SAM-parametered overloads. *)
+		| TInst(cf,tlf), TFun _ when has_class_flag cf CFunctionalInterface ->
+			begin match TOther.TClass.get_singular_interface_field cf.cl_ordered_fields with
+			| None -> raise Not_found
+			| Some sam ->
+				let map = apply_params cf.cl_params tlf in
+				rate_conv (cacc+1) (map sam.cf_type) targ
+			end
 		| tfun,targ ->
 			raise Not_found
 

src/context/abstractCast.ml

@@ -88,14 +88,9 @@ and do_check_cast ctx uctx tleft eright p =
 						loop2 a.a_to
 					end
 				| TInst(c,tl), TFun _ when has_class_flag c CFunctionalInterface ->
-					let cf = try
-						snd (ctx.com.functional_interface_lut#find c.cl_path)
-					with Not_found -> match TClass.get_singular_interface_field c.cl_ordered_fields with
-						| None ->
-							raise Not_found
-						| Some cf ->
-							ctx.com.functional_interface_lut#add c.cl_path (c,cf);
-							cf
+					let cf = match TClass.get_singular_interface_field c.cl_ordered_fields with
+						| None -> raise Not_found
+						| Some cf -> cf
 					in
 					let map = apply_params c.cl_params tl in
 					let monos = Monomorph.spawn_constrained_monos map cf.cf_params in

src/context/common.ml

@@ -345,7 +345,6 @@ and context = {
 	mutable modules : Type.module_def list;
 	mutable types : Type.module_type list;
 	mutable resources : (string,string) Hashtbl.t;
-	functional_interface_lut : (path,(tclass * tclass_field)) lookup;
 	(* target-specific *)
 	mutable flash_version : float;
 	mutable neko_lib_paths : string list;
@@ -810,7 +809,6 @@ let create sctx request_scope part_scope display_mode =
 		parser_cache = new hashtbl_lookup;
 		overload_cache = new hashtbl_lookup;
 		is_macro_context = false;
-		functional_interface_lut = new Lookup.hashtbl_lookup;
 		hxb_reader_api = None;
 		hxb_reader_stats = HxbReader.create_hxb_reader_stats ();
 		hxb_writer_config = None;
@@ -935,7 +933,6 @@ let clone com is_macro_context =
 		parser_cache = new hashtbl_lookup;
 		overload_cache = new hashtbl_lookup; (* ! *)
 		is_macro_context = is_macro_context;
-		functional_interface_lut = new Lookup.hashtbl_lookup;
 		hxb_reader_api = None;
 		hxb_reader_stats = HxbReader.create_hxb_reader_stats ();
 	}

src/core/tOther.ml

@@ -386,8 +386,19 @@ module TClass = struct
 			c.cl_init <- Some cf
 
 	let get_singular_interface_field fields =
+		(* Re-declarations of java.lang.Object members (equals/hashCode/toString)
+		   on an interface must not count toward the SAM check — JLS §9.8.
+		   Matched by name+arity since these are unique on Object. *)
+		let is_object_member cf = match cf.cf_name, follow cf.cf_type with
+			| "equals", TFun([_],_) -> true
+			| "hashCode", TFun([],_) -> true
+			| "toString", TFun([],_) -> true
+			| _ -> false
+		in
 		let is_normal_field cf =
-			not (has_class_field_flag cf CfDefault) && match cf.cf_kind with
+			not (has_class_field_flag cf CfDefault)
+			&& not (is_object_member cf)
+			&& match cf.cf_kind with
 				| Method MethNormal -> true
 				| _ -> false
 		in

src/generators/genjvm.ml

@@ -3201,19 +3201,7 @@ module Preprocessor = struct
 			mt.mt_path <- make_root mt.mt_path
 
 	let check_functional_interface gctx c =
-		let rec loop m l = match l with
-			| [] ->
-				m
-			| cf :: l ->
-				if not (has_class_field_flag cf CfDefault) then begin match m with
-					| None ->
-						loop (Some cf) l
-					| Some _ ->
-						None
-				end else
-					loop m l
-		in
-		match loop None c.cl_ordered_fields with
+		match TClass.get_singular_interface_field c.cl_ordered_fields with
 		| None ->
 			()
 		| Some cf ->
@@ -3224,6 +3212,57 @@ module Preprocessor = struct
 			| _ ->
 				()
 
+	(* Collect the functional interfaces actually referenced by user code, so
+	   closures only implement SAMs the program demands. Without this filter a
+	   closure would bind to every structurally-matching interface on the
+	   --java-lib classpath — including incidental ones from a higher API level
+	   than the runtime, which hard-fails class linking. An interface counts as
+	   used iff some non-extern type, field signature, or sub-expression names
+	   it; scanning non-extern code only keeps classpath noise out. *)
+	let collect_used_functional_interfaces gctx =
+		let used = Hashtbl.create 0 in
+		let rec note_fi_in_type depth t =
+			if depth < 32 then match follow t with
+			| TInst(c,tl) ->
+				if has_class_flag c CFunctionalInterface then Hashtbl.replace used c.cl_path ();
+				List.iter (note_fi_in_type (depth + 1)) tl
+			| TFun(args,ret) ->
+				List.iter (fun (_,_,t) -> note_fi_in_type (depth + 1) t) args;
+				note_fi_in_type (depth + 1) ret
+			| TAbstract(_,tl) | TEnum(_,tl) | TType(_,tl) ->
+				List.iter (note_fi_in_type (depth + 1)) tl
+			| TAnon an ->
+				PMap.iter (fun _ cf -> note_fi_in_type (depth + 1) cf.cf_type) an.a_fields
+			| TDynamic (Some t) ->
+				note_fi_in_type (depth + 1) t
+			| _ ->
+				()
+		in
+		let rec note_fi_in_expr e =
+			note_fi_in_type 0 e.etype;
+			Type.iter note_fi_in_expr e
+		in
+		let scan_class c =
+			if not (has_class_flag c CExtern) then begin
+				let rec scan cf =
+					note_fi_in_type 0 cf.cf_type;
+					Option.may note_fi_in_expr cf.cf_expr;
+					List.iter scan cf.cf_overloads
+				in
+				List.iter scan c.cl_ordered_fields;
+				List.iter scan c.cl_ordered_statics;
+				Option.may scan c.cl_constructor
+			end
+		in
+		(* go through com.modules so we can also pick up private typedefs *)
+		List.iter (fun m ->
+			List.iter (fun mt -> match mt with
+				| TClassDecl c -> scan_class c
+				| _ -> ()
+			) m.m_types
+		) gctx.gctx.modules;
+		used
+
 	let preprocess gctx =
 		let rec has_runtime_meta = function
 			| (Meta.Custom s,_,_) :: _ when String.length s > 0 && s.[0] <> ':' ->
@@ -3233,7 +3272,6 @@ module Preprocessor = struct
 			| [] ->
 				false
 		in
-		(* go through com.modules so we can also pick up private typedefs *)
 		List.iter (fun m ->
 			List.iter (fun mt ->
 				match mt with
@@ -3251,6 +3289,9 @@ module Preprocessor = struct
 					()
 			) m.m_types
 		) gctx.gctx.modules;
+		(* After check_path: cl_paths are stable, so we can key the used-SAM
+		   set by cl_path without worrying about private-type rewrites. *)
+		let fi_used = collect_used_functional_interfaces gctx in
 		(* preprocess classes *)
 		let patch_optional c =
 			let apply cf =
@@ -3267,8 +3308,8 @@ module Preprocessor = struct
 					gctx.preprocessor#preprocess_class c
 				else begin
 					patch_optional c;
-					if has_class_flag c CFunctionalInterface then
-					check_functional_interface gctx c
+					if Hashtbl.mem fi_used c.cl_path then
+						check_functional_interface gctx c
 				end
 			| _ -> ()
 		) gctx.gctx.types;

src/typing/overloadResolution.ml

@@ -1,16 +1,38 @@
 open TType
 open TUnification
 open TFunctions
+open TOther
 open FieldCallCandidate
 
+(* Try the functional-interface conversion path: if [t_param] is a SAM class
+   and [t_arg] is a function type, unify the function against the SAM method's
+   signature (mirroring what AbstractCast does at cast time). Returns true if
+   compatible. Used during overload candidate filtering so SAM-parameter
+   overloads aren't discarded before the cast layer runs — but unlike a blind
+   accept, this still rejects lambdas whose shape doesn't match the SAM. *)
+let try_functional_interface_match t_param t_arg =
+	match follow t_param, follow t_arg with
+	| TInst(c,tl), TFun _ when has_class_flag c CFunctionalInterface ->
+		begin match TClass.get_singular_interface_field c.cl_ordered_fields with
+		| None -> false
+		| Some cf ->
+			let map = apply_params c.cl_params tl in
+			let monos = List.map (fun _ -> mk_mono()) cf.cf_params in
+			let expected = map (apply_params cf.cf_params monos cf.cf_type) in
+			try Type.unify t_arg expected; true
+			with Unify_error _ -> false
+		end
+	| _ -> false
+
 let unify_cf map_type c cf el =
 	let monos = List.map (fun _ -> mk_mono()) cf.cf_params in
 	match follow (apply_params cf.cf_params monos (map_type cf.cf_type)) with
 		| TFun(tl'',ret) as tf ->
 			let rec loop2 acc el tl = match el,tl with
 				| e :: el,(_,o,t) :: tl ->
 					begin try
-						Type.unify e.etype t;
+						(try Type.unify e.etype t
+						 with Unify_error _ when try_functional_interface_match t e.etype -> ());
 						loop2 (e :: acc) el tl
 					with _ ->
 						if Type.ExtType.is_rest (follow t) then

src/typing/typeloadFields.ml

@@ -1644,14 +1644,6 @@ let finalize_class cctx =
 		| Some r -> delay ctx.g PTypeField (fun() -> ignore(lazy_type r)))
 	) cctx.delayed_expr
 
-let check_functional_interface ctx c =
-	match TClass.get_singular_interface_field c.cl_ordered_fields with
-	| None ->
-		()
-	| Some cf ->
-		add_class_flag c CFunctionalInterface;
-		ctx.com.functional_interface_lut#add c.cl_path (c,cf)
-
 let create_class_field cctx f  =
 	let cf = {(mk_field (fst f.cff_name) ~public:(is_public cctx f.cff_access None) t_dynamic f.cff_pos (pos f.cff_name)) with
 		cf_doc = f.cff_doc;
@@ -1793,7 +1785,7 @@ let init_class ctx_c cctx c p herits fields =
 			a.a_unops <- List.rev a.a_unops;
 			a.a_array <- List.rev a.a_array;
 		| None ->
-			if (has_class_flag c CFunctionalInterface) && com.platform = Jvm then check_functional_interface ctx_c c;
+			()
 	end;
 	c.cl_ordered_statics <- List.rev c.cl_ordered_statics;
 	c.cl_ordered_fields <- List.rev c.cl_ordered_fields;

tests/misc/jvm/projects/StructuralSam/Main.hx

@@ -0,0 +1,38 @@
+import test.Listeners;
+import test.Listeners.Listeners_OnClick;
+import test.Listeners.Listeners_WithToString;
+import test.Listeners.Listeners_AbstractEqualsPlusOne;
+import test.Listeners.Listeners_WithDefaults;
+import test.Listeners.Listeners_StringMaker;
+import test.Listeners.Listeners_Unused;
+
+function main() {
+	// Plain SAM — javac would accept the lambda directly.
+	trace(Listeners.runOnClick(id -> Sys.println("click=" + id), 7));
+
+	// SAM with default toString inherited from Object — still single abstract.
+	trace(Listeners.runDescribe(v -> "v=" + v, 3));
+
+	// Abstract equals re-declaration must be excluded from the count.
+	trace(Listeners.runCompute(a -> a * a, 5));
+
+	// default + static methods don't count toward abstractness.
+	trace(Listeners.runTransform(x -> x + 1, 10));
+
+	// Non-overloaded SAM with non-void return — sanity check.
+	trace(Listeners.runMaker(n -> "made-" + n, 2));
+
+	// SAM-aware overload disambiguation: distinct arg arities so the right
+	// candidate is unambiguous.
+	trace(Listeners.overloaded((id:Int) -> Sys.println("ovl-click=" + id), 1));
+	trace(Listeners.overloaded((s:String) -> s + "!", "hi"));
+
+	// A closure converted to OnClick must implement OnClick at runtime — but
+	// NOT Unused, which is structurally identical yet never used as a
+	// conversion target. Guards against closures promiscuously implementing
+	// every matching SAM interface on the classpath.
+	var cb:Listeners_OnClick = id -> Sys.println("bound-click=" + id);
+	Listeners.runOnClick(cb, 99);
+	trace(Std.isOfType(cb, Listeners_OnClick));
+	trace(Std.isOfType(cb, Listeners_Unused));
+}

tests/misc/jvm/projects/StructuralSam/Setup.hx

@@ -0,0 +1,18 @@
+import sys.FileSystem;
+
+function main() {
+	Sys.setCwd("./project");
+	FileSystem.createDirectory("./out");
+	Sys.command("javac", ["-d", "out", "test/Listeners.java", "-g"]);
+	Sys.setCwd("./out");
+	Sys.command("jar", ["cf", "test.jar",
+		"test/Listeners.class",
+		"test/Listeners$OnClick.class",
+		"test/Listeners$WithToString.class",
+		"test/Listeners$AbstractEqualsPlusOne.class",
+		"test/Listeners$WithDefaults.class",
+		"test/Listeners$NotSam.class",
+		"test/Listeners$StringMaker.class",
+		"test/Listeners$Unused.class",
+		"test/Listeners$UnaryStringFn.class"]);
+}