Rewire interprocedural to be one-Analysis [1] update public interface

Summary:
**About the stack**

After some discussion, all the pysa stakeholders are agreed that we don't have
any expectation of needing to run multiple concurrent analyses and share data
across them.

As a result, we can significantly simplify the framework by restricting
to one analysis at a time.

Code simplification is an important long-term goal, but our immediate concern
is really functionality: by restricting the framework to run on one analysis
at a time, we can make it possible for us to put callbacks into the analysis
which the "plumbing" code, such as callgraph construction, can use to customize
framework behavior for each analysis; this isn't possible to do cleanly in
a multi-analysis framework because it's not clear which analysis would call
the shots.

This change is needed to unblock full feature parity of interprocedural
infer vs ordinary infer, because we need the ability to exclude some code
from the analysis based on commandline flags that don't line up with
taint.

**About this diff**

It's going to take some time to fully simplify the existing multi-analysis
code. This diff is a minimal initial change to rewire the public functions
from `interproceduralAnalysis.ml` while making it trivial to review the
changes; the interfaces are clean but the code is now a little messy
because to preserve the existing logic I'm often doing a "fold" over just one
analysis.

I'll stack changes on top to both simplify the interproceduralResult types
and get rid of some of the accumulate boilerplate still left over because
we previously had to fold over analyses.

Reviewed By: dkgi

Differential Revision: D28886238

fbshipit-source-id: d82d3c422a71c8ce0a260289e0ab36d67e60d356

Author: stroxler

source/command/analyzeCommand.ml

@@ -177,7 +177,7 @@ let run_analysis
       Scheduler.with_scheduler ~configuration ~f:(fun scheduler ->
           Interprocedural.Analysis.initialize_configuration
             ~static_analysis_configuration
-            [analysis_kind];
+            analysis_kind;
           let cached_environment =
             if use_cache then Service.StaticAnalysis.Cache.load_environment ~configuration else None
           in
@@ -234,7 +234,7 @@ let run_analysis
           in
           Service.StaticAnalysis.analyze
             ~scheduler
-            ~analysis_kind
+            ~analysis:analysis_kind
             ~static_analysis_configuration
             ~filename_lookup
             ~environment:(Analysis.TypeEnvironment.read_only environment)

source/interprocedural/interproceduralAnalysis.ml

@@ -12,22 +12,18 @@ open Statement
 module Kind = AnalysisKind
 module Result = InterproceduralResult
 
-let initialize_configuration kinds ~static_analysis_configuration =
-  let initialize_kind kind =
-    let (Result.Analysis { analysis; _ }) = Result.get_abstract_analysis kind in
-    let module Analysis = (val analysis) in
-    Analysis.initialize_configuration ~static_analysis_configuration
-  in
-  List.iter kinds ~f:initialize_kind
+let initialize_configuration kind ~static_analysis_configuration =
+  let (Result.Analysis { analysis; _ }) = Result.get_abstract_analysis kind in
+  let module Analysis = (val analysis) in
+  Analysis.initialize_configuration ~static_analysis_configuration
 
 
 type initialize_result = {
   initial_models: InterproceduralResult.model_t Callable.Map.t;
   skip_overrides: Ast.Reference.Set.t;
 }
 
-let initialize_models kinds ~scheduler ~static_analysis_configuration ~environment ~functions ~stubs
-  =
+let initialize_models kind ~scheduler ~static_analysis_configuration ~environment ~functions ~stubs =
   let initialize_each
       { initial_models = models; skip_overrides }
       (Result.Analysis { kind; analysis })
@@ -57,10 +53,7 @@ let initialize_models kinds ~scheduler ~static_analysis_configuration ~environme
     }
   in
   let accumulate model kind = initialize_each model (Result.get_abstract_analysis kind) in
-  List.fold
-    kinds
-    ~init:{ initial_models = Callable.Map.empty; skip_overrides = Reference.Set.empty }
-    ~f:accumulate
+  accumulate { initial_models = Callable.Map.empty; skip_overrides = Reference.Set.empty } kind
 
 
 let record_initial_models ~functions ~stubs models =
@@ -103,7 +96,7 @@ let get_empty_model (type a) (kind : < model : a ; .. > Result.storable_kind) :
   Analysis.empty_model
 
 
