Add only_new option to haxe.macro.Context.onGenerate

Author: Apprentice-Alchemist

src/context/common.ml

@@ -51,6 +51,8 @@ class compiler_callbacks = object(self)
 	val mutable after_typing = [];
 	val before_save = ref [];
 	val after_save = ref [];
+	val before_save_only_new = ref [];
+	val after_save_only_new = ref [];
 	val after_filters = ref [];
 	val after_generation = ref [];
 	val mutable null_safety_report = [];
@@ -70,6 +72,12 @@ class compiler_callbacks = object(self)
 	method add_after_save (f : unit -> unit) : unit =
 		after_save := f :: !after_save
 
+	method add_before_save_only_new (f : module_type list -> unit) : unit =
+		before_save_only_new := f :: !before_save_only_new
+
+	method add_after_save_only_new (f : module_type list -> unit) : unit =
+		after_save_only_new := f :: !after_save_only_new
+
 	method add_after_filters (f : unit -> unit) : unit =
 		after_filters := f :: !after_filters
 
@@ -88,11 +96,22 @@ class compiler_callbacks = object(self)
 			List.iter (fun f -> try f() with Error.Error err -> handle_error err) (List.rev l);
 			self#run handle_error r
 
+	method run_with_types handle_error r (tl: module_type list) =
+		match !r with
+		| [] ->
+			()
+		| l ->
+			r := [];
+			List.iter (fun f -> try f tl with Error.Error err -> handle_error err) (List.rev l);
+			self#run_with_types handle_error r tl
+
 	method get_before_typer_create = before_typer_create
 	method get_after_init_macros = after_init_macros
 	method get_after_typing = after_typing
 	method get_before_save = before_save
 	method get_after_save = after_save
+	method get_before_save_only_new = before_save_only_new
+	method get_after_save_only_new = after_save_only_new
 	method get_after_filters = after_filters
 	method get_after_generation = after_generation
 	method get_null_safety_report = null_safety_report

src/filters/filters.ml

@@ -512,6 +512,7 @@ let run com ectx main before_destruction =
 	);
 	with_timer com.timer_ctx detail_times "callbacks" None (fun () ->
 		com.callbacks#run com.error_ext com.callbacks#get_before_save;
+		com.callbacks#run_with_types com.error_ext com.callbacks#get_before_save_only_new new_types;
 	);
 	Common.enter_stage com CSaveStart;
 	with_timer com.timer_ctx detail_times "save state" None (fun () ->
@@ -527,6 +528,7 @@ let run com ectx main before_destruction =
 	Common.enter_stage com CSaveDone;
 	with_timer com.timer_ctx detail_times "callbacks" None (fun () ->
 		com.callbacks#run com.error_ext com.callbacks#get_after_save;
+		com.callbacks#run_with_types com.error_ext com.callbacks#get_after_save_only_new new_types;
 	);
 	before_destruction();
 	destruction com scom ectx detail_times main rename_locals_config com.types all_types_array

src/macro/macroApi.ml

@@ -31,7 +31,7 @@ type 'value compiler_api = {
 	include_module : string -> unit;
 	after_init_macros : (unit -> unit) -> unit;
 	after_typing : (module_type list -> unit) -> unit;
-	on_generate : (Type.t list -> unit) -> bool -> unit;
+	on_generate : (Type.t list -> unit) -> bool -> bool -> unit;
 	after_generate : (unit -> unit) -> unit;
 	on_type_not_found : (string -> 'value) -> unit;
 	parse_string : string -> Globals.pos -> bool -> Ast.expr;
@@ -1901,9 +1901,9 @@ let macro_api ccom get_api =
 			(get_api()).after_typing (fun tl -> ignore(f [encode_array (List.map encode_module_type tl)]));
 			vnull
 		);
-		"on_generate", vfun2 (fun f b ->
+		"on_generate", vfun3 (fun f persistent only_new ->
 			let f = prepare_callback f 1 in
-			(get_api()).on_generate (fun tl -> ignore(f [encode_array (List.map encode_type tl)])) (decode_bool b);
+			(get_api()).on_generate (fun tl -> ignore(f [encode_array (List.map encode_type tl)])) (decode_bool persistent) (decode_bool only_new);
 			vnull
 		);
 		"on_after_generate", vfun1 (fun f ->

src/typing/macroContext.ml

@@ -149,10 +149,15 @@ let make_macro_com_api com mcom p =
 				macro_timer com.timer_ctx timer_level ["afterTyping"] None f tl;
 			)
 		);
-		on_generate = (fun f b ->
-			(if b then com.callbacks#add_before_save else com.callbacks#add_after_save) (fun() ->
-				macro_timer com.timer_ctx timer_level ["onGenerate"] None f (List.map type_of_module_type com.types);
-			)
+		on_generate = (fun f persistent only_new ->
+			if only_new then
+				(if persistent then com.callbacks#add_before_save_only_new else com.callbacks#add_after_save_only_new) (fun tl ->
+					macro_timer com.timer_ctx timer_level ["onGenerate"] None f (List.map type_of_module_type tl);
+				)
+			else
+				(if persistent then com.callbacks#add_before_save else com.callbacks#add_after_save) (fun () ->
+					macro_timer com.timer_ctx timer_level ["onGenerate"] None f (List.map type_of_module_type com.types);
+				)
 		);
 		after_generate = (fun f ->
 			com.callbacks#add_after_generation (fun() ->

std/haxe/macro/Context.hx

@@ -436,7 +436,9 @@ class Context {
 		compiler's typing phase, just before its generation phase.
 
 		The callback receives an `Array` containing all types which are about
-		to be generated. Modifications are limited to metadata, it is mainly
+		to be generated, unless `only_new` is set to `true` in which case the callback
+		only receives types that were not cached by the compilation server.
+		Modifications are limited to metadata, it is mainly
 		intended to obtain information.
 
 		By default, the callback is made before types are stored in the compilation
@@ -447,8 +449,8 @@ class Context {
 
 		*Note*: the callback is still invoked when generation is disabled with  `--no-output`.
 	**/
-	public static function onGenerate(callback:Array<Type>->Void, persistent:Bool = true) {
-		load("on_generate", 2)(callback, persistent);
+	public static function onGenerate(callback:Array<Type>->Void, persistent:Bool = true, only_new:Bool = false) {
+		load("on_generate", 3)(callback, persistent, only_new);
 	}
 
 	/**