Add hh --log-errors

Summary:
Added a new `--log-errors` mode to the Hack client that allows typechecking files and logging their errors to either as an event or a file. The implementation uses a fire-and-forget pattern where the client receives an immediate response before the actual typechecking work completes on the server, improving responsiveness. The new mode accepts `--log-errors` to enable logging and optionally `--log-to-file <path>` to write errors to a file instead of logging an event.

To support the fire-and-forget behavior, I added a `handle_after_send` mechanism in `ServerCommandTypes` that allows specific RPC commands to send a response immediately and then continue processing. The `LOG_ERRORS` command uses this to return unit to the client right away, then performs the typechecking and logging asynchronously.

The implementation reuses `ServerStatusSingle.go` for typechecking individual files and respects error filtering and warning configuration just like the existing `--single` mode. Error serialization is handled in `ServerLogErrors` which produces telemetry with full diagnostic information.

Reviewed By: vassilmladenov

Differential Revision: D86486434

fbshipit-source-id: 0b1c38bc28d5f2d69b6bacb7d5a996b36dcd1f43

Author: dlreeves

hphp/hack/src/client/clientArgs.ml

@@ -178,6 +178,8 @@ let parse_check_args cmd ~from_default : ClientEnv.client_check_env =
 
   let set_from x () = from := x in
   let single_files = ref [] in
+  let only_log_errors = ref false in
+  let log_to_file = ref None in
   let set_mode ?(validate = true) x =
     if validate && Option.is_some !mode then
       raise (Arg.Bad "only a single mode should be specified")
@@ -188,6 +190,7 @@ let parse_check_args cmd ~from_default : ClientEnv.client_check_env =
     end
   in
   let add_single x = single_files := x :: !single_files in
+  let set_log_to_file x = log_to_file := Some x in
   let add_multi f =
     let files =
       Sys_utils.read_file f
@@ -213,6 +216,9 @@ let parse_check_args cmd ~from_default : ClientEnv.client_check_env =
           (MODE_STATUS_SINGLE
              { filenames = single_files; show_tast; preexisting_warnings }))
   in
+  let set_mode_only_log_errors config =
+    if !only_log_errors then set_mode (MODE_LOG_ERRORS config)
+  in
   let find_my_tests_max_distance = ref 1 in
   (* parse args *)
   let usage =
@@ -684,6 +690,14 @@ rewrite to the function names to something like `foo_1` and `foo_2`.
         Arg.String add_multi,
         "<path> Return errors for files read from the given file (one per line)"
       );
+      ( "--log-errors",
+        Arg.Unit (fun () -> only_log_errors := true),
+        " (mode) type check the given list of files and log their errors (use --log-to-file to specify output file)"
+      );
+      ( "--log-to-file",
+        Arg.String set_log_to_file,
+        "<path> Write logged errors to specified file (use with --log-errors)"
+      );
       ( "--show-tast",
         Arg.Unit (fun () -> show_tast := true),
         " in combination with `--single`, output the TASTs of the file along with TAST hashes."
@@ -816,12 +830,15 @@ rewrite to the function names to something like `foo_1` and `foo_2`.
   );
 
   set_mode_from_single_files !show_tast !preexisting_warnings;
+  set_mode_only_log_errors
+    { log_file = !log_to_file; preexisting_warnings = !preexisting_warnings };
   let mode = Option.value !mode ~default:MODE_STATUS in
   (* fixups *)
   let (root, paths) =
     match (mode, args) with
     | (MODE_LINT, _)
-    | (MODE_FILE_LEVEL_DEPENDENCIES, _) ->
+    | (MODE_FILE_LEVEL_DEPENDENCIES, _)
+    | (MODE_LOG_ERRORS _, _) ->
       (Wwwroot.interpret_command_line_root_parameter [], args)
     | (_, _) -> (Wwwroot.interpret_command_line_root_parameter args, [])
   in

hphp/hack/src/client/clientCheck.ml

@@ -388,6 +388,20 @@ let main_internal
         ~max_errors:args.max_errors
     in
     Lwt.return (exit_status, telemetry)
