hphp/hack/src/deps/fileInfo.ml

   1 (*
   2  * Copyright (c) 2015, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the MIT license found in the
   6  * LICENSE file in the "hack" directory of this source tree.
   7  *
   8  *)
   9
  10 (*****************************************************************************)
  11 (* This module defines the data structured used to describe the content of
  12  * a file.
  13  * The parser constructs FileInfo.t structs, that contain names and positions
  14  * plus some extra info required for the build.
  15  * After the names have been checked (Naming.make_env), we "simplify" the
  16  * struct and only keep the names defined in the files we know about.
  17  *)
  18 (*****************************************************************************)
  19
  20 open Hh_prelude
  21 open Prim_defs
  22
  23 (*****************************************************************************)
  24 (* Parsing modes *)
  25 (*****************************************************************************)
  26
  27 type mode =
  28   | Mhhi  (** just declare signatures, don't check anything *)
  29   | Mstrict  (** check everything! *)
  30   | Mpartial  (** Don't fail if you see a function/class you don't know *)
  31 [@@deriving eq, show, enum]
  32
  33 let parse_mode = function
  34   | "strict"
  35   | "" ->
  36     Some Mstrict
  37   | "partial" -> Some Mpartial
  38   | _ -> None
  39
  40 let is_strict = function
  41   | Mstrict -> true
  42   | Mhhi
  43   | Mpartial ->
  44     false
  45
  46 let string_of_mode = function
  47   | Mhhi -> "hhi"
  48   | Mstrict -> "strict"
  49   | Mpartial -> "partial"
  50
  51 let pp_mode fmt mode =
  52   Format.pp_print_string fmt
  53   @@
  54   match mode with
  55   | Mhhi -> "Mhhi"
  56   | Mstrict -> "Mstrict"
  57   | Mpartial -> "Mpartial"
  58
  59 (*****************************************************************************)
  60 (* Positions of names in a file *)
  61 (*****************************************************************************)
  62
  63 type name_type =
  64   | Fun [@value 0]
  65   | Class [@value 1]
  66   | RecordDef [@value 2]
  67   | Typedef [@value 3]
  68   | Const [@value 4]
  69 [@@deriving eq, show, enum, ord]
  70
  71 (** We define two types of positions establishing the location of a given name:
  72  * a Full position contains the exact position of a name in a file, and a
  73  * File position contains just the file and the type of toplevel entity,
  74  * allowing us to lazily retrieve the name's exact location if necessary.
  75  *)
  76 type pos =
  77   | Full of Pos.t
  78   | File of name_type * Relative_path.t
  79 [@@deriving eq, show]
  80
  81 type id = pos * string [@@deriving eq, show]
  82
  83 (*****************************************************************************)
  84 (* The record produced by the parsing phase. *)
  85 (*****************************************************************************)
  86
  87 type hash_type = Int64.t option [@@deriving eq]
  88
  89 let pp_hash_type fmt hash =
  90   match hash with
  91   | None -> Format.fprintf fmt "None"
  92   | Some hash -> Format.fprintf fmt "Some (%s)" (Int64.to_string hash)
  93
  94 (** The record produced by the parsing phase. *)
  95 type t = {
  96   hash: hash_type;
  97   file_mode: mode option;
  98   funs: id list;
  99   classes: id list;
 100   record_defs: id list;
 101   typedefs: id list;
 102   consts: id list;
 103   comments: (Pos.t * comment) list option;
 104       (** None if loaded from saved state *)
 105 }
 106 [@@deriving show]
 107
 108 let empty_t =
 109   {
 110     hash = None;
 111     file_mode = None;
 112     funs = [];
 113     classes = [];
 114     record_defs = [];
 115     typedefs = [];
 116     consts = [];
 117     comments = Some [];
 118   }
 119
 120 let pos_full (p, name) = (Full p, name)
 121
 122 let get_pos_filename = function
 123   | Full p -> Pos.filename p
 124   | File (_, fn) -> fn
 125
 126 (*****************************************************************************)
 127 (* The simplified record used after parsing. *)
 128 (*****************************************************************************)
 129
 130 (** The simplified record used after parsing. *)
 131 type names = {
 132   n_funs: SSet.t;
 133   n_classes: SSet.t;
 134   n_record_defs: SSet.t;
 135   n_types: SSet.t;
 136   n_consts: SSet.t;
 137 }
 138
 139 (** The simplified record stored in saved-state.*)
 140 type saved_names = {
 141   sn_funs: SSet.t;
 142   sn_classes: SSet.t;
 143   sn_record_defs: SSet.t;
 144   sn_types: SSet.t;
 145   sn_consts: SSet.t;
 146 }
 147
 148 (** Data structure stored in the saved state *)
 149 type saved = {
 150   s_names: saved_names;
 151   s_hash: Int64.t option;
 152   s_mode: mode option;
 153 }
 154
 155 let empty_names =
 156   {
 157     n_funs = SSet.empty;
 158     n_classes = SSet.empty;
 159     n_record_defs = SSet.empty;
 160     n_types = SSet.empty;
 161     n_consts = SSet.empty;
 162   }
 163
 164 (*****************************************************************************)
 165 (* Functions simplifying the file information. *)
 166 (*****************************************************************************)
 167
 168 let name_set_of_idl idl =
 169   List.fold_left idl ~f:(fun acc (_, x) -> SSet.add x acc) ~init:SSet.empty
 170
 171 let simplify info =
 172   let {
 173     funs;
 174     classes;
 175     record_defs;
 176     typedefs;
 177     consts;
 178     file_mode = _;
 179     comments = _;
 180     hash = _;
 181   } =
 182     info
 183   in
 184   let n_funs = name_set_of_idl funs in
 185   let n_classes = name_set_of_idl classes in
 186   let n_record_defs = name_set_of_idl record_defs in
 187   let n_types = name_set_of_idl typedefs in
 188   let n_consts = name_set_of_idl consts in
 189   { n_funs; n_classes; n_record_defs; n_types; n_consts }
 190
 191 let to_saved info =
 192   let {
 193     funs;
 194     classes;
 195     record_defs;
 196     typedefs;
 197     consts;
 198     file_mode = s_mode;
 199     hash = s_hash;
 200     comments = _;
 201   } =
 202     info
 203   in
 204   let sn_funs = name_set_of_idl funs in
 205   let sn_classes = name_set_of_idl classes in
 206   let sn_record_defs = name_set_of_idl record_defs in
 207   let sn_types = name_set_of_idl typedefs in
 208   let sn_consts = name_set_of_idl consts in
 209   let s_names = { sn_funs; sn_classes; sn_record_defs; sn_types; sn_consts } in
 210   { s_names; s_mode; s_hash }
 211
 212 let from_saved fn saved =
 213   let { s_names; s_mode; s_hash } = saved in
 214   let { sn_funs; sn_classes; sn_record_defs; sn_types; sn_consts } = s_names in
 215   let funs =
 216     List.map (SSet.elements sn_funs) ~f:(fun x -> (File (Fun, fn), x))
 217   in
 218   let classes =
 219     List.map (SSet.elements sn_classes) ~f:(fun x -> (File (Class, fn), x))
 220   in
 221   let record_defs =
 222     List.map (SSet.elements sn_record_defs) ~f:(fun x ->
 223         (File (RecordDef, fn), x))
 224   in
 225   let typedefs =
 226     List.map (SSet.elements sn_types) ~f:(fun x -> (File (Typedef, fn), x))
 227   in
 228   let consts =
 229     List.map (SSet.elements sn_consts) ~f:(fun x -> (File (Const, fn), x))
 230   in
 231   {
 232     file_mode = s_mode;
 233     hash = s_hash;
 234     funs;
 235     classes;
 236     record_defs;
 237     typedefs;
 238     consts;
 239     comments = None;
 240   }
 241
 242 let saved_to_names saved =
 243   {
 244     n_funs = saved.s_names.sn_funs;
 245     n_classes = saved.s_names.sn_classes;
 246     n_record_defs = saved.s_names.sn_record_defs;
 247     n_types = saved.s_names.sn_types;
 248     n_consts = saved.s_names.sn_consts;
 249   }
 250
 251 let merge_names t_names1 t_names2 =
 252   let { n_funs; n_classes; n_record_defs; n_types; n_consts } = t_names1 in
 253   {
 254     n_funs = SSet.union n_funs t_names2.n_funs;
 255     n_classes = SSet.union n_classes t_names2.n_classes;
 256     n_record_defs = SSet.union n_record_defs t_names2.n_record_defs;
 257     n_types = SSet.union n_types t_names2.n_types;
 258     n_consts = SSet.union n_consts t_names2.n_consts;
 259   }
 260
 261 let to_string fast =
 262   [
 263     ("funs", fast.funs);
 264     ("classes", fast.classes);
 265     ("typedefs", fast.typedefs);
 266     ("consts", fast.consts);
 267   ]
 268   |> List.filter ~f:(fun (_, l) -> not @@ List.is_empty l)
 269   |> List.map ~f:(fun (kind, l) ->
 270          Printf.sprintf
 271            "%s: %s"
 272            kind
 273            (List.map l ~f:snd |> String.concat ~sep:","))
 274   |> String.concat ~sep:";"
 275
 276 type diff = {
 277   removed_funs: SSet.t;
 278   added_funs: SSet.t;
 279   removed_classes: SSet.t;
 280   added_classes: SSet.t;
 281   removed_types: SSet.t;
 282   added_types: SSet.t;
 283   removed_consts: SSet.t;
 284   added_consts: SSet.t;
 285 }
 286
 287 let diff f1 f2 =
 288   let matches_hash =
 289     match (f1.hash, f2.hash) with
 290     | (Some h1, Some h2) -> Int64.equal h1 h2
 291     | _ -> false
 292   in
 293   if matches_hash then
 294     None
 295   else
 296     let diff_ids ids1 ids2 =
 297       let removed_ids = SSet.diff ids1 ids2 in
 298       let added_ids = SSet.diff ids2 ids1 in
 299       (removed_ids, added_ids)
 300     in
 301     let f1 = simplify f1 in
 302     let f2 = simplify f2 in
 303     let (removed_funs, added_funs) = diff_ids f1.n_funs f2.n_funs in
 304     let (removed_classes, added_classes) = diff_ids f1.n_classes f2.n_classes in
 305     let (removed_types, added_types) = diff_ids f1.n_types f2.n_types in
 306     let (removed_consts, added_consts) = diff_ids f1.n_consts f2.n_consts in
 307     let is_empty =
 308       List.fold
 309         ~f:(fun acc s -> (not (SSet.is_empty s)) || acc)
 310         [
 311           removed_funs;
 312           added_funs;
 313           removed_classes;
 314           added_classes;
 315           removed_types;
 316           added_types;
 317           removed_consts;
 318           added_consts;
 319         ]
 320         ~init:false
 321     in
 322     if is_empty then
 323       None
 324     else
 325       Some
 326         {
 327           removed_funs;
 328           added_funs;
 329           removed_classes;
 330           added_classes;
 331           removed_types;
 332           added_types;
 333           removed_consts;
 334           added_consts;
 335         }