had_parser_resume

src/compiler/server.ml

@@ -57,12 +57,12 @@ let parse_file cs com (rfile : ClassPaths.resolved_file) p =
 			try
 				let cfile = cc#find_file fkey in
 				if cfile.c_time <> ftime then raise Not_found;
-				Parser.ParseSuccess((cfile.c_package,cfile.c_decls),false,cfile.c_pdi)
+				Parser.ParseSuccess((cfile.c_package,cfile.c_decls),cfile.c_pdi)
 			with Not_found ->
 				let parse_result = TypeloadParse.parse_file com rfile p in
 				let info,is_unusual = match parse_result with
 					| ParseError(_,_,_) -> "not cached, has parse error",true
-					| ParseSuccess(data,is_display_file,pdi) ->
+					| ParseSuccess(data,pdi) ->
 						if is_display_file then begin
 							if pdi.pd_errors <> [] then
 								"not cached, is display file with parse errors",true

src/context/common.ml

@@ -251,6 +251,7 @@ type context = {
 	mutable package_rules : (string,package_rule) PMap.t;
 	mutable report_mode : report_mode;
 	mutable was_auto_triggered : bool;
+	mutable had_parser_resume : bool;
 	(* communication *)
 	mutable print : string -> unit;
 	mutable error : Gctx.error_function;
@@ -772,6 +773,7 @@ let create timer_ctx compilation_step cs version args display_mode =
 		hxb_reader_stats = HxbReader.create_hxb_reader_stats ();
 		hxb_writer_config = None;
 		was_auto_triggered = false;
+		had_parser_resume = false;
 	} in
 	com
 

src/context/formatString.ml

@@ -84,7 +84,7 @@ let format_string config s p process_expr =
 					else Error.raise_typing_error msg pos
 				in
 				match ParserEntry.parse_expr_string config scode ep error true with
-					| ParseSuccess(data,_,_) -> data
+					| ParseSuccess(data,_) -> data
 					| ParseError(_,(msg,p),_) -> error (Parser.error_msg msg) p
 			in
 			add_expr e slen

src/macro/eval/evalDebugMisc.ml

@@ -81,7 +81,7 @@ exception Parse_expr_error of string
 let parse_expr ctx config s p =
 	let error s = raise (Parse_expr_error s) in
 	match ParserEntry.parse_expr_string config s p error true with
-	| ParseSuccess(data,_,_) -> data
+	| ParseSuccess(data,_) -> data
 	| ParseError(_,(msg,_),_) -> error (Parser.error_msg msg)
 
 (* Vars *)

src/syntax/grammar.ml

@@ -1291,26 +1291,26 @@ and inline_function = function%parser
 
 and parse_macro_expr ctx p = function%parser
 	| [ (DblDot,_); [%let t = parse_complex_type ctx] ] ->
-		let _, to_type, _  = reify !in_macro in
+		let _, to_type, _  = reify ctx.in_macro in
 		let t = to_type t p in
 		let ct = make_ptp_ct_null (mk_type_path ~sub:"ComplexType" (["haxe";"macro"],"Expr")) in
 		(ECheckType (t,(ct,p)),p)
 	| [ (Kwd Var,p1); [%let vl = psep Comma (parse_var_decl ctx false)] ] ->
-		reify_expr (EVars vl,p1) !in_macro
+		reify_expr (EVars vl,p1) ctx.in_macro
 	| [ (Kwd Final,p1); [%s s] ] ->
 		check_redundant_var ctx p1 s;
 		begin match%parser s with
 		| [ [%let vl = psep Comma (parse_var_decl ctx true)] ] ->
-			reify_expr (EVars vl,p1) !in_macro
+			reify_expr (EVars vl,p1) ctx.in_macro
 		| [ ] ->
 			serror()
 		end
 	| [ [%let d = parse_class ctx None [] [] false] ] ->
-		let _,_,to_type = reify !in_macro in
+		let _,_,to_type = reify ctx.in_macro in
 		let ct = make_ptp_ct_null (mk_type_path ~sub:"TypeDefinition" (["haxe";"macro"],"Expr")) in
 		(ECheckType (to_type d,(ct,null_pos)),p)
 	| [ [%let e = secure_expr ctx] ] ->
-		reify_expr e !in_macro
+		reify_expr e ctx.in_macro
 
 and parse_function ctx p1 inl s =
 	let name = match%parser s with

src/syntax/parser.ml

@@ -82,6 +82,8 @@ type parser_ctx = {
 	lexer_ctx : Lexer.lexer_ctx;
 	syntax_errors : (error_msg * pos) list ref;
 	last_doc : (string * int) option ref;
+	in_macro : bool;
+	mutable had_resume : bool;
 	config : parser_config;
 }
 
@@ -111,18 +113,22 @@ type parser_display_information = {
 	pd_errors : parse_error list;
 	pd_dead_blocks : (pos * expr) list;
 	pd_conditions : expr list;
+	pd_was_display_file : bool;
+	pd_had_resume : bool;
 }
 
 type 'a parse_result =
 	(* Parsed non-display-file without errors. *)