+  | ClientEnv.MODE_LOG_ERRORS { log_file; preexisting_warnings; _ } ->
+    let files = filter_real_paths ~allow_directories:false args.paths in
+    let error_filter =
+      Filter_errors.Filter.make
+        ~default_all:local_config.warnings_default_all
+        ~generated_files:(ServerConfig.warnings_generated_files config)
+        args.warning_switches
+    in
+    let%lwt ((), telemetry) =
+      rpc args
+      @@ ServerCommandTypes.LOG_ERRORS
+           { files; log_file; error_filter; preexisting_warnings }
+    in
+    Lwt.return (Exit_status.No_error, telemetry)
   | ClientEnv.MODE_LIST_FILES ->
     let%lwt (infol, telemetry) =
       rpc args @@ ServerCommandTypes.LIST_FILES_WITH_ERRORS

hphp/hack/src/client/clientEnv.ml

@@ -19,6 +19,11 @@ type status_single = {
   preexisting_warnings: bool;
 }
 
+type log_errors_params = {
+  log_file: string option;
+  preexisting_warnings: bool;
+}
+
 type client_mode =
   | MODE_CST_SEARCH of string list option
   | MODE_DUMP_SYMBOL_INFO of string
@@ -63,6 +68,7 @@ type client_mode =
   | MODE_STATS
   | MODE_STATUS
   | MODE_STATUS_SINGLE of status_single
+  | MODE_LOG_ERRORS of log_errors_params
   | MODE_TYPE_AT_POS of string
   | MODE_TYPE_AT_POS_BATCH of string list
   | MODE_TYPE_ERROR_AT_POS of string

hphp/hack/src/client_and_server/serverCommandTypes.ml

@@ -357,6 +357,13 @@ type _ t =
       -> ((Errors.finalized_error list * int)
          * Tast.program Tast_with_dynamic.t Relative_path.Map.t option)
          t
+  | LOG_ERRORS : {
+      files: string list;
+      log_file: string option;
+      error_filter: Filter_errors.Filter.t;
+      preexisting_warnings: bool;
+    }
+      -> unit t
   | INFER_TYPE :
       file_input * File_content.Position.t
       -> InferAtPosService.result t
@@ -490,6 +497,7 @@ let rpc_command_needs_full_check : type a. a t -> bool =
   | NO_PRECHECKED_FILES -> true
   | STATS -> false
   | STATUS_SINGLE _ -> false
+  | LOG_ERRORS _ -> false
   | INFER_TYPE _ -> false
   | INFER_TYPE_BATCH _ -> false
   | INFER_TYPE_ERROR _ -> false