-let get_obscure_models analyses =
+let get_obscure_models analysis =
   let get_analysis_specific_obscure_model map abstract_analysis =
     let (Result.Analysis { kind; analysis }) = abstract_analysis in
     let module Analysis = (val analysis) in
@@ -113,7 +106,7 @@ let get_obscure_models analyses =
       (Result.Pkg { kind = ModelPart kind; value = obscure_model })
       map
   in
-  let models = List.fold ~f:get_analysis_specific_obscure_model ~init:Kind.Map.empty analyses in
+  let models = get_analysis_specific_obscure_model Kind.Map.empty analysis in
   Result.{ models; is_obscure = true }
 
 
@@ -289,7 +282,7 @@ let widen_if_necessary step callable ~old_model ~new_model result =
 
 let analyze_define
     step
-    analyses
+    analysis
     callable
     environment
     qualifier
@@ -329,12 +322,7 @@ let analyze_define
       let akind, model, result = analyze analysis in
       Result.Kind.Map.add akind model models, Result.Kind.Map.add akind result results
     in
-    (* Run all the analyses *)
-    try
-      let init = Result.Kind.Map.(empty, empty) in
-      let models, results = List.fold ~f:accumulate analyses ~init in
-      models, results
-    with
+    try accumulate Result.Kind.Map.(empty, empty) analysis with
     | Analysis.ClassHierarchy.Untracked annotation ->
         Log.log
           ~section:`Info
@@ -407,7 +395,7 @@ let callables_to_dump =
   ref Callable.Set.empty
 
 
-let analyze_callable analyses step callable environment =
+let analyze_callable analysis step callable environment =
   let resolution = Analysis.TypeEnvironment.ReadOnly.global_resolution environment in
   let () =
     (* Verify invariants *)
@@ -446,13 +434,13 @@ let analyze_callable analyses step callable environment =
           Fixpoint.
             {
               is_partial = false;
-              model = get_obscure_models analyses;
+              model = get_obscure_models analysis;
               result = Result.empty_result;
             }
       | Some (qualifier, ({ Node.value; _ } as define)) ->
           if Define.dump value then
             callables_to_dump := Callable.Set.add callable !callables_to_dump;
-          analyze_define step analyses callable environment qualifier define )
+          analyze_define step analysis callable environment qualifier define )
   | #Callable.override_target as callable -> analyze_overrides step callable
   | #Callable.object_target as path ->
       Format.asprintf "Found object %a in fixpoint analysis" Callable.pp path |> failwith
@@ -470,11 +458,11 @@ type result = {
 }
 
 (* Called on a worker with a set of functions to analyze. *)
-let one_analysis_pass ~analyses ~step ~environment ~callables =
-  let analyses = List.map ~f:Result.get_abstract_analysis analyses in
+let one_analysis_pass ~analysis ~step ~environment ~callables =
+  let analysis = Result.get_abstract_analysis analysis in
   let analyze_and_cache expensive_callables callable =
     let timer = Timer.start () in
-    let result = analyze_callable analyses step callable environment in
+    let result = analyze_callable analysis step callable environment in
     Fixpoint.add_state step callable result;
     (* Log outliers. *)
     if Timer.stop_in_ms timer > 500 then begin
@@ -564,7 +552,7 @@ let compute_callables_to_reanalyze
 let compute_fixpoint
     ~scheduler
     ~environment
-    ~analyses
+    ~analysis
     ~dependencies
     ~filtered_callables
     ~all_callables
@@ -635,7 +623,7 @@ let compute_fixpoint
           Scheduler.map_reduce
             scheduler
             ~policy:(Scheduler.Policy.legacy_fixed_chunk_size 1000)
-            ~map:(fun _ callables -> one_analysis_pass ~analyses ~step ~environment ~callables)
+            ~map:(fun _ callables -> one_analysis_pass ~analysis ~step ~environment ~callables)
             ~initial:
               {
                 callables_processed = 0;
@@ -722,7 +710,7 @@ let report_results
     ~static_analysis_configuration
     ~environment
     ~filename_lookup
-    ~analyses
+    ~analysis
     ~callables
     ~skipped_overrides
     ~fixpoint_timer
@@ -740,5 +728,4 @@ let report_results
       ~fixpoint_timer
       ~fixpoint_iterations
   in
-  let analyses = List.map ~f:Result.get_abstract_analysis analyses in
-  analyses |> List.concat_map ~f:report_analysis
+  Result.get_abstract_analysis analysis |> report_analysis

source/interprocedural/interproceduralAnalysis.mli

@@ -13,13 +13,13 @@ type initialize_result = {
 }
 
 val initialize_configuration
-  :  Kind.abstract list ->
+  :  Kind.abstract ->
   static_analysis_configuration:Configuration.StaticAnalysis.t ->
   unit
 
-(* Calls init on all specified analyses to get initial models *)
+(* Calls init on specified analysis to get initial models *)
 val initialize_models
-  :  Kind.abstract list ->
+  :  Kind.abstract ->
   scheduler:Scheduler.t ->
   static_analysis_configuration:Configuration.StaticAnalysis.t ->
   environment:Analysis.TypeEnvironment.ReadOnly.t ->
@@ -45,7 +45,7 @@ type result = {
 }
 
 val one_analysis_pass
-  :  analyses:Kind.abstract list ->
+  :  analysis:Kind.abstract ->
   step:Fixpoint.step ->
   environment:Analysis.TypeEnvironment.ReadOnly.t ->
   callables:Callable.t list ->
@@ -55,7 +55,7 @@ val one_analysis_pass
 val compute_fixpoint
   :  scheduler:Scheduler.t ->
   environment:Analysis.TypeEnvironment.ReadOnly.t ->
-  analyses:Kind.abstract list ->
+  analysis:Kind.abstract ->
   dependencies:DependencyGraph.t ->
   filtered_callables:Callable.Set.t ->
   all_callables:Callable.t list ->
@@ -69,7 +69,7 @@ val report_results
   static_analysis_configuration:Configuration.StaticAnalysis.t ->
   environment:Analysis.TypeEnvironment.ReadOnly.t ->
   filename_lookup:(Ast.Reference.t -> string option) ->
-  analyses:Kind.abstract list ->
+  analysis:Kind.abstract ->
   callables:Callable.Set.t ->
   skipped_overrides:Ast.Reference.t list ->
   fixpoint_timer:Timer.t ->

source/interprocedural/test/interproceduralAnalysisTest.ml

@@ -106,76 +106,7 @@ module AnalysisA = ResultA.Register (struct
     callables |> Callable.Set.elements |> List.map ~f:get_model
 end)
 
-module ResultB = Interprocedural.Result.Make (struct
-  type result = int
-
-  type call_model = string [@@deriving show]
-
-  let name = "analysisB"
-
-  let empty_model = "empty"
-
-  let obscure_model = "obscure"
-
-  let join ~iteration:_ a b = a ^ b
-
-  let widen ~iteration ~previous ~next = join ~iteration previous next
-
-  let reached_fixpoint ~iteration:_ ~previous ~next = String.(next <= previous)
-
-  let strip_for_callsite model = model
-end)
-
-module AnalysisB = ResultB.Register (struct
-  let initialize_configuration ~static_analysis_configuration:_ = ()
-
-  let initialize_models
-      ~scheduler:_
-      ~static_analysis_configuration:_
-      ~environment:_
-      ~functions:_
-      ~stubs:_
-    =
-    { Result.initial_models = Callable.Map.empty; skip_overrides = Reference.Set.empty }
-
-
-  let analyze ~environment:_ ~callable:_ ~qualifier:_ ~define:_ ~existing:_ = 7, "B"
-
-  let report
-      ~scheduler:_
-      ~static_analysis_configuration:_
-      ~environment:_
-      ~filename_lookup:_
-      ~callables
-      ~skipped_overrides:_
-      ~fixpoint_timer:_
-      ~fixpoint_iterations:_
-    =
-    let get_model callable : Yojson.Safe.json =
-      let model =
-        Fixpoint.get_model callable
-        >>= Result.get_model ResultB.kind
-        >>| (fun r -> `String r)
-        |> Option.value ~default:`Null
-      in
-      let result =
-        Fixpoint.get_result callable
-        |> Result.get_result ResultB.kind
-        >>| (fun r -> `Int r)
-        |> Option.value ~default:`Null
-      in
-      `Assoc
-        [
-          "analysis", `String ResultB.name;
-          "callable", `String (Callable.show callable);
-          "model", model;
-          "result", result;
-        ]
-    in
-    callables |> Callable.Set.elements |> List.map ~f:get_model
-end)
-
-let analyses = [AnalysisA.abstract_kind; AnalysisB.abstract_kind]
+let analysis = AnalysisA.abstract_kind
 
 let assert_report ~expected report =
   let json_printer jsons = String.concat ~sep:"\n" (List.map ~f:Yojson.Safe.to_string jsons) in
