Support autocomplete for objects from another module M.x[....

Fixes #360

Author: cristianoc

CHANGELOG.md

@@ -1,6 +1,7 @@
 ## master
 - Fix issue where using paths of the form `./something` would show multiple copies of the same file in vscode.
 - When hovering on a field access, show the instantiated type of the field.
+- Support autocomplete for objects from another module `M.x[...`.
 
 ## 1.2.1
 

analysis/src/NewCompletions.ml

@@ -672,15 +672,19 @@ let localValueCompletions ~pos ~(env : QueryEnv.t) suffix =
                {(emptyDeclared c.cname.txt) with item = Constructor (c, t)}))
     else results
   in
-  if suffix = "" || not (isCapitalized suffix) then
-    results
-    @ completionForDeclareds ~pos env.file.stamps.values suffix (fun v ->
-          Value v)
-    @ completionForDeclareds ~pos env.file.stamps.types suffix (fun t -> Type t)
-    @ (completionForFields env.exported.types env.file.stamps.types suffix
-      |> List.map (fun (f, t) ->
-             {(emptyDeclared f.fname.txt) with item = Field (f, t)}))
-  else results
+  let results =
+    if suffix = "" || not (isCapitalized suffix) then
+      results
+      @ completionForDeclareds ~pos env.file.stamps.values suffix (fun v ->
+            Value v)
+      @ completionForDeclareds ~pos env.file.stamps.types suffix (fun t ->
+            Type t)
+      @ (completionForFields env.exported.types env.file.stamps.types suffix
+        |> List.map (fun (f, t) ->
+               {(emptyDeclared f.fname.txt) with item = Field (f, t)}))
+    else results
+  in
+  results |> List.map (fun r -> (r, env))
 
 let valueCompletions ~(env : QueryEnv.t) suffix =
   Log.log (" - Completing in " ^ Uri2.toString env.file.uri);
@@ -705,17 +709,20 @@ let valueCompletions ~(env : QueryEnv.t) suffix =
                {(emptyDeclared c.cname.txt) with item = Constructor (c, t)})))
     else results
   in
-  if suffix = "" || not (isCapitalized suffix) then (
-    Log.log " -- not capitalized";
-    results
-    @ completionForExporteds env.exported.values env.file.stamps.values suffix
-        (fun v -> Value v)
-    @ completionForExporteds env.exported.types env.file.stamps.types suffix
-        (fun t -> Type t)
-    @ (completionForFields env.exported.types env.file.stamps.types suffix
-      |> List.map (fun (f, t) ->
-             {(emptyDeclared f.fname.txt) with item = Field (f, t)})))
-  else results
+  let results =
+    if suffix = "" || not (isCapitalized suffix) then (
+      Log.log " -- not capitalized";
+      results
+      @ completionForExporteds env.exported.values env.file.stamps.values suffix
+          (fun v -> Value v)
+      @ completionForExporteds env.exported.types env.file.stamps.types suffix
+          (fun t -> Type t)
+      @ (completionForFields env.exported.types env.file.stamps.types suffix
+        |> List.map (fun (f, t) ->
+               {(emptyDeclared f.fname.txt) with item = Field (f, t)})))
+    else results
+  in
+  results |> List.map (fun r -> (r, env))
 
 let attributeCompletions ~(env : QueryEnv.t) ~suffix =
   let results = [] in
@@ -726,15 +733,18 @@ let attributeCompletions ~(env : QueryEnv.t) ~suffix =
           suffix (fun m -> Module m)
     else results
   in
-  if suffix = "" || not (isCapitalized suffix) then
-    results
-    @ completionForExporteds env.exported.values env.file.stamps.values suffix
-        (fun v -> Value v)
-    (* completionForExporteds(env.exported.types, env.file.stamps.types, suffix, t => Type(t)) @ *)
-    @ (completionForFields env.exported.types env.file.stamps.types suffix
-      |> List.map (fun (f, t) ->
-             {(emptyDeclared f.fname.txt) with item = Field (f, t)}))
-  else results
+  let results =
+    if suffix = "" || not (isCapitalized suffix) then
+      results
+      @ completionForExporteds env.exported.values env.file.stamps.values suffix
+          (fun v -> Value v)
+      (* completionForExporteds(env.exported.types, env.file.stamps.types, suffix, t => Type(t)) @ *)
+      @ (completionForFields env.exported.types env.file.stamps.types suffix
+        |> List.map (fun (f, t) ->
+               {(emptyDeclared f.fname.txt) with item = Field (f, t)}))
+    else results
+  in
+  results |> List.map (fun r -> (r, env))
 
 (* TODO filter out things that are defined after the current position *)
 let resolveRawOpens ~env ~rawOpens ~package =
