Infer: improve the type specificity in TypeInferenceData

Summary:
It came up in review of a separate diff that our types did not clearly
express that attributes and globals always have nonmissing annotations.

This diff fixes that by separating optional type annotations from required
ones. It's a little ugly to need a type synonym for `Type.t`, but as far
as I can tell from skimming the docs there's no way to get a derived
`to_yojson` otherwise, and if the choice is between a type synonym or
a bunch of hand-rolled json serialization I think the former is better.

Reviewed By: dkgi

Differential Revision: D28939568

fbshipit-source-id: ffd76acd4a123cd9b6c9fbe297d7046c8c95ec6f

Author: stroxler

source/interprocedural_analyses/type_inference/test/typeInferenceLocalTest.ml

@@ -141,19 +141,23 @@ let check_inference_results ~context ~checks source =
   Memory.reset_shared_memory ()
 
 
+let get_inferred = function
+  | TypeAnnotation.Inferred inferred -> Some inferred
+  | TypeAnnotation.Given _
+  | TypeAnnotation.Missing ->
+      None
+
+
 let test_inferred_returns context =
   let check_return_annotation ~define_name ~expected source =
-    let check
-        ( { LocalResult.define = { DefineAnnotation.return = { TypeAnnotation.inferred; _ }; _ }; _ }
-        as result )
-      =
+    let check ({ LocalResult.define = { DefineAnnotation.return; _ }; _ } as result) =
       Asserts.assert_inference_result
         ~context
         ~result
         ~details:"Checking inferred return annotation"
         ~source
         ~expected:(Some expected)
-        ~actual:inferred
+        ~actual:(get_inferred return)
     in
     check_inference_results ~context ~checks:[Setup.make_function define_name, check] source
   in
@@ -170,7 +174,7 @@ let test_inferred_parameters context =
   let open DefineAnnotation.Parameters in
   let check_parameter_annotation ~define_name ~parameter_name ~expected source =
     let check ({ LocalResult.define = { DefineAnnotation.parameters; _ }; _ } as result) =
-      let { Value.annotation = { TypeAnnotation.inferred; _ }; _ } =
+      let { Value.annotation; _ } =
         Asserts.find_by_name ("$parameter$" ^ parameter_name) parameters
       in
       Asserts.assert_inference_result
@@ -179,7 +183,7 @@ let test_inferred_parameters context =
         ~details:("Checking inferred annotation for parameter " ^ parameter_name)
         ~source
         ~expected:(Some expected)
-        ~actual:inferred
+        ~actual:(get_inferred annotation)
     in
     check_inference_results ~context ~checks:[Setup.make_function define_name, check] source
   in
@@ -197,16 +201,14 @@ let test_inferred_globals context =
   let check_global_annotation ~define_name ~global_name ~expected source =
     let open GlobalAnnotation in
     let check ({ LocalResult.globals; _ } as result) =
-      let { Value.annotation = { TypeAnnotation.inferred; _ }; _ } =
-        Asserts.find_by_name global_name globals
-      in
+      let { Value.annotation; _ } = Asserts.find_by_name global_name globals in
       Asserts.assert_inference_result
         ~context
         ~result
         ~details:("Checking inferred annotation for global " ^ global_name)
         ~source
         ~expected:(Some expected)
-        ~actual:inferred
+        ~actual:(Some annotation)
     in
     check_inference_results ~context ~checks:[Setup.make_function define_name, check] source
   in
@@ -223,16 +225,14 @@ let test_inferred_attributes context =
   let check_attribute_annotation ~define_name ~attribute_name ~expected source =
     let open AttributeAnnotation in
     let check ({ LocalResult.attributes; _ } as result) =
-      let { Value.annotation = { TypeAnnotation.inferred; _ }; _ } =
-        Asserts.find_by_name attribute_name attributes
-      in
+      let { Value.annotation; _ } = Asserts.find_by_name attribute_name attributes in
       Asserts.assert_inference_result
         ~context
         ~result
         ~details:("Checking inferred annotation for attribute " ^ attribute_name)
         ~source
         ~expected:(Some expected)
-        ~actual:inferred
+        ~actual:(Some annotation)
     in
     check_inference_results ~context ~checks:[Setup.make_function define_name, check] source
   in

source/interprocedural_analyses/type_inference/typeInferenceData.ml

@@ -64,43 +64,56 @@ module AnnotationLocation = struct
     create ~lookup ~qualifier ~line
 end
 
