Keep information on whether a value definition is type annotated.

Author: cristianoc

analysis/src/Hover.ml

@@ -41,8 +41,8 @@ let newHover ~full:{file; package} locItem =
   | TypeDefinition (name, decl, _stamp) ->
     let typeDef = Shared.declToString name decl in
     Some (codeBlock typeDef)
-  | LModule (Definition (stamp, _tip)) | LModule (LocalReference (stamp, _tip))
-    -> (
+  | LModule (Definition (stamp, _tip, _))
+  | LModule (LocalReference (stamp, _tip)) -> (
     match Stamps.findModule file.stamps stamp with
     | None -> None
     | Some md -> (
@@ -85,7 +85,7 @@ let newHover ~full:{file; package} locItem =
     | Some file ->
       showModule ~docstring:file.structure.docstring ~name:file.moduleName ~file
         None)
-  | Typed (_, _, Definition (_, (Field _ | Constructor _))) -> None
+  | Typed (_, _, Definition (_, (Field _ | Constructor _), _)) -> None
   | Constant t ->
     Some
       (codeBlock

analysis/src/ProcessAttributes.ml

@@ -34,14 +34,15 @@ let rec findDeprecatedAttribute attributes =
   | ({Asttypes.txt = "deprecated"}, _) :: _ -> Some ""
   | _ :: rest -> findDeprecatedAttribute rest
 
-let newDeclared ~item ~scope ~extent ~name ~stamp ~modulePath isExported
-    attributes =
+let newDeclared ~item ~scope ~extent ~name ~stamp ~modulePath ~isExported
+    ?(isTypeAnnotated = false) attributes =
   {
     Declared.name;
     stamp;
     extentLoc = extent;
     scopeLoc = scope;
     isExported;
+    isTypeAnnotated;
     modulePath;
     deprecated = findDeprecatedAttribute attributes;
     docstring =

analysis/src/ProcessCmt.ml

@@ -22,7 +22,7 @@ let sigItemsExtent items =
   items |> List.map (fun item -> item.Typedtree.sig_loc) |> locsExtent
 
 let addItem ~(name : string Location.loc) ~extent ~stamp ~(env : Env.t) ~item
-    attributes addExported addStamp =
+    ?(isTypeAnnotated = false) attributes addExported addStamp =
   let isExported = addExported name.txt stamp in
   let declared =
     ProcessAttributes.newDeclared ~item
@@ -32,7 +32,8 @@ let addItem ~(name : string Location.loc) ~extent ~stamp ~(env : Env.t) ~item
           loc_end = env.scope.loc_end;
           loc_ghost = false;
         }
-      ~extent ~name ~stamp ~modulePath:env.modulePath isExported attributes
+      ~extent ~name ~stamp ~modulePath:env.modulePath ~isExported
+      ~isTypeAnnotated attributes
   in
   addStamp env.stamps stamp declared;
   declared
@@ -45,7 +46,8 @@ let rec forTypeSignatureItem ~env ~(exported : Exported.t)
     let declared =
       addItem
         ~name:(Location.mknoloc (Ident.name ident))
-        ~extent:loc ~stamp:(Ident.binding_time ident) ~env ~item val_attributes
+        ~extent:loc ~stamp:(Ident.binding_time ident) ~env ~item
+        ~isTypeAnnotated:true val_attributes
         (Exported.add exported Exported.Value)
         Stamps.addValue
     in
@@ -107,7 +109,8 @@ let rec forTypeSignatureItem ~env ~(exported : Exported.t)
                                }
                              ~name:(Location.mknoloc name)
                              ~stamp (* TODO maybe this needs another child *)
-                             ~modulePath:env.modulePath true cd_attributes
+                             ~modulePath:env.modulePath ~isExported:true
+                             cd_attributes
                          in
                          Stamps.addConstructor env.stamps stamp declared;
                          item))
@@ -247,7 +250,8 @@ let rec forSignatureItem ~env ~(exported : Exported.t)
     let declared =
       addItem ~name
         ~stamp:(Ident.binding_time val_id)
-        ~extent:val_loc ~item:val_desc.ctyp_type ~env val_attributes
+        ~extent:val_loc ~item:val_desc.ctyp_type ~env ~isTypeAnnotated:true
+        val_attributes
         (Exported.add exported Exported.Value)
         Stamps.addValue
     in
@@ -341,6 +345,10 @@ let rec getModulePath mod_desc =
   | Tmod_constraint (expr, _typ, _constraint, _coercion) ->
     getModulePath expr.mod_desc
 