@@ -516,3 +524,9 @@ let rpc_command_needs_full_check : type a. a t -> bool =
 
 let use_priority_pipe (command : 'result t) : bool =
   not (rpc_command_needs_full_check command)
+
+let handle_after_send : type a. a t -> (a * unit t) option =
+ fun cmd ->
+  match cmd with
+  | LOG_ERRORS _ -> Some ((), cmd)
+  | _ -> None

hphp/hack/src/client_and_server/serverCommandTypesUtils.ml

@@ -4,6 +4,7 @@ open ServerCommandTypes
 let debug_describe_t : type a. a t -> string = function
   | STATUS _ -> "STATUS"
   | STATUS_SINGLE _ -> "STATUS_SINGLE"
+  | LOG_ERRORS _ -> "LOG_ERRORS"
   | INFER_TYPE _ -> "INFER_TYPE"
   | INFER_TYPE_BATCH _ -> "INFER_TYPE_BATCH"
   | INFER_TYPE_ERROR _ -> "INFER_TYPE_ERROR"

hphp/hack/src/server/dune

@@ -67,6 +67,7 @@
   serverInvalidateUnits
   serverIsSubtype
   serverLint
+  serverLogErrors
   serverMethodJumps
   serverMethodJumpsBatch
   serverRage

hphp/hack/src/server/serverCommand.ml

@@ -53,7 +53,7 @@ let actually_handle genv client msg full_recheck_needed ~is_stale env =
     ~key:Connection_tracker.Server_done_full_recheck
     ~long_delay_okay:true;
 
-  let (_metadata, cmd) = msg in
+  let (metadata, cmd) = msg in
   ClientProvider.ping client;
   let t_start = Unix.gettimeofday () in
   ClientProvider.track
@@ -62,30 +62,40 @@ let actually_handle genv client msg full_recheck_needed ~is_stale env =
     ~time:t_start;
   Sys_utils.start_gc_profiling ();
   Full_fidelity_parser_profiling.start_profiling ();
-
-  let (new_env, response) =
-    try ServerRpc.handle ~is_stale genv env cmd with
-    | exn ->
-      let e = Exception.wrap exn in
-      raise (Nonfatal_rpc_exception (e, env))
+  let handle_request cmd =
+    let result =
+      try ServerRpc.handle ~is_stale genv env metadata cmd with
+      | exn ->
+        let e = Exception.wrap exn in
+        raise (Nonfatal_rpc_exception (e, env))
+    in
+
+    let parsed_files = Full_fidelity_parser_profiling.stop_profiling () in
+    ClientProvider.track
+      client
+      ~key:Connection_tracker.Server_end_handle
+      ~log:true;
+    let (major_gc_time, minor_gc_time) = Sys_utils.get_gc_time () in
+    HackEventLogger.handled_command
+      (ServerCommandTypesUtils.debug_describe_t cmd)
+      ~start_t:t_start
+      ~major_gc_time
+      ~minor_gc_time
+      ~parsed_files;
+    result
   in
 
-  let parsed_files = Full_fidelity_parser_profiling.stop_profiling () in
-  ClientProvider.track
-    client
-    ~key:Connection_tracker.Server_end_handle
-    ~log:true;
-  let (major_gc_time, minor_gc_time) = Sys_utils.get_gc_time () in
-  HackEventLogger.handled_command
-    (ServerCommandTypesUtils.debug_describe_t cmd)
-    ~start_t:t_start
-    ~major_gc_time
-    ~minor_gc_time
-    ~parsed_files;
-
-  ClientProvider.send_response_to_client client response;
-  ClientProvider.shutdown_client client;
-  new_env
+  match ServerCommandTypes.handle_after_send cmd with
+  | None ->
+    let (new_env, response) = handle_request cmd in
+    ClientProvider.send_response_to_client client response;
+    ClientProvider.shutdown_client client;
+    new_env
+  | Some (response, post_send_cmd) ->
+    ClientProvider.send_response_to_client client response;
+    ClientProvider.shutdown_client client;
+    let (new_env, ()) = handle_request post_send_cmd in
+    new_env
 
 let handle
     (genv : ServerEnv.genv)

hphp/hack/src/server/serverLogErrors.ml

@@ -0,0 +1,102 @@
+(*
+ * Copyright (c) 2018, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the "hack" directory of this source tree.
+ *
+ *)
+open Hh_prelude
+open Option.Monad_infix
+
+let go
+    (workers : MultiWorker.worker list option)
+    (env : ServerEnv.env)
+    (files : string list)
+    (error_filter : Filter_errors.Filter.t)
+    (preexisting_warnings : bool) : Telemetry.t =
+  let file_names =
+    List.map files ~f:(fun filename -> ServerCommandTypes.FileName filename)
+  in
+
+  let ctx = Provider_utils.ctx_from_server_env env in
+
+  let tast_error_filter =
+    {
+      Tast_provider.ErrorFilter.error_filter;
+      warnings_saved_state =
+        ServerEnv.(env.init_env.mergebase_warning_hashes)
+        >>= Option.some_if (not preexisting_warnings);
+    }
+  in
+
+  let (errors, _tasts) =
+    ServerStatusSingle.go
+      workers
+      file_names
+      ctx
+      ~return_expanded_tast:false
+      ~error_filter:tast_error_filter
+  in
+
+  (* Define error JSON serialization function.
+     This differs from `hh --json` to align with the information sent to VSCode
+     (similar structure, though not identical). The `hh --json` format includes
+     unnecessary extra fields that aren't needed for this use case. *)
+  let error_to_json : Errors.error -> Hh_json.json =
+   fun err ->
+    let {
+      User_error.severity;
+      code = _;
+      claim = (pos, claim_msg);
+      reasons;
+      explanation = _;
+      custom_msgs;
+      quickfixes = _;
+      is_fixmed = _;
+      function_pos = _;
+    } =
+      User_error.to_absolute err
+    in
+    let msg_to_json msg =
+      Hh_json.string_ @@ Markdown_lite.render ~add_bold:false msg
+    in
+    let reason_to_json (pos, msg) =
+      Hh_json.JSON_Object
+        [("location", Pos.multiline_json pos); ("message", msg_to_json msg)]
+    in
+    Hh_json.JSON_Object
+      [
+        ( "severity",
+          Hh_json.string_ @@ User_error.Severity.to_all_caps_string severity );
+        ("range", Pos.multiline_json_no_filename pos);
+        ("message", msg_to_json claim_msg);
+        ("relatedInformation", Hh_json.array_ reason_to_json reasons);
+        ("customErrors", Hh_json.array_ msg_to_json custom_msgs);
+        ( "lineAgnosticHash",
+          Hh_json.string_
+          @@ Printf.sprintf "%x" (User_error.hash_error_for_saved_state err) );
+      ]
+  in
+  let errors = Errors.drop_fixmed_errors_in_files errors in
+  let file_to_errors = Errors.as_map errors in
+  let file_to_error_json =
+    Relative_path.Map.map ~f:(List.map ~f:error_to_json) file_to_errors
+  in
+  let compute_file_telemetry fn =
+    let relpath = Relative_path.create_detect_prefix fn in
+    Telemetry.create ()
+    |> Telemetry.string_
+         ~key:"filename"
+         ~value:(Relative_path.to_absolute relpath)
+    |> Telemetry.json_
+         ~key:"diagnostics"
+         ~value:
+           (Hh_json.JSON_Array
+              (Relative_path.Map.find_opt file_to_error_json relpath
+              |> Option.value ~default:[]))
+  in
+  Telemetry.create ()
+  |> Telemetry.object_list
+       ~key:"errors"
+       ~value:(List.map files ~f:compute_file_telemetry)

hphp/hack/src/server/serverLogErrors.mli

@@ -0,0 +1,17 @@
+(*
+ * Copyright (c) 2018, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the "hack" directory of this source tree.
+ *
+ *)
+
+(** Type check files and generate Telemetry with error diagnostics *)
+val go :
+  MultiWorker.worker list option ->
+  ServerEnv.env ->
+  string list ->
+  Filter_errors.Filter.t ->
+  bool ->
+  Telemetry.t

hphp/hack/src/server/serverRpc.ml

@@ -42,9 +42,10 @@ let handle :
     ServerEnv.genv ->
     ServerEnv.env ->
     is_stale:bool ->
+    ServerCommandTypes.cmd_metadata ->
     a ServerCommandTypes.t ->
     ServerEnv.env * a =
- fun genv env ~is_stale -> function
+ fun genv env ~is_stale metadata -> function
   | ServerCommandTypes.STATUS { max_errors; error_filter } ->
     log_check_response env;
     let (error_list, dropped_count) =
@@ -118,6 +119,29 @@ let handle :
         None
     in
     (env, (errors, tasts))
+  | ServerCommandTypes.LOG_ERRORS
+      { files; log_file; error_filter; preexisting_warnings } ->
+    let telemetry =
+      ServerLogErrors.go
+        genv.ServerEnv.workers
+        env
+        files
+        error_filter
+        preexisting_warnings
+    in
+    let () =
+      match log_file with
+      | Some path ->
+        let oc = Out_channel.create ~binary:false ~append:true path in
+        telemetry |> Telemetry.to_json |> Hh_json.json_to_output oc;
+        Out_channel.newline oc;
+        Out_channel.close oc
+      | None ->
+        HackEventLogger.LogFileErrors.log
+          telemetry
+          ~from:metadata.ServerCommandTypes.from
+    in
+    (env, ())
   | ServerCommandTypes.INFER_TYPE (file_input, pos) ->
     let path =
       match file_input with