[PR] Implement versioned .js.flow

hack/utils/string/string_utils.ml

@@ -34,7 +34,7 @@ let string_ends_with long short =
    `haystack`. If not found, returns -1.
 
    An implementation of the Knuth-Morris-Pratt (KMP) algorithm. *)
-let substring_index needle =
+let substring_index ?(start_pos = 0) needle =
   (* see Wikipedia pseudocode *)
   let needle_len = String.length needle in
   if needle_len = 0 then raise (Invalid_argument needle);
@@ -55,7 +55,7 @@ let substring_index needle =
   done;
   fun haystack ->
     let len = String.length haystack in
-    let p = ref 0 in
+    let p = ref start_pos in
     let q = ref 0 in
     while !p < len && !q < needle_len do
       if haystack.[!p] = needle.[!q] then (

hack/utils/string/string_utils.mli

@@ -27,7 +27,7 @@ val string_starts_with : string -> string -> bool
 
 val string_ends_with : string -> string -> bool
 
-val substring_index : string -> string -> int
+val substring_index : ?start_pos:int -> string -> string -> int
 
 val is_substring : string -> string -> bool
 

src/parser_utils/package_json.ml

@@ -7,21 +7,29 @@
 
 module Ast = Flow_ast
 
+type flow_t = { types_versions: string SMap.t }
+
 type t = {
   name: string option;
   main: string option;
+  flow: flow_t option;
 }
 
 type 'a t_or_error = (t, 'a * string) result
 
 let ( >>= ) = Core_result.( >>= )
 
-let empty = { name = None; main = None }
+let empty = { name = None; main = None; flow = None }
 
 let name package = package.name
 
 let main package = package.main
 
+let flow_types_versions package =
+  match package.flow with
+  | Some t -> t.types_versions
+  | None -> SMap.empty
+
 let statement_of_program = function
   | (_, [statement], _) -> Ok statement
   | (loc, _, _) -> Error (loc, "Expected a single statement.")
@@ -45,6 +53,46 @@ let properties_of_object = function
   | (_, Ast.Expression.Object { Ast.Expression.Object.properties; comments = _ }) -> Ok properties
   | (loc, _) -> Error (loc, "Expected an object literal")
 
+let parse_flow properties =
+  Ast.(
+    Expression.Object.(
+      let extract_property (flow : flow_t) = function
+        | Property
+            ( _,
+              Property.Init
+                {
+                  key = Property.Literal (_, { Literal.value = Literal.String key; _ });
+                  value = (_, Expression.Object { Expression.Object.properties; _ });
+                  _;
+                } ) ->
+          begin
+            match key with
+            | "typesVersions" ->
+              let value =
+                List.fold_left
+                  (fun map property ->
+                    match property with
+                    | Property
+                        ( _,
+                          Property.Init
+                            {
+                              key = Property.Literal (_, { Literal.value = Literal.String key; _ });
+                              value =
+                                (_, Expression.Literal { Literal.value = Literal.String value; _ });
+                              _;
+                            } ) ->
+                      SMap.add key value map
+                    | _ -> map)
+                  SMap.empty
+                  properties
+              in
+              { types_versions = value }
+            | _ -> flow
+          end
+        | _ -> flow
+      in
+      List.fold_left extract_property { types_versions = SMap.empty } properties))
+
 let parse ast : 'a t_or_error =
   statement_of_program ast
   >>= object_of_statement
@@ -67,6 +115,21 @@ let parse ast : 'a t_or_error =
             | "main" -> { package with main = Some value }
             | _ -> package
           end
+        | Property
+            ( _,
+              Property.Init
+                {
+                  key = Property.Literal (_, { Literal.value = Literal.String key; _ });
+                  value = (_, Expression.Object { Expression.Object.properties; _ });
+                  _;
+                } ) ->
+          begin
+            match key with
+            | "flow" ->
+              let value = parse_flow properties in
+              { package with flow = Some value }
+            | _ -> package
+          end
         | _ -> package
       in
       Ok (List.fold_left extract_property empty properties)))

src/parser_utils/package_json.mli

@@ -15,4 +15,6 @@ val name : t -> string option
 
 val main : t -> string option
 
+val flow_types_versions : t -> string SMap.t
+
 val parse : (Loc.t, Loc.t) Flow_ast.program -> Loc.t t_or_error

src/services/inference/module/module_js.ml

@@ -93,6 +93,69 @@ let module_name_candidates ~options =
       in
       List.rev (name :: List.fold_left map_name [] mappers))
 
+let types_versions_package_candidates reader =
+  Module_hashtables.memoize_with_types_versions_candidates_cache ~f:(fun package_filename ->
+      let package =
+        match Module_heaps.Reader_dispatcher.get_package ~reader package_filename with
+        | Some (Ok package) -> package
+        | _ -> Package_json.empty
+      in
+      let types_versions = Package_json.flow_types_versions package in
+      let version_path =
+        SMap.find_first_opt
+          (fun k ->
+            try Semver.satisfies ~include_prereleases:true k Flow_version.version
+            with Semver.Parse_error _ -> false)
+          types_versions
+      in
+      version_path)
+
+let types_versions_candidates ~reader dir rel_path dirname =
+  Node_paths_part.(
+    let parts = get_node_module_path_parts rel_path dirname in
+    match parts with
+    | Some parts ->
+      let package_root =
+        if parts.package_root_index == -1 then
+          rel_path
+        else
+          String.sub rel_path 0 parts.package_root_index
+      in
+      let package_filename = Filename.concat package_root "package.json" in
+      let package_filename = Files.normalize_path dir package_filename in
+      let version_path = types_versions_package_candidates reader package_filename in
+      let filename =
+        if parts.package_root_index == -1 then
+          ""
+        else
+          String.sub
+            rel_path
+            (parts.package_root_index + 1)
+            (String.length rel_path - (parts.package_root_index + 1))
+      in
+      let rel_path =
+        match version_path with
+        | Some (_, version_path) ->
+          (* Chop trailing "/" *)
+          let tail =
+            if filename = "" then
+              version_path
+            else
+              Filename.concat version_path filename
+          in
+          Files.normalize_path package_root tail
+        | None -> rel_path
+      in
+      (* If file points outside of root, resolve current package root *)
+      let rel_path =
+        if String_utils.string_starts_with rel_path package_root then
+          rel_path
+        else
+          Files.normalize_path package_root filename
+      in
+      Some rel_path
+    | _ -> None)
+
 let add_package filename = function
   | Ok package -> Module_heaps.Package_heap_mutator.add_package_json filename package
   | Error _ -> Module_heaps.Package_heap_mutator.add_error filename