+module SerializableType = struct
+  type t = Type.t [@@deriving show, eq]
+
+  let to_yojson type_ = `String (type_to_string type_)
+end
+
 module TypeAnnotation = struct
-  type t = {
-    inferred: Type.t option;
-    given: Type.t option;
-  }
+  type t =
+    | Inferred of SerializableType.t
+    | Given of SerializableType.t
+    | Missing
   [@@deriving show, eq]
 
-  let is_inferred annotation = Option.is_some annotation.inferred
+  let is_inferred = function
+    | Inferred _ -> true
+    | Given _
+    | Missing ->
+        false
 
-  let combine_with ~f left right =
-    {
-      inferred =
-        ( match left.inferred, right.inferred with
-        | Some left, Some right -> Some (f left right)
-        | None, right -> right
-        | left, None -> left );
-      given = (if Option.is_some left.given then left.given else right.given);
-    }
 
+  let from_given ~global_resolution expression =
+    let parser = GlobalResolution.annotation_parser global_resolution in
+    match expression >>| parser.parse_annotation with
+    | Some type_ -> Given type_
+    | None -> Missing
 
-  let join ~global_resolution = combine_with ~f:(GlobalResolution.join global_resolution)
 
-  let meet ~global_resolution = combine_with ~f:(GlobalResolution.meet global_resolution)
+  let from_inferred type_ = Inferred type_
+
+  let merge ~f left right =
+    match left, right with
+    | Inferred left, Inferred right -> Inferred (f left right)
+    | Inferred type_, _
+    | _, Inferred type_ ->
+        Inferred type_
+    | Given type_, _
+    | _, Given type_ ->
+        Given type_
+    | Missing, Missing -> Missing
 
-  let from_given ~global_resolution given =
-    let parser = GlobalResolution.annotation_parser global_resolution in
-    let given = given >>| parser.parse_annotation in
-    { inferred = None; given }
 
+  let join ~global_resolution = merge ~f:(GlobalResolution.join global_resolution)
 
-  let from_inferred inferred = { inferred = Some inferred; given = None }
+  let meet ~global_resolution = merge ~f:(GlobalResolution.meet global_resolution)
 
-  let to_yojson { inferred; given } =
-    match inferred, given with
-    | Some inferred, _ -> `String (type_to_string inferred)
-    | None, Some given -> `String (type_to_string given)
-    | _ -> `Null
+  let to_yojson = function
+    | Inferred type_
+    | Given type_ ->
+        SerializableType.to_yojson type_
+    | Missing -> `Null
 end
 
 module AnnotationsByName = struct
@@ -182,7 +195,7 @@ module GlobalAnnotation = struct
     type t = {
       name: SerializableReference.t;
       location: AnnotationLocation.t;
-      annotation: TypeAnnotation.t;
+      annotation: SerializableType.t;
     }
     [@@deriving show, eq, to_yojson]
 
@@ -199,7 +212,7 @@ module GlobalAnnotation = struct
     let combine ~global_resolution left right =
       {
         left with
-        annotation = TypeAnnotation.join ~global_resolution left.annotation right.annotation;
+        annotation = GlobalResolution.join global_resolution left.annotation right.annotation;
       }
   end
 
@@ -213,7 +226,7 @@ module AttributeAnnotation = struct
       parent: SerializableReference.t;
       name: SerializableReference.t;
       location: AnnotationLocation.t;
-      annotation: TypeAnnotation.t;
+      annotation: SerializableType.t;
     }
     [@@deriving show, eq, to_yojson]
 
@@ -230,7 +243,7 @@ module AttributeAnnotation = struct
     let combine ~global_resolution left right =
       {
         left with
-        annotation = TypeAnnotation.join ~global_resolution left.annotation right.annotation;
+        annotation = GlobalResolution.join global_resolution left.annotation right.annotation;
       }
   end
 
@@ -412,7 +425,7 @@ module LocalResult = struct
               {
                 parent = type_to_reference parent;
                 name;
-                annotation = TypeAnnotation.from_inferred type_;
+                annotation = type_;
                 location = error.location |> AnnotationLocation.from_location_with_module ~lookup;
               };
         }
@@ -425,7 +438,7 @@ module LocalResult = struct
               globals
               {
                 name;
-                annotation = TypeAnnotation.from_inferred type_;
+                annotation = type_;
                 location = error.location |> AnnotationLocation.from_location_with_module ~lookup;
               };
         }