+let patIsTypeAnnotated pat =
+  pat.pat_extra
+  |> List.exists (function Tpat_constraint _, _, _ -> true | _ -> false)
+
 let rec forStructureItem ~env ~(exported : Exported.t) item =
   match item.str_desc with
   | Tstr_value (_isRec, bindings) ->
@@ -352,7 +360,8 @@ let rec forStructureItem ~env ~(exported : Exported.t) item =
         let item = pat.pat_type in
         let declared =
           addItem ~name ~stamp:(Ident.binding_time ident) ~env
-            ~extent:pat.pat_loc ~item attributes
+            ~extent:pat.pat_loc ~item ~isTypeAnnotated:(patIsTypeAnnotated pat)
+            attributes
             (Exported.add exported Exported.Value)
             Stamps.addValue
         in
@@ -443,7 +452,7 @@ let rec forStructureItem ~env ~(exported : Exported.t) item =
     let declared =
       addItem ~extent:val_loc ~item:val_type ~name
         ~stamp:(Ident.binding_time val_id)
-        ~env val_attributes
+        ~env ~isTypeAnnotated:true val_attributes
         (Exported.add exported Exported.Value)
         Stamps.addValue
     in
@@ -495,7 +504,8 @@ and forModule env mod_desc moduleName =
                 loc_end = env.scope.loc_end;
                 loc_ghost = false;
               }
-            ~extent:t.Typedtree.mty_loc ~stamp ~modulePath:NotVisible false []
+            ~extent:t.Typedtree.mty_loc ~stamp ~modulePath:NotVisible
+            ~isExported:false []
         in
         Stamps.addModule env.stamps stamp declared));
     forModule env resultExpr.mod_desc moduleName
@@ -629,12 +639,14 @@ let extraForFile ~(file : File.t) =
   in
   file.stamps
   |> Stamps.iterModules (fun stamp (d : Module.t Declared.t) ->
-         addLocItem extra d.name.loc (LModule (Definition (stamp, Module)));
+         addLocItem extra d.name.loc
+           (LModule (Definition (stamp, Module, false)));
          addReference stamp d.name.loc);
   file.stamps
   |> Stamps.iterValues (fun stamp (d : Types.type_expr Declared.t) ->
          addLocItem extra d.name.loc
-           (Typed (d.name.txt, d.item, Definition (stamp, Value)));
+           (Typed
+              (d.name.txt, d.item, Definition (stamp, Value, d.isTypeAnnotated)));
          addReference stamp d.name.loc);
   file.stamps
   |> Stamps.iterTypes (fun stamp (d : Type.t Declared.t) ->
@@ -648,7 +660,9 @@ let extraForFile ~(file : File.t) =
                   addReference stamp fname.loc;
                   addLocItem extra fname.loc
                     (Typed
-                       (d.name.txt, typ, Definition (d.stamp, Field fname.txt))))
+                       ( d.name.txt,
+                         typ,
+                         Definition (d.stamp, Field fname.txt, false) )))
          | Variant constructors ->
            constructors
            |> List.iter (fun {Constructor.stamp; cname} ->
@@ -669,7 +683,7 @@ let extraForFile ~(file : File.t) =
                     (Typed
                        ( d.name.txt,
                          t,
-                         Definition (d.stamp, Constructor cname.txt) )))
+                         Definition (d.stamp, Constructor cname.txt, false) )))
          | _ -> ());
   extra
 
@@ -1002,12 +1016,13 @@ struct
                 loc_start = val_loc.loc_end;
                 loc_end = (currentScopeExtent ()).loc_end;
               }
-            ~modulePath:NotVisible ~item:val_desc.ctyp_type false val_attributes
+            ~modulePath:NotVisible ~item:val_desc.ctyp_type ~isExported:false
+            ~isTypeAnnotated:true val_attributes
         in
         Stamps.addValue Collector.file.stamps stamp declared;
         addReference stamp name.loc;
         addLocItem extra name.loc
-          (Typed (name.txt, val_desc.ctyp_type, Definition (stamp, Value))))
+          (Typed (name.txt, val_desc.ctyp_type, Definition (stamp, Value, true))))
     | _ -> ()
 
   let enter_core_type {ctyp_type; ctyp_desc} =
@@ -1016,7 +1031,7 @@ struct
       addForLongident (Some (ctyp_type, Type)) path txt loc
     | _ -> ()
 
-  let enter_pattern {pat_desc; pat_loc; pat_type; pat_attributes} =
+  let enter_pattern ({pat_desc; pat_loc; pat_type; pat_attributes} as pat) =
     let addForPattern stamp name =
       if Stamps.findValue Collector.file.stamps stamp = None then (
         let declared =
@@ -1027,13 +1042,14 @@ struct
                 loc_start = pat_loc.loc_end;
                 loc_end = (currentScopeExtent ()).loc_end;
               }