@@ -197,15 +128,14 @@ let test_unknown_function_analysis context =
     |> TypeAnalysis.TypeEnvironment.read_only
   in
   let step = Fixpoint.{ epoch = 1; iteration = 0 } in
-  let _ = Analysis.one_analysis_pass ~step ~analyses ~environment ~callables:targets in
+  let _ = Analysis.one_analysis_pass ~step ~analysis ~environment ~callables:targets in
   (* Make sure obscure models are correctly handled *)
   let check_obscure_model target =
     match Fixpoint.get_model target with
     | None ->
         Format.sprintf "no model stored for target %s" (Callable.show target) |> assert_failure
     | Some models ->
-        assert_equal (Result.get_model ResultA.kind models) (Some ResultA.obscure_model);
-        assert_equal (Result.get_model ResultB.kind models) (Some ResultB.obscure_model)
+        assert_equal (Result.get_model ResultA.kind models) (Some ResultA.obscure_model)
   in
   List.iter ~f:check_obscure_model targets;
   (* Make sure result extraction works (this verifies a lot of the type magic) *)
@@ -215,7 +145,7 @@ let test_unknown_function_analysis context =
       ~scheduler:(Test.mock_scheduler ())
       ~static_analysis_configuration
       ~environment
-      ~analyses
+      ~analysis
       ~filename_lookup:(fun _ -> None)
       ~callables:(targets |> Callable.Set.of_list)
       ~skipped_overrides:[]