@@ -804,7 +814,7 @@ let getItems ~full ~rawOpens ~allFiles ~pos ~dotpath =
            (fun results env ->
              let completionsFromThisOpen = valueCompletions ~env suffix in
              List.filter
-               (fun declared ->
+               (fun (declared, _env) ->
                  if Hashtbl.mem alreadyUsedIdentifiers declared.name.txt then
                    false
                  else (
@@ -819,7 +829,7 @@ let getItems ~full ~rawOpens ~allFiles ~pos ~dotpath =
       allFiles |> FileSet.elements
       |> Utils.filterMap (fun name ->
              if Utils.startsWith name suffix && not (String.contains name '-')
-             then Some {(emptyDeclared name) with item = FileModule name}
+             then Some ({(emptyDeclared name) with item = FileModule name}, env)
              else None)
     in
     locallyDefinedValues @ valuesFromOpens @ localModuleNames
@@ -863,15 +873,16 @@ let getItems ~full ~rawOpens ~allFiles ~pos ~dotpath =
                    (Some (env, fields, typ))
             with
             | None -> []
-            | Some (_env, fields, typ) ->
+            | Some (env, fields, typ) ->
               fields
               |> Utils.filterMap (fun field ->
                      if Utils.startsWith field.fname.txt lastField then
                        Some
-                         {
-                           (emptyDeclared field.fname.txt) with
-                           item = Field (field, typ);
-                         }
+                         ( {
+                             (emptyDeclared field.fname.txt) with
+                             item = Field (field, typ);
+                           },
+                           env )
                      else None))))
       | None -> [])
     | QualifiedRecordAccess path -> (
@@ -924,7 +935,7 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
     let declareds = processDotPath ~exact:true (componentPath @ ["make"]) in
     let labels =
       match declareds with
-      | {SharedTypes.item = Value typ} :: _ ->
+      | ({SharedTypes.item = Value typ}, _env) :: _ ->
         let rec getFields (texp : Types.type_expr) =
           match texp.desc with
           | Tfield (name, _, t1, t2) ->
@@ -984,7 +995,9 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
     (* TODO(#107): figure out why we're getting duplicates. *)
     declareds |> Utils.dedup
     |> List.map
-         (fun {SharedTypes.name = {txt = name}; deprecated; docstring; item} ->
+         (fun
+           ({SharedTypes.name = {txt = name}; deprecated; docstring; item}, _env)
+         ->
            mkItem ~name ~kind:(kindToInt item) ~deprecated
              ~detail:(detail name item) ~docstring)
   | Cpipe (pipe, partialName) -> (
@@ -1044,8 +1057,7 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
       match String.split_on_char '.' pipeId with
       | x :: fieldNames -> (
         match [x] |> processDotPath ~exact:true with
-        | {SharedTypes.item = Value typ} :: _ -> (
-          let env = QueryEnv.fromFile full.file in
+        | ({SharedTypes.item = Value typ}, env) :: _ -> (
           match getFields ~env ~typ fieldNames with
           | None -> None
           | Some (typ1, _env1) -> fromType typ1)
@@ -1096,10 +1108,12 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
         let dotpath = modulePath @ [partialName] in
         let declareds = dotpath |> processDotPath ~exact:false in
         declareds
-        |> List.filter (fun {item} ->
+        |> List.filter (fun ({item}, _env) ->
                match item with Value _ -> true | _ -> false)
         |> List.map
-             (fun {SharedTypes.name = {txt = name}; deprecated; docstring; item}
+             (fun
+               ( {SharedTypes.name = {txt = name}; deprecated; docstring; item},
+                 _env )
              ->
                mkItem ~name:(completionName name) ~kind:(kindToInt item)
                  ~detail:(detail name item) ~deprecated ~docstring)
@@ -1152,7 +1166,7 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
   | Clabel (funPath, prefix, identsSeen) ->
     let labels =
       match funPath |> processDotPath ~exact:true with
-      | {SharedTypes.item = Value typ} :: _ ->
+      | ({SharedTypes.item = Value typ}, _env) :: _ ->
         let rec getLabels (t : Types.type_expr) =
           match t.desc with
           | Tlink t1 | Tsubst t1 -> getLabels t1
@@ -1200,8 +1214,8 @@ let processCompletable ~processDotPath ~full ~package ~rawOpens
     in
     let env0 = QueryEnv.fromFile full.file in
     let env, fields =
-      match [lhs] |> processDotPath ~exact:true with
-      | {SharedTypes.item = Value typ} :: _ -> getObjectFields ~env:env0 typ
+      match lhs |> processDotPath ~exact:true with
+      | ({SharedTypes.item = Value typ}, env) :: _ -> getObjectFields ~env typ
       | _ -> (env0, [])
     in
     let labels = resolvePath ~env fields path in
@@ -1225,7 +1239,9 @@ let getCompletable ~textOpt ~pos =
       match PartialParser.findCompletable text offset with
       | None -> None
       | Some completable ->
-        let rawOpens = PartialParser.findOpens text offset in
+        let offsetFromLineStart = offset - snd pos in
+        (* try to avoid confusion e.g. unclosed quotes at current position *)
+        let rawOpens = PartialParser.findOpens text offsetFromLineStart in
         Some (completable, rawOpens)))
 
 let computeCompletions ~completable ~full ~pos ~rawOpens =
@@ -1239,17 +1255,17 @@ let computeCompletions ~completable ~full ~pos ~rawOpens =
          Take the last position before pos if any, or just return the first element. *)
       let rec prioritize decls =
         match decls with
-        | d1 :: d2 :: rest ->
+        | (d1, e1) :: (d2, e2) :: rest ->
           let pos2 = d2.extentLoc.loc_start |> Utils.tupleOfLexing in
-          if pos2 >= pos then prioritize (d1 :: rest)
+          if pos2 >= pos then prioritize ((d1, e1) :: rest)
           else
             let pos1 = d1.extentLoc.loc_start |> Utils.tupleOfLexing in
-            if pos1 <= pos2 then prioritize (d2 :: rest)
-            else prioritize (d1 :: rest)
+            if pos1 <= pos2 then prioritize ((d2, e2) :: rest)
+            else prioritize ((d1, e1) :: rest)
         | [] | [_] -> decls
       in
       declareds
-      |> List.filter (fun {SharedTypes.name = {txt}} -> txt = last)
+      |> List.filter (fun ({SharedTypes.name = {txt}}, _env) -> txt = last)
       |> prioritize
     | _ -> declareds
   in

analysis/src/PartialParser.ml

@@ -190,8 +190,8 @@ type completable =
   | Cdotpath of string list  (** e.g. ["M", "foo"] for M.foo *)
   | Cjsx of string list * string * string list
       (** E.g. (["M", "Comp"], "id", ["id1", "id2"]) for <M.Comp id1=... id2=... ... id *)
-  | Cobj of string * string list * string
-      (** e.g. ("foo", ["a", "b"], "bar") for foo["a"]["b"]["bar" *)
+  | Cobj of string list * string list * string
+      (** e.g. (["M", "foo"], ["a", "b"], "bar") for M.foo["a"]["b"]["bar" *)
   | Cpipe of pipe * string  (** E.g. ("x", "foo") for "x->foo" *)
 
 let isLowercaseIdent id =
@@ -238,18 +238,23 @@ let findCompletable text offset =
   let mkObj ~off ~partialName =
     let off = skipWhite text off in
     let rec loop off path i =
-      if i < 0 then Some ([], String.sub text 0 (i - 1))
+      if i < 0 then
+        let id = String.sub text 0 (i - 1) in
+        Some ([], [id])
       else
         match text.[i] with
-        | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' -> loop off path (i - 1)
+        | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '.' ->
+          loop off path (i - 1)
         | ']' when i > 1 && text.[i - 1] = '"' ->
           let i0 = i - 2 in
           let i1 = startOfLident text i0 in
           let ident = String.sub text i1 (i0 - i1 + 1) in
           if ident <> "" && i1 > 1 && text.[i1 - 1] = '"' && text.[i1 - 2] = '['
           then loop (off - i + i1 - 3) (ident :: path) (i1 - 3)
           else None
-        | _ -> Some (path, String.sub text (i + 1) (off - i))
+        | _ ->
+          let id = String.sub text (i + 1) (off - i) in
+          Some (path, Str.split (Str.regexp_string ".") id)
     in
     match loop off [] off with
     | None -> None

analysis/tests/src/Completion.res

@@ -98,3 +98,5 @@ let make = () => {
 // ^com my
   <> </>
 }
+
+// ^com Obj.object["

analysis/tests/src/Obj.res

@@ -7,3 +7,5 @@ module Rec = {
 
   let recordVal: recordt = assert false
 }
+
+let object: objT = {"name": "abc", "age": 4}

analysis/tests/src/expected/Completion.res.txt

@@ -729,3 +729,18 @@ Complete tests/src/Completion.res 96:3
     "documentation": null
   }]
 
+Complete tests/src/Completion.res 100:3
+[{
+    "label": "name",
+    "kind": 4,
+    "tags": [],
+    "detail": "string",
+    "documentation": null
+  }, {
+    "label": "age",
+    "kind": 4,
+    "tags": [],
+    "detail": "int",
+    "documentation": null
+  }]
+