-            ~modulePath:NotVisible ~extent:pat_loc ~item:pat_type false
+            ~modulePath:NotVisible ~extent:pat_loc ~item:pat_type
+            ~isExported:false ~isTypeAnnotated:(patIsTypeAnnotated pat)
             pat_attributes
         in
         Stamps.addValue Collector.file.stamps stamp declared;
         addReference stamp name.loc;
         addLocItem extra name.loc
-          (Typed (name.txt, pat_type, Definition (stamp, Value))))
+          (Typed (name.txt, pat_type, Definition (stamp, Value, false))))
     in
     (* Log.log("Entering pattern " ++ Utils.showLocation(pat_loc)); *)
     match pat_desc with

analysis/src/References.ml

@@ -67,7 +67,7 @@ let getLocItem ~full ~line ~col =
     Some li3
   | [
    {locType = Typed (_, _, LocalReference (_, Value))};
-   ({locType = Typed (_, _, Definition (_, Value))} as li2);
+   ({locType = Typed (_, _, Definition (_, Value, _))} as li2);
   ] ->
     (* JSX on type-annotated labeled (~arg:t):
        (~arg:t) becomes Props#arg
@@ -138,7 +138,7 @@ let definedForLoc ~file ~package locKind =
   in
   match locKind with
   | NotFound -> None
-  | LocalReference (stamp, tip) | Definition (stamp, tip) ->
+  | LocalReference (stamp, tip) | Definition (stamp, tip, _) ->
     inner ~file stamp tip
   | GlobalReference (moduleName, path, tip) -> (
     maybeLog ("Getting global " ^ moduleName);
@@ -306,7 +306,7 @@ let definition ~file ~package stamp (tip : Tip.t) =
 
 let definitionForLocItem ~full:{file; package} locItem =
   match locItem.locType with
-  | Typed (_, _, Definition (stamp, tip)) -> (
+  | Typed (_, _, Definition (stamp, tip, _)) -> (
     maybeLog
       ("Typed Definition stamp:" ^ string_of_int stamp ^ " tip:"
      ^ Tip.toString tip);
@@ -323,7 +323,7 @@ let definitionForLocItem ~full:{file; package} locItem =
           Some (file.uri, loc))
       else None)
   | Typed (_, _, NotFound)
-  | LModule (NotFound | Definition (_, _))
+  | LModule (NotFound | Definition _)
   | TypeDefinition (_, _, _)
   | Constant _ ->
     None
@@ -530,8 +530,8 @@ let allReferencesForLocItem ~full:({file; package} as full) locItem =
     List.append targetModuleReferences otherModulesReferences
   | Typed (_, _, NotFound) | LModule NotFound | Constant _ -> []
   | TypeDefinition (_, _, stamp) -> forLocalStamp ~full stamp Type
-  | Typed (_, _, (LocalReference (stamp, tip) | Definition (stamp, tip)))
-  | LModule (LocalReference (stamp, tip) | Definition (stamp, tip)) ->
+  | Typed (_, _, (LocalReference (stamp, tip) | Definition (stamp, tip, _)))
+  | LModule (LocalReference (stamp, tip) | Definition (stamp, tip, _)) ->
     maybeLog
       ("Finding references for " ^ Uri2.toString file.uri ^ " and stamp "
      ^ string_of_int stamp ^ " and tip " ^ Tip.toString tip);

analysis/src/SharedTypes.ml

@@ -132,6 +132,7 @@ module Declared = struct
     stamp : int;
     modulePath : modulePath;
     isExported : bool;
+    isTypeAnnotated : bool;
     deprecated : string option;
     docstring : string list;
     item : 'item;
@@ -297,7 +298,7 @@ type locKind =
   | LocalReference of int * Tip.t
   | GlobalReference of string * string list * Tip.t
   | NotFound
-  | Definition of int * Tip.t
+  | Definition of int * Tip.t * (* whether it is type annotated *) bool
 
 type locType =
   | Typed of string * Types.type_expr * locKind
@@ -370,7 +371,8 @@ let locKindToString = function
   | LocalReference (_, tip) -> "(LocalReference " ^ Tip.toString tip ^ ")"
   | GlobalReference _ -> "GlobalReference"
   | NotFound -> "NotFound"
-  | Definition (_, tip) -> "(Definition " ^ Tip.toString tip ^ ")"
+  | Definition (_, tip, _hasTypeAnnotation) ->
+    "(Definition " ^ Tip.toString tip ^ ")"
 
 let locTypeToString = function
   | Typed (name, e, locKind) ->