@@ -228,8 +158,6 @@ let test_unknown_function_analysis context =
       [
         {| {"analysis":"analysisA","callable":"fun_a (fun)","model":-1,"result":null} |};
         {| {"analysis":"analysisA","callable":"fun_b (fun)","model":-1,"result":null} |};
-        {| {"analysis":"analysisB","callable":"fun_a (fun)","model":"obscure","result":null} |};
-        {| {"analysis":"analysisB","callable":"fun_b (fun)","model":"obscure","result":null} |};
       ]
 
 
@@ -262,7 +190,7 @@ let test_meta_data context =
     |> TypeAnalysis.TypeEnvironment.create
     |> TypeAnalysis.TypeEnvironment.read_only
   in
-  let _ = Analysis.one_analysis_pass ~step:step1 ~analyses ~environment ~callables:targets in
+  let _ = Analysis.one_analysis_pass ~step:step1 ~analysis ~environment ~callables:targets in
   (* All obscure functions should reach fixpoint in 1st step *)
   let () = List.iter ~f:(check_meta_data ~step:step1 ~is_partial:false) targets in
   ()

source/interprocedural_analyses/taint/test/fixpointTest.ml

@@ -26,12 +26,11 @@ let assert_fixpoint ?models ~context source ~expect:{ iterations = expect_iterat
     |> DependencyGraph.union overrides
     |> DependencyGraph.reverse
   in
-  let analyses = [TaintAnalysis.abstract_kind] in
   let iterations =
     Analysis.compute_fixpoint
       ~scheduler
       ~environment
-      ~analyses
+      ~analysis:TaintAnalysis.abstract_kind
       ~dependencies
       ~filtered_callables:Callable.Set.empty
       ~all_callables:callables_to_analyze

source/interprocedural_analyses/taint/test/integrationTest.ml

@@ -109,7 +109,7 @@ let test_integration path context =
     Analysis.compute_fixpoint
       ~scheduler:(Test.mock_scheduler ())
       ~environment
-      ~analyses:[TaintAnalysis.abstract_kind]
+      ~analysis:TaintAnalysis.abstract_kind
       ~dependencies
       ~filtered_callables:Callable.Set.empty
       ~all_callables:callables_to_analyze

source/interprocedural_analyses/taint/test/missingFlowsTest.ml

@@ -36,12 +36,11 @@ let assert_fixpoint
     |> DependencyGraph.union overrides
     |> DependencyGraph.reverse
   in
-  let analyses = [TaintAnalysis.abstract_kind] in
   let iterations =
     Analysis.compute_fixpoint
       ~scheduler
       ~environment
-      ~analyses
+      ~analysis:TaintAnalysis.abstract_kind
       ~dependencies
       ~filtered_callables:Callable.Set.empty
       ~all_callables:callables_to_analyze