[hxb] fix a_status tdefs, implement enum fields, improve debug printing

src/compiler/compiler.ml

@@ -286,6 +286,7 @@ let do_type ctx mctx actx display_file_dot_path macro_cache_enabled =
 	MacroContext.macro_enable_cache := macro_cache_enabled;
 
 	let macros = match mctx with None -> None | Some mctx -> mctx.g.macros in
+	Printf.eprintf "=== Create typer context ===\n";
 	let tctx = Setup.create_typer_context ctx macros actx.native_libs in
 	let display_file_dot_path = DisplayProcessing.maybe_load_display_file_before_typing tctx display_file_dot_path in
 	check_defines ctx.com;

src/compiler/displayOutput.ml

@@ -344,6 +344,7 @@ let handle_type_path_exception ctx p c is_import pos =
 			| None ->
 				DisplayPath.TypePathHandler.complete_type_path com p
 			| Some (c,cur_package) ->
+				Printf.eprintf "=== [Display] create typer context ===\n";
 				let ctx = Typer.create com None in
 				DisplayPath.TypePathHandler.complete_type_path_inner ctx p c cur_package is_import
 		end with Common.Abort msg ->

src/compiler/generate.ml

@@ -1,11 +1,12 @@
 open Globals
 open CompilationContext
 open TType
+open Tanon_identification
 
 let test_hxb com m =
 	if m.m_extra.m_kind = MCode then begin
 		let ch = IO.output_bytes() in
-		let anon_identification = new Genshared.tanon_identification ([],"") in
+		let anon_identification = new tanon_identification ([],"") in
 		let writer = new HxbWriter.hxb_writer anon_identification (* cp *) in
 		writer#write_module m;
 		let bytes_module = IO.close_out ch in

src/compiler/hxb/hxbData.ml

@@ -7,14 +7,14 @@ type chunk_kind =
 	| TYPF (* forward types *)
 	| CLSR (* class reference array *)
 	| ABSR (* abstract reference array *)
-	| ENMR (* enum reference array *)
 	| TPDR (* typedef reference array *)
+	| ENMR (* enum reference array *)
 	| CLSD (* class definition *)
 	| ABSD (* abstract definition *)
-	| CFLD (* class fields without expressions *)
+	| CFLD (* class fields *)
+	| TPDD (* typedef definition *)
 	| ENMD (* enum definition *)
 	| EFLD (* enum fields *)
-	| TPDD (* typedef definition *)
 	| HEND (* the end *)
 
 let string_of_chunk_kind = function

src/compiler/hxb/hxbReader.ml

@@ -2,7 +2,14 @@ open Globals
 open Ast
 open Type
 open HxbData
-open TPrinting
+
+(* Debug utils *)
+let no_color = false
+let c_reset = if no_color then "" else "\x1b[0m"
+let c_bold = if no_color then "" else "\x1b[1m"
+let c_dim = if no_color then "" else "\x1b[2m"
+let todo = "\x1b[33m[TODO]" ^ c_reset
+let todo_error = "\x1b[41m[TODO] error:" ^ c_reset
 
 class hxb_reader
 	(com : Common.context)
@@ -20,12 +27,8 @@ class hxb_reader
 	val mutable abstracts = Array.make 0 null_abstract
 	val mutable enums = Array.make 0 null_enum
 	val mutable typedefs = Array.make 0 null_typedef
-	(* val mutable class_fields = Array.make 0 null_class_field *)
-	(* val mutable abstract_fields = Array.make 0 null_abstract_field *)
-	(* val mutable enum_fields = Array.make 0 null_enum_field *)
 
 	val vars = Hashtbl.create 0
-	(* val mutable vars = Array.make 0 null_tvar *)
 	val mutable type_type_parameters = Array.make 0 (mk_type_param "" t_dynamic None)
 	val mutable field_type_parameters = Array.make 0 (mk_type_param "" t_dynamic None)
 
@@ -174,22 +177,28 @@ class hxb_reader
 		let i = self#read_uleb128 in
 		typedefs.(i)
 
-	method read_field_ref fields =
+	(* method read_field_ref fields = *)
+	method read_field_ref source fields =
 		let name = self#read_string in
 		try PMap.find name fields with e ->
-			Printf.eprintf "  TODO error reading field ref for %s\n" name;
+			Printf.eprintf "  %s reading field ref for %s.%s\n" todo_error source name;
+			Printf.eprintf "    Available fields: %s\n" (PMap.fold (fun f acc -> acc ^ " " ^ f.cf_name) fields "");
 			null_field
 
-	method read_enum_field_ref =
-		(* Printf.eprintf "  TODO enum field ref %s\n" name; *)
-		assert false (* TODO *)
+	method read_enum_field_ref en =
+		let name = self#read_string in
+		Printf.eprintf "  TODO enum field ref %s\n" name;
+		try PMap.find name en.e_constrs with e ->
+			Printf.eprintf "  %s reading enum field ref for %s.%s\n" todo_error (s_type_path en.e_path) name;
+			Printf.eprintf "    Available fields: %s\n" (PMap.fold (fun ef acc -> acc ^ " " ^ ef.ef_name) en.e_constrs "");
+			null_enum_field
 
 	(* Type instances *)
 
 	method read_type_instance =
 		match self#read_u8 with
 		| 0 ->
-			Printf.eprintf "  TODO identity\n";
+			Printf.eprintf "  %s identity\n" todo;
 			mk_mono() (* TODO: identity *)
 		| 1 ->
 			self#read_type_instance