@@ -320,6 +383,19 @@ module Node = struct
     let file_options = Options.file_options options in
     lazy_seq
       [
+        lazy
+          ( if SSet.mem dir node_modules_containers then
+            lazy_seq
+              ( Files.node_resolver_dirnames file_options
+              |> Core_list.map ~f:(fun dirname ->
+                     let rel_path = spf "%s%s%s" dirname Filename.dir_sep r in
+                     let rel_path_opt = types_versions_candidates ~reader dir rel_path dirname in
+                     match rel_path_opt with
+                     | Some rel_path ->
+                       lazy (resolve_relative ~options ~reader loc ?resolution_acc dir rel_path)
+                     | _ -> lazy None) )
+          else
+            None );
         lazy
           ( if SSet.mem dir node_modules_containers then
             lazy_seq

src/services/inference/module/node_paths_part.ml

@@ -0,0 +1,78 @@
+(**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *)
+
+type node_module_path_parts = {
+  top_level_node_modules_index: int;
+  top_level_package_name_index: int;
+  package_root_index: int;
+  file_name_index: int;
+}
+
+type states = {
+  before_node_modules: int;
+  node_modules: int;
+  scope: int;
+  package_content: int;
+}
+
+let states = { before_node_modules = 0; node_modules = 1; scope = 2; package_content = 3 }
+
+(* Example of expected pattern: /base/path/node_modules/[@scope/otherpackage/@otherscope/node_modules/]package/[subdirectory/]file.js *)
+(* Returns indices:                       ^            ^                                                      ^             ^ *)
+let get_node_module_path_parts (full_path : string) (node_modules_path_part : string) :
+    node_module_path_parts option =
+  let top_level_node_modules_index = ref 0 in
+  let top_level_package_name_index = ref 0 in
+  let package_root_index = ref 0 in
+  let file_name_index = ref 0 in
+  let part_start = ref 0 in
+  let part_end = ref 0 in
+  let state = ref states.before_node_modules in
+  while !part_end >= 0 do
+    part_start := !part_end;
+    part_end :=
+      String_utils.substring_index ~start_pos:(!part_start + 1) Filename.dir_sep full_path;
+
+    if !state == states.before_node_modules then (
+      let start = !part_start in
+      let index = String_utils.substring_index ~start_pos:start node_modules_path_part full_path in
+      if index == start then (
+        top_level_node_modules_index := start;
+        top_level_package_name_index := !part_end;
+        state := states.node_modules
+      )
+    ) else if !state == states.node_modules || !state == states.scope then
+      let index = !part_start + 1 in
+      let ch = full_path.[index] in
+      let has_scope = ch == '@' in
+      if !state == states.node_modules && has_scope then
+        state := states.scope
+      else (
+        package_root_index := !part_end;
+        state := states.package_content
+      )
+    else if !state == states.package_content then (
+      let index =
+        String_utils.substring_index ~start_pos:!part_start node_modules_path_part full_path
+      in
+      if index == !part_start then state := states.node_modules
+    ) else
+      state := states.package_content
+  done;
+
+  file_name_index := !part_start;
+
+  if !state > states.node_modules then
+    Some
+      {
+        top_level_node_modules_index = !top_level_node_modules_index;
+        top_level_package_name_index = !top_level_package_name_index;
+        package_root_index = !package_root_index;
+        file_name_index = !file_name_index;
+      }
+  else
+    None

src/state/locals/module/module_hashtables.ml

@@ -114,3 +114,12 @@ let memoize_with_module_name_candidates_cache ~f name =
     let result = f name in
     Hashtbl.add module_name_candidates_cache name result;
     result
+
+let types_versions_candidates_cache = Hashtbl.create 100
+
+let memoize_with_types_versions_candidates_cache ~f name =
+  try Hashtbl.find types_versions_candidates_cache name
+  with Not_found ->
+    let result = f name in
+    Hashtbl.add types_versions_candidates_cache name result;
+    result

src/state/locals/module/module_hashtables.mli

@@ -24,3 +24,6 @@ module All_providers_mutator : sig
 end
 
 val memoize_with_module_name_candidates_cache : f:(string -> string list) -> string -> string list
+
+val memoize_with_types_versions_candidates_cache :
+  f:(string -> (SMap.key * string) option) -> string -> (SMap.key * string) option

tests/declaration_files_node_versions/.flowconfig

@@ -0,0 +1,7 @@
+[ignore]
+
+[include]
+
+[libs]
+
+[options]

tests/declaration_files_node_versions/declaration_files_node_versions.exp

@@ -0,0 +1 @@
+Found 0 errors