-	| ParseSuccess of 'a * bool * parser_display_information
+	| ParseSuccess of 'a * parser_display_information
 	(* Parsed non-display file with errors *)
 	| ParseError of 'a * parse_error * parse_error list
 
-let create_context lexer_ctx config = {
+let create_context lexer_ctx config in_macro = {
 	lexer_ctx;
 	syntax_errors = ref [];
 	last_doc = ref None;
+	in_macro;
+	had_resume = false;
 	config;
 }
 
@@ -180,15 +186,11 @@ let next_pos ctx s = pos (next_token ctx s)
 
 (* Global state *)
 
-let in_macro = ref false
-let had_resume = ref false
 let code_ref = ref (Sedlexing.Utf8.from_string "")
 let delayed_syntax_completion : (syntax_completion * DisplayTypes.completion_subject) option ref = ref None
 
 let reset_state () =
 	display_position#reset;
-	in_macro := false;
-	had_resume := false;
 	code_ref := Sedlexing.Utf8.from_string "";
 	delayed_syntax_completion := None
 
@@ -380,7 +382,7 @@ let is_signature_display ctx =
 
 let check_resume ctx p fyes fno =
 	if is_completion ctx && ctx.config.in_display_file && p.pmax = (display_position#get).pmin then begin
-		had_resume := true;
+		ctx.had_resume <- true;
 		fyes()
 	end else
 		fno()

src/syntax/parserEntry.ml

@@ -210,21 +210,19 @@ end
 
 (* parse main *)
 let parse config entry lctx code file =
-	let ctx = Parser.create_context lctx config in
 	let defines = config.defines in
+	let in_macro = Define.defined defines Define.Macro in
+	let ctx = Parser.create_context lctx config in_macro in
 	let entry = entry ctx in
 	let restore_cache = TokenCache.clear () in
 	let old_code = !code_ref in
-	let old_macro = !in_macro in
 	code_ref := code;
 	let restore =
 		(fun () ->
 			restore_cache ();
-			in_macro := old_macro;
 			code_ref := old_code;
 		)
 	in
-	in_macro := Define.defined defines Define.Macro;
 	Lexer.skip_header code;
 
 	let sharp_error s p =
@@ -359,11 +357,17 @@ let parse config entry lctx code file =
 		end;
 		let was_display_file = ctx.config.in_display_file in
 		restore();
-		let pdi = {pd_errors = List.rev !(ctx.syntax_errors);pd_dead_blocks = dbc#get_dead_blocks;pd_conditions = conds#get_conditions} in
+		let pdi = {
+			pd_errors = List.rev !(ctx.syntax_errors);
+			pd_dead_blocks = dbc#get_dead_blocks;
+			pd_conditions = conds#get_conditions;
+			pd_was_display_file = was_display_file;
+			pd_had_resume = ctx.had_resume;
+		} in
 		if was_display_file then
-			ParseSuccess(l,true,pdi)
+			ParseSuccess(l,pdi)
 		else begin match List.rev !(ctx.syntax_errors) with
-			| [] -> ParseSuccess(l,false,pdi)
+			| [] -> ParseSuccess(l,pdi)
 			| error :: errors -> ParseError(l,error,errors)
 		end
 	with
@@ -416,6 +420,6 @@ let parse_expr_string config s p error inl =
 			(fst e,p)
 		in
 		match result with
-		| ParseSuccess(data,is_display_file,pdi) -> ParseSuccess(loop data,is_display_file,pdi)
+		| ParseSuccess(data,pdi) -> ParseSuccess(loop data,pdi)
 		| ParseError(data,error,errors) -> ParseError(loop data,error,errors)
 	end

src/typing/macroContext.ml

@@ -99,7 +99,7 @@ let make_macro_com_api com mcom p =
 	let parse_metadata s p =
 		try
 			match ParserEntry.parse_string (ParserConfig.default_config com.defines) Grammar.parse_meta s null_pos raise_typing_error false with
-			| ParseSuccess(meta,_,_) -> meta
+			| ParseSuccess(meta,_) -> meta
 			| ParseError(_,_,_) -> raise_typing_error "Malformed metadata string" p
 		with _ ->
 			raise_typing_error "Malformed metadata string" p
@@ -169,8 +169,8 @@ let make_macro_com_api com mcom p =
 
 			try
 				let r = match ParserEntry.parse_expr_string (ParserConfig.file_parser_config com p.pfile) s p raise_typing_error inl with
-					| ParseSuccess(data,true,_) when inl -> data (* ignore errors when inline-parsing in display file *)
-					| ParseSuccess(data,_,_) -> data
+					| ParseSuccess(data,{pd_was_display_file = true}) when inl -> data (* ignore errors when inline-parsing in display file *)
+					| ParseSuccess(data,_) -> data
 					| ParseError _ -> Interp.exc_string "Invalid expression"
 				in
 				exit();
@@ -187,7 +187,7 @@ let make_macro_com_api com mcom p =
 		);
 		parse = (fun entry s ->
 			match ParserEntry.parse_string (ParserConfig.default_config com.defines) entry s null_pos raise_typing_error false with
-			| ParseSuccess(r,_,_) -> r
+			| ParseSuccess(r,_) -> r
 			| ParseError(_,(msg,p),_) -> Parser.error msg p
 		);
 		register_file_contents = (fun file content ->
@@ -302,7 +302,7 @@ let make_macro_api ctx mctx p =
 	let parse_metadata s p =
 		try
 			match ParserEntry.parse_string (ParserConfig.default_config mctx.com.defines) Grammar.parse_meta s null_pos raise_typing_error false with
-			| ParseSuccess(meta,_,_) -> meta
+			| ParseSuccess(meta,_) -> meta
 			| ParseError(_,_,_) -> raise_typing_error "Malformed metadata string" p
 		with _ ->
 			raise_typing_error "Malformed metadata string" p
@@ -1028,7 +1028,7 @@ let resolve_init_macro com e =
 	let e = try
 		if String.get e (String.length e - 1) = ';' then raise_typing_error "Unexpected ;" p;
 		begin match ParserEntry.parse_expr_string (ParserConfig.default_config com.defines) e p raise_typing_error false with
-		| ParseSuccess(data,_,_) -> data
+		| ParseSuccess(data,_) -> data
 		| ParseError(_,(msg,p),_) -> (Parser.error msg p)
 		end
 	with err ->

src/typing/typeloadFunction.ml

@@ -63,7 +63,7 @@ let type_function ctx (args : function_arguments) ret e do_display p =
 	end else begin
 		let is_display_debug = Meta.has (Meta.Custom ":debug.display") ctx.f.curfield.cf_meta in
 		if is_display_debug then print_endline ("before processing:\n" ^ (Expr.dump_with_pos e));
-		let e = if !Parser.had_resume then e else Display.preprocess_expr ctx.com e in
+		let e = if ctx.com.had_parser_resume then e else Display.preprocess_expr ctx.com e in
 		if is_display_debug then print_endline ("after processing:\n" ^ (Expr.dump_with_pos e));
 		type_expr ctx e NoValue
 	end in

src/typing/typeloadModule.ml

@@ -294,7 +294,7 @@ module ModuleLevel = struct
 			with Not_found ->
 				if Sys.file_exists path then begin
 					let _,r = match !TypeloadParse.parse_hook com (ClassPaths.create_resolved_file path com.empty_class_path) p with
-						| ParseSuccess(data,_,_) -> data
+						| ParseSuccess(data,_) -> data
 						| ParseError(_,(msg,p),_) -> Parser.error msg p
 					in
 					List.iter (fun (d,p) -> match d with EImport _ | EUsing _ -> () | _ -> raise_typing_error "Only import and using is allowed in import.hx files" p) r;

src/typing/typeloadParse.ml

@@ -42,9 +42,11 @@ let parse_file_from_lexbuf com file p lexbuf =
 	in
 	begin match com.display.dms_kind,parse_result with
 		| DMModuleSymbols (Some ""),_ -> ()
-		| DMModuleSymbols filter,(ParseSuccess(data,_,_)) when filter = None && DisplayPosition.display_position#is_in_file (com.file_keys#get file) ->
+		| DMModuleSymbols filter,(ParseSuccess(data,_)) when filter = None && DisplayPosition.display_position#is_in_file (com.file_keys#get file) ->
 			let ds = DocumentSymbols.collect_module_symbols None (filter = None) data in
 			DisplayException.raise_module_symbols (DocumentSymbols.Printer.print_module_symbols com [file,ds] filter);
+		| _,ParseSuccess(_,{pd_had_resume = true}) ->
+			com.had_parser_resume <- true
 		| _ ->
 			()
 	end;
@@ -123,7 +125,7 @@ let resolve_module_file com m remap p =
 			| [] -> []
 		in
 		let meta = match parse_result with
-			| ParseSuccess((_,decls),_,_) -> loop decls
+			| ParseSuccess((_,decls),_) -> loop decls
 			| ParseError _ -> []
 		in
 		if not (Meta.has Meta.NoPackageRestrict meta) then begin
@@ -268,8 +270,8 @@ let handle_parser_result com p result =
 				com.has_error <- true
 	in
 	match result with
-		| ParseSuccess(data,is_display_file,pdi) ->
-			if is_display_file then begin
+		| ParseSuccess(data,pdi) ->
+			if pdi.pd_was_display_file then begin
 				begin match pdi.pd_errors with
 				| (msg,p) :: _ -> handle_parser_error msg p
 				| [] -> ()

src/typing/typerDisplay.ml

@@ -491,7 +491,7 @@ and display_expr ctx e_ast e dk mode with_type p =
 		raise_positions pl
 	| DMTypeDefinition ->
 		raise_position_of_type ctx e.etype
-	| DMDefault when not (!Parser.had_resume)->
+	| DMDefault when not ctx.com.had_parser_resume ->
 		let display_fields e_ast e1 so =
 			let l = match so with None -> 0 | Some s -> String.length s in
 			let fields = DisplayFields.collect ctx e_ast e1 dk with_type p in