@@ -206,7 +215,19 @@ class hxb_reader
 		| 11 ->
 			TEnum(self#read_enum_ref,[])
 		| 12 ->
-			TType(self#read_typedef_ref,[])
+			begin match self#read_u8 with
+				| 0 ->
+					let c = self#read_class_ref in
+					TType(class_module_type c,[])
+				| 1 ->
+					let e = self#read_enum_ref in
+					TType(enum_module_type e.e_module e.e_path e.e_pos,[])
+				| 2 ->
+					let a = self#read_abstract_ref in
+					TType(abstract_module_type a [],[])
+				| _ ->
+					TType(self#read_typedef_ref,[])
+			end
 		| 13 ->
 			TAbstract(self#read_abstract_ref,[])
 		| 14 ->
@@ -245,7 +266,7 @@ class hxb_reader
 			mk_anon (ref Closed)
 		| 51 ->
 			ignore(self#read_uleb128);
-			Printf.eprintf "  TODO TAnon\n";
+			Printf.eprintf "  %s TAnon\n" todo;
 			t_dynamic (* TODO *)
 		| i ->
 			error (Printf.sprintf "Bad type instance id: %i" i)
@@ -356,22 +377,6 @@ class hxb_reader
 			tf_expr = e;
 		}
 
-	(* method read_switch_case = *)
-	(* 	(1* list_8 *1) *)
-	(* 	(1* Printf.eprintf "   read_switch_case\n"; *1) *)
-	(* 	let el = self#read_list8 (fun () -> self#read_texpr) in *)
-	(* 	let e = self#read_texpr in *)
-	(* 	{ *)
-	(* 		case_patterns = el; *)
-	(* 		case_expr = e; *)
-	(* 	} *)
-
-	(* method read_catch = *)
-	(* 	(1* Printf.eprintf "   read_catch\n"; *1) *)
-	(* 	let v = self#read_var in *)
-	(* 	let e = self#read_texpr in *)
-	(* 	(v,e) *)
-
 	method read_var_kind =
 		match IO.read_byte ch with
 			| 0 -> VUser TVOLocalVariable
@@ -497,8 +502,19 @@ class hxb_reader
 				let e3 = self#read_texpr in
 				TIf(e1,e2,Some e3)
 			| 82 ->
-				(* TODO TSwitch *)
-				assert false
+				let subject = self#read_texpr in
+				let cases = self#read_list16 (fun () ->
+					let patterns = self#read_texpr_list in
+					let ec = self#read_texpr in
+					{ case_patterns = patterns; case_expr = ec}
+				) in
+				let def = self#read_option (fun () -> self#read_texpr) in
+				TSwitch {
+					switch_subject = subject;
+					switch_cases = cases;
+					switch_default = def;
+					switch_exhaustive = true;
+				}
 			| 83 ->
 				(* TODO TTry *)
 				assert false
@@ -527,43 +543,52 @@ class hxb_reader
 			| 100 -> TEnumIndex (self#read_texpr)
 			| 101 ->
 				let e1 = self#read_texpr in
-				let ef = self#read_enum_field_ref in
+				let en = self#read_enum_ref in
+				(* Printf.eprintf "  %s TEnumParameter for %s\n" todo (s_type_path en.e_path); *)
+				(* PMap.iter (fun k _-> Printf.eprintf "    -> %s\n" k) en.e_constrs; *)
+				let ef = self#read_enum_field_ref en in
 				let i = IO.read_i32 ch in
 				TEnumParameter(e1,ef,i)
 			| 102 ->
 				let e1 = self#read_texpr in
 				let c = self#read_class_ref in
 				let tl = self#read_types in
-				Printf.eprintf "  Read field ref for expr 102 (cl = %s)\n" (snd c.cl_path);
-				let cf = self#read_field_ref c.cl_fields in
+				Printf.eprintf "  Read field ref for expr 102 (cl = %s, %d fields)\n" (s_type_path c.cl_path) (List.length c.cl_ordered_fields);
+				let cf = self#read_field_ref (s_type_path c.cl_path) c.cl_fields in
+				(* let cf = self#read_field_ref c.cl_fields in *)
 				TField(e1,FInstance(c,tl,cf))
 			| 103 ->
 				let e1 = self#read_texpr in
 				let c = self#read_class_ref in
-				Printf.eprintf "  Read field ref for expr 103 (cl = %s)\n" (snd c.cl_path);
-				let cf = self#read_field_ref c.cl_statics in
+				Printf.eprintf "  Read field ref for expr 103 (cl = %s)\n" (s_type_path c.cl_path);
+				let cf = self#read_field_ref (s_type_path c.cl_path) c.cl_statics in
+				(* let cf = self#read_field_ref c.cl_statics in *)
 				TField(e1,FStatic(c,cf))
 			| 104 ->
 				let e1 = self#read_texpr in
 				(* TODO (see writer) *)
 				(* TODO TField(e1,FAnon(cf)) *)
+				Printf.eprintf "  %s TField(e,FAnon(cf))\n" todo;
 				e1.eexpr
 			| 105 ->
 				let e1 = self#read_texpr in
 				let c = self#read_class_ref in
 				let tl = self#read_types in
-				Printf.eprintf "  Read field ref for expr 105 (cl = %s)\n" (snd c.cl_path);
-				let cf = self#read_field_ref c.cl_fields in
+				Printf.eprintf "  Read field ref for expr 105 (cl = %s)\n" (s_type_path c.cl_path);
+				let cf = self#read_field_ref (s_type_path c.cl_path) c.cl_fields in
+				(* let cf = self#read_field_ref c.cl_fields in *)
 				TField(e1,FClosure(Some(c,tl),cf))
 			| 106 ->
 				let e1 = self#read_texpr in
 				(* TODO (see writer) *)
 				(* TODO TField(e1,FClosure(None,cf)) *)
+				Printf.eprintf "  %s TField(e,FClosure(None,cf))\n" todo;
 				e1.eexpr
 			| 107 ->
 				let e1 = self#read_texpr in
 				let en = self#read_enum_ref in
-				let ef = self#read_enum_field_ref in
+				(* Printf.eprintf "  %s TField(_,FEnum)\n" todo; *)
+				let ef = self#read_enum_field_ref en in
 				TField(e1,FEnum(en,ef))
 			| 108 ->
 				let e1 = self#read_texpr in
@@ -577,10 +602,11 @@ class hxb_reader
 			| 123 -> TTypeExpr (TTypeDecl self#read_typedef_ref)
 			| 124 -> TCast(self#read_texpr,None)
 			| 125 ->
-				let e1 = self#read_texpr in
-				let path = self#read_path in
+				let _e1 = self#read_texpr in
+				let _path = self#read_path in
 				(* TODO retrieve md from path *)
 				(* TCast(e1,Some path) *)
+				Printf.eprintf "  %s TCast\n" todo;
 				assert false
 			| 126 ->
 				let c = self#read_class_ref in
@@ -740,7 +766,7 @@ class hxb_reader
 		| _ ->
 			type_type_parameters <- Array.of_list c.cl_params
 		end;
-		(* Printf.eprintf "  read class fields with type parameters for %s: %d\n" (snd c.cl_path) (Array.length type_type_parameters); *)
+		(* Printf.eprintf "  read class fields with type parameters for %s: %d\n" (s_type_path c.cl_path) (Array.length type_type_parameters); *)
 		(* Printf.eprintf "    own class params: %d\n" (List.length c.cl_params); *)
 		let _ = self#read_option (fun f ->
 			let _ = self#read_string in
@@ -756,14 +782,20 @@ class hxb_reader
 		()
 
 	method read_enum_fields (m : module_def) (e : tenum) =
-		let constrs = self#read_list16 (fun () ->
+		let _constrs = self#read_list16 (fun () ->
 			let name = self#read_string in
-			(* TODO read enum field *)
-			Printf.eprintf "  TODO read enum field %s\n" name;
-			()
+			Printf.eprintf "  Read enum field %s\n" name;
+			let ef = PMap.find name e.e_constrs in
+			self#read_type_parameters m ([],name) (fun a ->
+				field_type_parameters <- a
+			);
+			ef.ef_params <- Array.to_list field_type_parameters;
+			ef.ef_type <- self#read_type_instance;
+			(* TODO ef_doc *)
+			ef.ef_meta <- self#read_metadata;
 		) in
 		(* TODO set e_constrs *)
-		Printf.eprintf "  TODO set enum constructors for %s\n" (snd e.e_path);
+		Printf.eprintf "  %s set enum constructors for %s\n" todo (s_type_path e.e_path);
 		()
 
 	(* Module types *)
@@ -773,9 +805,9 @@ class hxb_reader
 		(* TODO: fix that *)
 		(* infos.mt_doc <- self#read_option (fun () -> self#read_documentation); *)
 		infos.mt_meta <- self#read_metadata;
-		(* Printf.eprintf "  read type parameters for %s\n" (snd infos.mt_path); *)
+		(* Printf.eprintf "  read type parameters for %s\n" (s_type_path infos.mt_path); *)
 		self#read_type_parameters m infos.mt_path (fun a ->
-			(* Printf.eprintf "  read type parameters for %s: %d\n" (snd infos.mt_path) (Array.length a); *)
+			(* Printf.eprintf "  read type parameters for %s: %d\n" (s_type_path infos.mt_path) (Array.length a); *)
 			type_type_parameters <- a
 		);
 		infos.mt_params <- Array.to_list type_type_parameters;
@@ -811,7 +843,7 @@ class hxb_reader
 			error (Printf.sprintf "Invalid class kind id: %i" i)
 
 	method read_class (m : module_def) (c : tclass) =
-		Printf.eprintf "  Read class %s\n" (snd c.cl_path);
+		Printf.eprintf "  Read class %s\n" (s_type_path c.cl_path);
 		self#read_common_module_type m (Obj.magic c);
 		c.cl_kind <- self#read_class_kind;
 		c.cl_flags <- (Int32.to_int self#read_u32);
@@ -824,21 +856,22 @@ class hxb_reader
 		c.cl_implements <- self#read_list16 read_relation;
 		c.cl_dynamic <- self#read_option (fun () -> self#read_type_instance);
 		c.cl_array_access <- self#read_option (fun () -> self#read_type_instance);
-		let read_field () =
-			let name = self#read_string in
-			let pos = self#read_pos in
-			let name_pos = self#read_pos in
-			(* TODO overloads *)
-			{ null_field with cf_name = name; cf_pos = pos; cf_name_pos = name_pos }
-		in
-		c.cl_constructor <- self#read_option read_field;
-		c.cl_ordered_fields <- self#read_list16 read_field;
-		c.cl_ordered_statics <- self#read_list16 read_field;
-		List.iter (fun cf -> c.cl_fields <- PMap.add cf.cf_name cf c.cl_fields) c.cl_ordered_fields;
-		List.iter (fun cf -> c.cl_statics <- PMap.add cf.cf_name cf c.cl_statics) c.cl_ordered_statics;
+		(* let read_field () = *)
+		(* 	let name = self#read_string in *)
+		(* 	let pos = self#read_pos in *)
+		(* 	let name_pos = self#read_pos in *)
+		(* 	(1* TODO overloads *1) *)
+		(* 	{ null_field with cf_name = name; cf_pos = pos; cf_name_pos = name_pos } *)
+		(* in *)
+		(* c.cl_constructor <- self#read_option read_field; *)
+		(* c.cl_ordered_fields <- self#read_list16 read_field; *)
+		(* c.cl_ordered_statics <- self#read_list16 read_field; *)
+		(* Printf.eprintf "   %d fields, %d statics\n" (List.length c.cl_ordered_fields) (List.length c.cl_ordered_statics); *)
+		(* List.iter (fun cf -> c.cl_fields <- PMap.add cf.cf_name cf c.cl_fields) c.cl_ordered_fields; *)
+		(* List.iter (fun cf -> c.cl_statics <- PMap.add cf.cf_name cf c.cl_statics) c.cl_ordered_statics; *)
 
 	method read_abstract (m : module_def) (a : tabstract) =
-		Printf.eprintf "  Read abstract %s\n" (snd a.a_path);
+		Printf.eprintf "  Read abstract %s\n" (s_type_path a.a_path);
 		self#read_common_module_type m (Obj.magic a);
 		a.a_impl <- self#read_option (fun () -> self#read_class_ref);
 		a.a_this <- self#read_type_instance;
@@ -849,11 +882,12 @@ class hxb_reader
 				field_type_parameters <- a
 			);
 			let t = self#read_type_instance in
-			Printf.eprintf "  Read field ref for abstract from field %s (a = %s)\n" name (snd a.a_path);
 			let impl = Option.get a.a_impl in
+			Printf.eprintf "  Read field ref for abstract from field %s (a = %s)\n" name (s_type_path a.a_path);
 			Printf.eprintf "   Impl has %d fields and %d statics\n" (List.length impl.cl_ordered_fields) (List.length impl.cl_ordered_statics);
 			(* let cf = self#read_field_ref (Option.get a.a_impl).cl_fields in *)
-			let cf = self#read_field_ref (Option.get a.a_impl).cl_statics in
+			let cf = self#read_field_ref (s_type_path impl.cl_path) impl.cl_statics in
+			(* let cf = self#read_field_ref (Option.get a.a_impl).cl_statics in *)
 			(t,cf)
 		);
 		a.a_to <- self#read_list16 (fun () -> self#read_type_instance);
@@ -863,25 +897,35 @@ class hxb_reader
 				field_type_parameters <- a
 			);
 			let t = self#read_type_instance in
-			Printf.eprintf "  Read field ref for abstract to field %s (a = %s)\n" name (snd a.a_path);
-			let cf = self#read_field_ref (Option.get a.a_impl).cl_fields in
+			let impl = Option.get a.a_impl in
+			Printf.eprintf "  Read field ref for abstract to field %s (a = %s)\n" name (s_type_path a.a_path);
+			Printf.eprintf "   Impl has %d fields and %d statics\n" (List.length impl.cl_ordered_fields) (List.length impl.cl_ordered_statics);
+			let cf = self#read_field_ref (s_type_path impl.cl_path) impl.cl_statics in
+			(* let cf = self#read_field_ref (s_type_path impl.cl_path) impl.cl_fields in *)
+			(* let cf = self#read_field_ref impl.cl_fields in *)
 			(t,cf)
 		);
-		a.a_array <- self#read_list16 (fun () -> self#read_field_ref (Option.get a.a_impl).cl_statics);
-		a.a_read <- self#read_option (fun () -> self#read_field_ref (Option.get a.a_impl).cl_fields);
-		a.a_write <- self#read_option (fun () -> self#read_field_ref (Option.get a.a_impl).cl_fields);
-		a.a_call <- self#read_option (fun () -> self#read_field_ref (Option.get a.a_impl).cl_fields);
+		a.a_array <- self#read_list16 (fun () -> self#read_field_ref "TODO" (Option.get a.a_impl).cl_statics);
+		a.a_read <- self#read_option (fun () -> self#read_field_ref "TODO" (Option.get a.a_impl).cl_fields);
+		a.a_write <- self#read_option (fun () -> self#read_field_ref "TODO" (Option.get a.a_impl).cl_fields);
+		a.a_call <- self#read_option (fun () -> self#read_field_ref "TODO" (Option.get a.a_impl).cl_fields);
 		a.a_enum <- self#read_bool;
 
 	method read_enum (m : module_def) (e : tenum) =
-		Printf.eprintf "  Read enum %s\n" (snd e.e_path);
+		Printf.eprintf "  Read enum %s\n" (s_type_path e.e_path);
 		self#read_common_module_type m (Obj.magic e);
-		e.e_type <- self#read_typedef_ref;
+		(* e.e_type <- self#read_typedef_ref; *)
+		let td_path = self#read_path in
+		let td_pos = self#read_pos in
+		let td_name_pos = self#read_pos in
+		let td = mk_typedef m td_path td_pos td_name_pos (mk_mono()) in
+		self#read_typedef m td;
+		e.e_type <- td;
 		e.e_extern <- self#read_bool;
 		e.e_names <- self#read_list16 (fun () -> self#read_string)
 
 	method read_typedef (m : module_def) (td : tdef) =
-		Printf.eprintf "  Read typedef %s\n" (snd td.t_path);
+		Printf.eprintf "  Read typedef %s\n" (s_type_path td.t_path);
 		self#read_common_module_type m (Obj.magic td);
 		td.t_type <- self#read_type_instance
 
@@ -948,15 +992,19 @@ class hxb_reader
 
 	method read_clsr =
 		let l = self#read_uleb128 in
+		(* Note: this shouldn't be necessary; trying to fix something with typedef ref *)
 		(* classes <- Array.append classes (Array.init l (fun i -> *)
+		(* let own = Array.length classes in *)
 		classes <- (Array.init l (fun i ->
-			let (pack,mname,tname) = self#read_full_path in
-			(* Printf.eprintf "  Read clsr %d of %d for %s.%s\n" i (l-1) mname tname; *)
-			match resolve_type pack mname tname with
-			| TClassDecl c ->
-				c
-			| _ ->
-				error ("Unexpected type where class was expected: " ^ (s_type_path (pack,tname)))
+				let (pack,mname,tname) = self#read_full_path in
+				Printf.eprintf "  Read clsr %d of %d for %s\n" i (l-1) (s_type_path ((pack @ [mname]),tname));
+				(* if i < own then classes.(i) else *)
+				match resolve_type pack mname tname with
+				| TClassDecl c ->
+						Printf.eprintf "  Resolved %d = %s with %d fields and %d statics\n" i (s_type_path c.cl_path) (List.length c.cl_ordered_fields) (List.length c.cl_ordered_statics);
+					c
+				| _ ->
+					error ("Unexpected type where class was expected: " ^ (s_type_path (pack,tname)))
 		))
 		(* classes <- self#read_list16 (fun () -> *)
 		(* 	let (pack,mname,tname) = self#read_full_path in *)
@@ -969,9 +1017,12 @@ class hxb_reader
 
 	method read_absr =
 		let l = self#read_uleb128 in
+		(* let own = Array.length abstracts in *)
 		abstracts <- (Array.init l (fun i ->
+		(* abstracts <- Array.append abstracts (Array.init l (fun i -> *)
 			let (pack,mname,tname) = self#read_full_path in
-			(* Printf.eprintf "  Read absr %d of %d for abstract %s\n" i l tname; *)
+			Printf.eprintf "  Read absr %d of %d for abstract %s\n" i l tname;
+			(* if i < own then abstracts.(i) else *)
 			match resolve_type pack mname tname with
 			| TAbstractDecl a ->
 				a
@@ -981,9 +1032,13 @@ class hxb_reader
 
 	method read_enmr =
 		let l = self#read_uleb128 in
+		(* let own = Array.length enums in *)
 		enums <- (Array.init l (fun i ->
+		(* enums <- Array.append enums (Array.init l (fun i -> *)
+		(* enums <- (Array.init l (fun i -> *)
 			let (pack,mname,tname) = self#read_full_path in
 			Printf.eprintf "  Read enmr %d of %d for enum %s\n" i l tname;
+			(* if i < own then enums.(i) else *)
 			match resolve_type pack mname tname with
 			| TEnumDecl en ->
 				en
@@ -993,9 +1048,13 @@ class hxb_reader
 
 	method read_tpdr =
 		let l = self#read_uleb128 in
+		(* let own = Array.length typedefs in *)
 		typedefs <- (Array.init l (fun i ->
+		(* typedefs <- Array.append typedefs (Array.init l (fun i -> *)
+		(* typedefs <- (Array.init l (fun i -> *)
 			let (pack,mname,tname) = self#read_full_path in
-			Printf.eprintf "  Read tpdr %d of %d for typedef %s.%s\n" i l mname tname;
+			Printf.eprintf "  Read tpdr %d of %d for typedef %s\n" i l (s_type_path ((pack @ [mname]), tname));
+			(* if i < own then typedefs.(i) else *)
 			match resolve_type pack mname tname with
 			| TTypeDecl tpd ->
 				tpd
@@ -1006,21 +1065,61 @@ class hxb_reader
 	method read_typf (m : module_def) =
 		self#read_list16 (fun () ->
 			let kind = self#read_u8 in
-			let path = self#read_path in
+			(* let path = self#read_path in *)
+			let (pack,mname,tname) = self#read_full_path in
+			let path = (pack, tname) in
+			(* let path = (pack @ [mname], tname) in *)
 			let pos = self#read_pos in
 			let name_pos = self#read_pos in
 			let mt = match kind with
 			| 0 ->
 				let c = mk_class m path pos name_pos in
+				classes <- Array.append classes (Array.make 1 c);
+
+				let read_field () =
+					let name = self#read_string in
+					let pos = self#read_pos in
+					let name_pos = self#read_pos in
+					(* TODO overloads *)
+					{ null_field with cf_name = name; cf_pos = pos; cf_name_pos = name_pos }
+				in
+
+				c.cl_constructor <- self#read_option read_field;
+				c.cl_ordered_fields <- self#read_list16 read_field;
+				c.cl_ordered_statics <- self#read_list16 read_field;
+				Printf.eprintf "  Forward declare %s with %d fields, %d statics\n" (s_type_path path) (List.length c.cl_ordered_fields) (List.length c.cl_ordered_statics);
+				List.iter (fun cf -> c.cl_fields <- PMap.add cf.cf_name cf c.cl_fields) c.cl_ordered_fields;
+				List.iter (fun cf -> c.cl_statics <- PMap.add cf.cf_name cf c.cl_statics) c.cl_ordered_statics;
+
 				TClassDecl c
 			| 1 ->
 				let en = mk_enum m path pos name_pos in
+				enums <- Array.append enums (Array.make 1 en);
+
+				let read_field () =
+					let name = self#read_string in
+					let pos = self#read_pos in
+					let name_pos = self#read_pos in
+					let index = self#read_u8 in
+
+					{ null_enum_field with
+						ef_name = name;
+						ef_pos = pos;
+						ef_name_pos = name_pos;
+						ef_index = index;
+					}
+				in
+
+				List.iter (fun ef -> en.e_constrs <- PMap.add ef.ef_name ef en.e_constrs) (self#read_list16 read_field);
 				TEnumDecl en
 			| 2 ->
 				let td = mk_typedef m path pos name_pos (mk_mono()) in
+				typedefs <- Array.append typedefs (Array.make 1 td);
 				TTypeDecl td
 			| 3 ->
 				let a = mk_abstract m path pos name_pos in
+				abstracts <- Array.append abstracts (Array.make 1 a);
+				(* TODO fields *)
 				TAbstractDecl a
 			| _ ->
 				error ("Invalid type kind: " ^ (string_of_int kind));

src/compiler/hxb/hxbWriter.ml

@@ -1,8 +1,8 @@
 open Globals
 open Ast
 open Type
-open Genshared
 open HxbData
+open Tanon_identification
 
 type field_source =
 	| ClassStatic of tclass
@@ -207,13 +207,14 @@ class ['a] hxb_writer
 	val typedefs = new pool
 	val abstracts = new pool
 
-	val fields = new pool
+	(* val fields = new pool *)
 
 	val own_classes = new pool
 	val own_abstracts = new pool
 	val own_enums = new pool
 	val own_typedefs = new pool
 
+	(* TODO *)
 	val anons = new pool
 
 	val type_param_lut = new pool
@@ -223,6 +224,7 @@ class ['a] hxb_writer
 	(* Chunks *)
 
 	method start_chunk (kind : chunk_kind) =
+		Printf.eprintf "Writing chunk %s\n" (string_of_chunk_kind kind);
 		let new_chunk = new chunk kind cp in
 		DynArray.add chunks new_chunk;
 		chunk <- new_chunk
@@ -276,7 +278,7 @@ class ['a] hxb_writer
 	method write_typedef_ref (td : tdef) =
 		(* chunk#write_uleb128 (typedefs#get_or_add td.t_path td) *)
 		let i = typedefs#get_or_add td.t_path td in
-		(* Printf.eprintf "  Write typedef ref %d for %s\n" i (snd td.t_path); *)
+		(* Printf.eprintf "  Write typedef ref %d for %s\n" i (s_type_path td.t_path); *)
 		chunk#write_uleb128 i
 
 	method write_abstract_ref (a : tabstract) =
@@ -290,7 +292,7 @@ class ['a] hxb_writer
 		chunk#write_string cf.cf_name
 
 	method write_enum_field_ref ef =
-		(* TODO: is this enough? :x *)
+		(* TODO -- enum ref should be written too *)
 		chunk#write_string ef.ef_name
 
 	(* Type instances *)
@@ -330,7 +332,26 @@ class ['a] hxb_writer
 			self#write_enum_ref en;
 		| TType(td,[]) ->
 			chunk#write_byte 12;
-			self#write_typedef_ref td;
+			begin match td.t_type with
+				| TAnon an ->
+					begin match !(an.a_status) with
+						| Statics c ->
+							chunk#write_byte 0;
+							self#write_class_ref c;
+						| EnumStatics en ->
+							chunk#write_byte 1;
+							self#write_enum_ref en;
+						| AbstractStatics a ->
+							chunk#write_byte 2;
+							self#write_abstract_ref a;
+						| _ ->
+							chunk#write_byte 3;
+							self#write_typedef_ref td;
+					end
+				| _ ->
+					chunk#write_byte 3;
+					self#write_typedef_ref td;
+			end;
 		| TAbstract(a,[]) ->
 			chunk#write_byte 13;
 			self#write_abstract_ref a;
@@ -344,6 +365,7 @@ class ['a] hxb_writer
 			self#write_types tl
 		| TType(td,tl) ->
 			chunk#write_byte 16;
+			(* Printf.eprintf "  TType %d for %s\n" 16 (s_type_path td.t_path); *)
 			self#write_typedef_ref td;
 			self#write_types tl
 		| TAbstract(a,tl) ->
@@ -372,6 +394,7 @@ class ['a] hxb_writer
 			let pfm = Option.get (anon_id#identify true t) in
 			chunk#write_byte 51;
 			chunk#write_uleb128 (anons#get_or_add pfm.pfm_path an)
+			(* TODO? *)
 			(* begin match !(an.a_status) with
 			| Closed -> chunk#write_byte 50
 			| Const -> chunk#write_byte 51
@@ -585,21 +608,27 @@ class ['a] hxb_writer
 			| TEnumIndex e1 ->
 				chunk#write_byte 100;
 				loop e1;
-			| TEnumParameter(e1,ef,i) ->
+			| TEnumParameter(e1,({ ef_type = TEnum(en,_) | TFun(_, TEnum(en,_)) } as ef),i) ->
 				chunk#write_byte 101;
 				loop e1;
+				self#write_enum_ref en;
 				self#write_enum_field_ref ef;
 				chunk#write_i32 i;
+			| TEnumParameter(e1,({ ef_type = eft}),i) ->
+				Printf.eprintf "en = %s\n" (s_type_kind eft);
+				assert false
 			| TField(e1,FInstance(c,tl,cf)) ->
 				chunk#write_byte 102;
 				loop e1;
 				self#write_class_ref c;
 				self#write_types tl;
+				(* Printf.eprintf "  TField %d for %s\n" 102 cf.cf_name; *)
 				self#write_field_ref (ClassMember c) cf; (* TODO check source *)
 			| TField(e1,FStatic(c,cf)) ->
 				chunk#write_byte 103;
 				loop e1;
 				self#write_class_ref c;
+				(* Printf.eprintf "  TField %d for %s\n" 103 cf.cf_name; *)
 				self#write_field_ref (ClassMember c) cf; (* TODO check source *)
 			| TField(e1,FAnon cf) ->
 				chunk#write_byte 104;
@@ -611,6 +640,7 @@ class ['a] hxb_writer
 				loop e1;
 				self#write_class_ref c;
 				self#write_types tl;
+				(* Printf.eprintf "  TField FClosure %d for %s.%s\n" 105 (snd c.cl_path) cf.cf_name; *)
 				self#write_field_ref (ClassMember c) cf; (* TODO check source *)
 			| TField(e1,FClosure(None,cf)) ->
 				chunk#write_byte 106;
@@ -638,6 +668,7 @@ class ['a] hxb_writer
 				self#write_abstract_ref a
 			| TTypeExpr (TTypeDecl td) ->
 				chunk#write_byte 123;
+				(* Printf.eprintf "  TTypeExpr %d for %s\n" 123 (s_type_path td.t_path); *)
 				self#write_typedef_ref td
 			| TCast(e1,None) ->
 				chunk#write_byte 124;
@@ -731,6 +762,7 @@ class ['a] hxb_writer
 
 	method write_class_field ?(with_pos = false) cf =
 		self#set_field_type_parameters cf.cf_params;
+		Printf.eprintf " Write class field %s\n" cf.cf_name;
 		chunk#write_string cf.cf_name;
 		chunk#write_list cf.cf_params self#write_type_parameter_forward;
 		chunk#write_list cf.cf_params self#write_type_parameter_data;
@@ -753,6 +785,7 @@ class ['a] hxb_writer
 		type_type_parameters <- type_param_lut#extract path
 
 	method write_common_module_type (infos : tinfos) : unit =
+		(* self#write_path infos.mt_path; *)
 		chunk#write_bool infos.mt_private;
 		(* TODO: fix that *)
 		(* chunk#write_option infos.mt_doc self#write_documentation; *)
@@ -813,15 +846,15 @@ class ['a] hxb_writer
 		);
 		chunk#write_option c.cl_dynamic self#write_type_instance;
 		chunk#write_option c.cl_array_access self#write_type_instance;
-		(* Write minimal data to be able to create refs *)
-		let write_field cf =
-			chunk#write_string cf.cf_name;
-			self#write_pos cf.cf_pos;
-			self#write_pos cf.cf_name_pos
-		in
-		chunk#write_option c.cl_constructor write_field;
-		chunk#write_list c.cl_ordered_fields write_field;
-		chunk#write_list c.cl_ordered_statics write_field;
+		(* (1* Write minimal data to be able to create refs *1) *)
+		(* let write_field cf = *)
+		(* 	chunk#write_string cf.cf_name; *)
+		(* 	self#write_pos cf.cf_pos; *)
+		(* 	self#write_pos cf.cf_name_pos *)
+		(* in *)
+		(* chunk#write_option c.cl_constructor write_field; *)
+		(* chunk#write_list c.cl_ordered_fields write_field; *)
+		(* chunk#write_list c.cl_ordered_statics write_field; *)
 
 	method write_abstract (a : tabstract) =
 		begin try
@@ -865,43 +898,58 @@ class ['a] hxb_writer
 		chunk#write_bool a.a_enum
 
 	method write_enum (e : tenum) =
+		Printf.eprintf "Write enum %s\n" (snd e.e_path);
 		self#select_type e.e_path;
 		self#write_common_module_type (Obj.magic e);
-		self#write_typedef_ref e.e_type;
+
+		(* Printf.eprintf "  Write typedef ref for %s\n" (snd e.e_type.t_path); *)
+		self#write_path e.e_type.t_path;
+		self#write_pos e.e_type.t_pos;
+		self#write_pos e.e_type.t_name_pos;
+		self#write_common_module_type (Obj.magic e.e_type);
+		self#write_type_instance e.e_type.t_type;
+		(* self#write_typedef_ref e.e_type; *)
+
 		chunk#write_bool e.e_extern;
 		chunk#write_list e.e_names chunk#write_string
 
 	method write_typedef (td : tdef) =
 		self#select_type td.t_path;
 		self#write_common_module_type (Obj.magic td);
-		self#write_type_instance td.t_type;
-		()
+		self#write_type_instance td.t_type
 
 	(* Module *)
 
 	method forward_declare_type (mt : module_type) =
+		let name = ref "" in
 		let i = match mt with
 		| TClassDecl c ->
 			ignore(classes#add c.cl_path c);
 			ignore(own_classes#add c.cl_path c);
+			name := snd c.cl_path;
 			0
 		| TEnumDecl e ->
 			ignore(enums#get_or_add e.e_path e);
 			ignore(own_enums#add e.e_path e);
+			name := snd e.e_path;
 			1
 		| TTypeDecl t ->
 			ignore(typedefs#get_or_add t.t_path t);
 			ignore(own_typedefs#add t.t_path t);
+			name := snd t.t_path;
 			2
 		| TAbstractDecl a ->
 			ignore(abstracts#add a.a_path a);
 			ignore(own_abstracts#add a.a_path a);
+			name := snd a.a_path;
 			3
 		in
+
 		let infos = t_infos mt in
-		Printf.eprintf "Forward declare type %s\n" (snd infos.mt_path);
+		Printf.eprintf "Forward declare type %s\n" (s_type_path infos.mt_path);
 		chunk#write_byte i;
-		self#write_path infos.mt_path;
+		(* self#write_path infos.mt_path; *)
+		self#write_full_path (fst infos.mt_path) (snd infos.mt_path) !name;
 		self#write_pos infos.mt_pos;
 		self#write_pos infos.mt_name_pos;
 		let params = new pool in
@@ -911,6 +959,31 @@ class ['a] hxb_writer
 			ignore(type_type_parameters#add ttp.ttp_name ttp);
 		) infos.mt_params;
 
+		(* Forward declare fields *)
+		match mt with
+		| TClassDecl c ->
+			(* Write minimal data to be able to create refs *)
+			let write_field cf =
+				chunk#write_string cf.cf_name;
+				self#write_pos cf.cf_pos;
+				self#write_pos cf.cf_name_pos
+			in
+			chunk#write_option c.cl_constructor write_field;
+			chunk#write_list c.cl_ordered_fields write_field;
+			chunk#write_list c.cl_ordered_statics write_field;
+		| TEnumDecl e ->
+				chunk#write_list (PMap.foldi (fun s f acc -> (s,f) :: acc) e.e_constrs []) (fun (s,ef) ->
+					Printf.eprintf "  forward declare enum field %s.%s\n" (s_type_path e.e_path) s;
+					chunk#write_string s;
+					self#write_pos ef.ef_pos;
+					self#write_pos ef.ef_name_pos;
+					chunk#write_byte ef.ef_index
+				);
+		| TAbstractDecl a ->
+				(* TODO *)
+				()
+		| TTypeDecl t -> ()
+
 	method write_module (m : module_def) =
 		self#start_chunk HHDR;
 		self#write_path m.m_path;
@@ -956,9 +1029,16 @@ class ['a] hxb_writer
 			chunk#write_list own_enums self#write_enum;
 			self#start_chunk EFLD;
 			chunk#write_list own_enums (fun e ->
-				chunk#write_list (PMap.foldi (fun s f acc -> (s,f) :: acc) e.e_constrs []) (fun (s,f) ->
+				(* TODO use to_list *)
+				chunk#write_list (PMap.foldi (fun s f acc -> (s,f) :: acc) e.e_constrs []) (fun (s,ef) ->
+					Printf.eprintf "  Write enum field %s.%s\n" (s_type_path e.e_path) s;
 					chunk#write_string s;
-					(* TODO write enum field *)
+					self#set_field_type_parameters ef.ef_params;
+					chunk#write_list ef.ef_params self#write_type_parameter_forward;
+					chunk#write_list ef.ef_params self#write_type_parameter_data;
+					self#write_type_instance ef.ef_type;
+					(* TODO ef_doc *)
+					self#write_metadata ef.ef_meta;
 				);
 			)
 		end;
@@ -1009,8 +1089,15 @@ class ['a] hxb_writer
 			self#start_chunk TPDR;
 			chunk#write_list l (fun td ->
 				let m = td.t_module in
-				Printf.eprintf "  [tpd] Write full path %s\n" (ExtString.String.join "." ((fst m.m_path) @ [(snd m.m_path); (snd td.t_path)]));
-				Printf.eprintf "  [tpd] Write full path %s\n" (ExtString.String.join "." ((fst td.t_path) @ [(snd td.t_path)]));
+				Printf.eprintf "  [tpdr] Write full path %s\n" (ExtString.String.join "." ((fst m.m_path) @ [(snd m.m_path); (snd td.t_path)]));
+				(* Printf.eprintf "  [tpdr] Write full path %s\n" (ExtString.String.join "." ((fst td.t_path) @ [(snd td.t_path)])); *)
+				(* match td.t_params with *)
+				(* | [] -> () *)
+				(* | params -> *)
+				(* 	List.iter (fun ttp -> *)
+				(* 		(1* ignore(type_type_parameters#add ttp.ttp_name ttp); *1) *)
+				(* 		Printf.eprintf "   [tpdr] type param %s %s\n" ttp.ttp_name (s_type_kind ttp.ttp_type); *)
+				(* 	) params; *)
 				self#write_full_path (fst m.m_path) (snd m.m_path) (snd td.t_path)
 			)
 		end;

src/core/tFunctions.ml

@@ -234,9 +234,16 @@ let null_enum = {
 }
 
 let null_field = mk_field "" t_dynamic null_pos null_pos
-(* TODO null_class_field *)
-(* TODO null_abstract_field *)
-(* TODO null_enum_field *)
+let null_enum_field = {
+	ef_name = "";
+	ef_type = TEnum (null_enum, []);
+	ef_pos = null_pos;
+	ef_name_pos = null_pos;
+	ef_doc = None;
+	ef_index = 0;
+	ef_params = [];
+	ef_meta = [];
+}
 
 let null_abstract = {
 	a_path = ([],"");

src/typing/typeload.ml

@@ -830,6 +830,7 @@ let load_core_class ctx c =
 			com2.class_path <- ctx.com.std_path;
 			if com2.display.dms_check_core_api then com2.display <- {com2.display with dms_check_core_api = false};
 			CommonCache.lock_signature com2 "load_core_class";
+			Printf.eprintf "=== Load core class ===\n";
 			let ctx2 = !create_context_ref com2 ctx.g.macros in
 			ctx.g.core_api <- Some ctx2;
 			ctx2

src/typing/typeloadFields.ml

@@ -1740,6 +1740,7 @@ let init_class ctx c p herits fields =
 	if cctx.is_class_debug then print_endline ("Created class context: " ^ dump_class_context cctx);
 	let fields = patch_class ctx c fields in
 	let fields = build_fields (ctx,cctx) c fields in
+	(* Triggers a second loading of many types.. *)
 	if cctx.is_core_api && ctx.com.display.dms_check_core_api then delay ctx PForce (fun() -> init_core_api ctx c);
 	if not cctx.is_lib then begin
 		delay ctx PForce (fun() -> check_overloads ctx c);

src/typing/typeloadModule.ml

@@ -797,36 +797,63 @@ let type_module ctx mpath file ?(dont_check_path=false) ?(is_extern=false) tdecl
 
 let type_module_hook = ref (fun _ _ _ -> None)
 
-let rec get_reader ctx input p =
-		let make_module path file = ModuleLevel.make_module ctx path file p in
-		let add_module m = ctx.com.module_lut#add m.m_path m in
+let indent = ref (-1)
+
+let rec get_reader ctx input mpath p =
+		let make_module path file =
+			Printf.eprintf "  \x1b[35m[typeloadModule]\x1b[0m make module %s\n" (s_type_path path);
+			ModuleLevel.make_module ctx path file p in
+
+		let add_module m =
+			Printf.eprintf "  \x1b[35m[typeloadModule]\x1b[0m add module %s = %s\n" (s_type_path m.m_path) (s_type_path mpath);
+			ctx.com.module_lut#add mpath m in
+			(* ctx.com.module_lut#add m.m_path m in *)
 
 		let resolve_type pack mname tname =
-			Printf.eprintf "  [typeloadModule] resolve type %s.%s\n" mname tname;
+			Printf.eprintf "  \x1b[35m[typeloadModule]\x1b[0m resolve type %s\n" (s_type_path ((pack @ [mname]),tname));
 			let m = try ctx.com.module_lut#find (pack,mname) with Not_found -> load_module' ctx ctx.g (pack,mname) p in
 			let t = List.find (fun t -> snd (t_path t) = tname) m.m_types in
-			Printf.eprintf "  [typeloadModule] resolved type %s.%s\n" mname tname;
+			Printf.eprintf "  \x1b[35m[typeloadModule]\x1b[0m resolved type %s\n" (s_type_path ((pack @ [mname]),tname));
 			t
 		in
 
 		new HxbReader.hxb_reader ctx.com input make_module add_module resolve_type
 
 and load_hxb_module ctx path p =
+	let mk_indent indent =
+		ExtLib.String.make (indent*2) ' '
+	in
+
+	(* if ctx.com.is_macro_context then raise Not_found; *)
+	if defined ctx.com Define.Macro then raise Not_found;
 	let l = ((Common.dump_path ctx.com) :: "hxb" :: (Common.platform_name_macro ctx.com) :: fst path @ [snd path]) in
 	let filepath = (List.fold_left (fun acc s -> acc ^ "/" ^ s) "." l) ^ ".hxb" in
 	let ch = try open_in_bin filepath with Sys_error _ -> raise Not_found in
 	let input = IO.input_channel ch in
 
-	Printf.eprintf "Loading %s from %s...\n" (snd path) filepath;
-	let m = (get_reader ctx input p)#read true p in
-	close_in ch;
-	Printf.eprintf "Loaded %s from %s\n" (snd m.m_path) filepath;
-	m
+	indent := !indent + 1;
+	Printf.eprintf "%s\x1b[44m>> Loading %s from %s...\x1b[0m\n" (mk_indent !indent) (snd path) filepath;
+	try
+		let m = (get_reader ctx input path p)#read true p in
+		Printf.eprintf "%s\x1b[44m<< Loaded %s from %s\x1b[0m\n" (mk_indent !indent) (snd m.m_path) filepath;
+		indent := !indent - 1;
+		close_in ch;
+		m
+	with e ->
+		Printf.eprintf "%s\x1b[44m<< Error loading %s from %s\x1b[0m\n" (mk_indent !indent) (snd path) filepath;
+		let msg = Printexc.to_string e and stack = Printexc.get_backtrace () in
+		Printf.eprintf "%s => %s\n%s\n" (mk_indent !indent) msg stack;
+		indent := !indent - 1;
+		close_in ch;
+		raise e
 
 and load_module' ctx g m p =
+	Printf.eprintf "\x1b[45m[typeloadModule]\x1b[0m Load module %s\n" (s_type_path m);
 	try
 		(* Check current context *)
-		ctx.com.module_lut#find m
+		let m = ctx.com.module_lut#find m in
+		Printf.eprintf "\x1b[44m-- Retrieved %s from cache\x1b[0m\n" (snd m.m_path);
+		m
 	with Not_found ->
 		(* Check cache *)
 		match !type_module_hook ctx m p with

src/typing/typer.ml

@@ -2094,6 +2094,7 @@ let create com macros =
 		memory_marker = Typecore.memory_marker;
 	} in
 	ctx.g.std <- (try
+		Printf.eprintf "=== Load Std ===\n";
 		TypeloadModule.load_module ctx ([],"StdTypes") null_pos
 	with
 		Error { err_message = Module_not_found ([],"StdTypes") } ->