Complete list literal elements from the list's element type (#9263)

Why:
    Completion inside list{…} lost the element type: an annotation
    list<kind> became the context path Type[list], extract_type had no
    case for list<'a>, and the [::] chain of a literal was walked as
    constructor payloads. The analysis now has a list type, context path
    and nested path next to the array ones; a [::] head is an element,
    its tail the rest of the list, and the [] at its end, which holds
    the cursor in list{} and list{a, }, a new element.

Example:
    type kind = First | Second
    let ys: list<kind> = list{First, Se}

Before (completable):
    Cexpression Type[list]=Se->variantPayload::::($1), variantPayload::::($0)
After (completable):
    Cexpression list<Type[kind]>=Se->list

Before (completions): module Set
After (completions): Second, module Set

Review: Does `list{...xs, }` complete an element now? No: a trailing
    spread is the tail of the [::] chain, so the parser yields plain `xs`
    and no element position is left, as #9212 notes.

Fixes #9212


Claude-Session: https://claude.ai/code/session_01Kbf3gJuq6rWZULJVY3ATmY

Signed-off-by: Christoph Knittel <ck@cca.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: cknitt

analysis/src/completion_back_end.ml

@@ -968,6 +968,12 @@ and get_completions_for_context_path ~state ~debug ~full ~opens ~raw_opens ~pos
       Completion.create "array" ~env
         ~kind:(Completion.Value (Ctype.newconstr Predef.path_array []));
     ]
+  | CPList None ->
+    if Debug.verbose () then print_endline "[ctx_path]--> CPList (no payload)";
+    [
+      Completion.create "list" ~env
+        ~kind:(Completion.Value (Ctype.newconstr Predef.path_list []));
+    ]
   | CPDict None ->
     if Debug.verbose () then print_endline "[ctx_path]--> CPDict (no payload)";
     [
@@ -998,9 +1004,16 @@ and get_completions_for_context_path ~state ~debug ~full ~opens ~raw_opens ~pos
         Completion.create "dummy" ~env
           ~kind:(Completion.Value (Ctype.newconstr Predef.path_dict []));
       ])
-  | CPArray (Some cp) -> (
+  | (CPArray (Some cp) | CPList (Some cp)) as context_path -> (
+    let is_list =
+      match context_path with
+      | CPList _ -> true
+      | _ -> false
+    in
     if Debug.verbose () then
-      print_endline "[ctx_path]--> CPArray (with payload)";
+      print_endline
+        (if is_list then "[ctx_path]--> CPList (with payload)"
+         else "[ctx_path]--> CPArray (with payload)");
     match mode with
     | Regular -> (
       match
@@ -1014,14 +1027,21 @@ and get_completions_for_context_path ~state ~debug ~full ~opens ~raw_opens ~pos
         [
           Completion.create "dummy" ~env
             ~kind:
-              (Completion.ExtractedType (Tarray (env, ExtractedType typ), `Type));
+              (Completion.ExtractedType
+                 ( (if is_list then Tlist (env, ExtractedType typ)
+                    else Tarray (env, ExtractedType typ)),
+                   `Type ));
         ])
     | Pipe ->
-      (* Pipe completion with array just needs to know that it's an array, not
-         what inner type it has. *)
+      (* Pipe completion with an array or a list just needs to know which one
+         it is, not what inner type it has. *)
       [
         Completion.create "dummy" ~env
-          ~kind:(Completion.Value (Ctype.newconstr Predef.path_array []));
+          ~kind:
+            (Completion.Value
+               (Ctype.newconstr
+                  (if is_list then Predef.path_list else Predef.path_array)
+                  []));
       ])
   | CPOption cp -> (
     if Debug.verbose () then print_endline "[ctx_path]--> CPOption";
@@ -1947,6 +1967,24 @@ let rec complete_typed_value ~raw_opens ~full ~state ~prefix ~completion_context
           ~env;
       ]
     else []
+  | Tlist (env, typ) as extracted_type ->
+    if Debug.verbose () then print_endline "[complete_typed_value]--> Tlist";
+    if prefix = "" then
+      [
+        create "list{}" ~includes_snippets:true ~insert_text:"list{$0}"
+          ~sort_text:"A"
+          ~kind:
+            (match typ with
+            | ExtractedType _ ->
+              ExtractedType
+                ( extracted_type,
+                  match mode with
+                  | Pattern _ -> `Type
+                  | Expression -> `Value )
+            | TypeExpr typ -> Value (Ctype.newconstr Predef.path_list [typ]))
+          ~env;
+      ]
+    else []
   | Tdict (env, typ) as extracted_type ->
     if Debug.verbose () then print_endline "[complete_typed_value]--> Tdict";
     if prefix = "" then

analysis/src/completion_expressions.ml

@@ -20,6 +20,23 @@ let rec traverse_expr (exp : Parsetree.expression) ~expr_path ~pos
     traverse_expr expr ~expr_path ~pos ~first_char_before_cursor_no_white
   | Pexp_ident {txt = Lident txt} -> some_if_has_cursor (txt, expr_path)
   | Pexp_construct ({txt = Lident "()"}, _) -> some_if_has_cursor ("", expr_path)
+  | Pexp_construct ({txt = Lident "::"}, {txt = [head; tail]})
+    when loc_has_cursor exp.pexp_loc -> (
+    (* A list literal is a chain of [::]: complete its head as an element,
+       and its tail as the rest of the list. *)
+    match
+      head
+      |> traverse_expr
+           ~expr_path:([Completable.NList] @ expr_path)
+           ~first_char_before_cursor_no_white ~pos
+    with
+    | Some _ as item_with_cursor -> item_with_cursor
+    | None ->
+      tail |> traverse_expr ~expr_path ~first_char_before_cursor_no_white ~pos)
+  | Pexp_construct ({txt = Lident "[]"}, {txt = []}) ->
+    (* The end of a list literal, which holds the cursor at a new element:
+       `list{<com>}` or `list{a, <com>}` *)
+    some_if_has_cursor ("", [Completable.NList] @ expr_path)
   | Pexp_construct ({txt = Lident txt}, {txt = []}) ->
     some_if_has_cursor (txt, expr_path)
   | Pexp_variant (label, {txt = []}) ->
@@ -47,10 +64,15 @@ let rec traverse_expr (exp : Parsetree.expression) ~expr_path ~pos
            `[None, <com>, None]`) *)
         Some ("", next_expr_path)
       | _ -> None)
-  | Pexp_spread (Spread_array, elements) -> (
-    (* Complete an item like an element of an array literal, and a spread
-       operand like the whole literal, whose type it has. *)
-    let next_expr_path = [Completable.NArray] @ expr_path in
+  | Pexp_spread (kind, elements) -> (
+    (* Complete an item like an element of the literal, and a spread operand
+       like the whole literal, whose type it has. *)
+    let item_path, opening =
+      match kind with
+      | Spread_array -> (Completable.NArray, '[')
+      | Spread_list -> (NList, '{')
+    in
+    let next_expr_path = [item_path] @ expr_path in
     let item_with_cursor =
       elements
       |> List.find_map (function
@@ -66,7 +88,7 @@ let rec traverse_expr (exp : Parsetree.expression) ~expr_path ~pos
     | None
       when loc_has_cursor exp.pexp_loc
            && (first_char_before_cursor_no_white = Some ','
-              || first_char_before_cursor_no_white = Some '[')
+              || first_char_before_cursor_no_white = Some opening)
            && not
                 (elements
                 |> List.exists (function
@@ -75,10 +97,6 @@ let rec traverse_expr (exp : Parsetree.expression) ~expr_path ~pos
       (* A new item at the start or after a comma, e.g. `[...xs, <com>]` *)
       Some ("", next_expr_path)
     | None -> None)
-  | Pexp_spread (Spread_list, _) ->
-    (* Like a list literal without a spread, a chain of [::], which gets no
-       typed completion either: the element type of a list is not extracted. *)
-    None
   | Pexp_dict entries -> (
     (* Complete inside the value of the entry with the cursor, or for the type
        of the values at an expression hole, e.g. `dict{"a": <com>}` *)

analysis/src/shared_types.ml

@@ -341,6 +341,7 @@ and completion_type =
     }
   | Tbool of Query_env.t
   | Tarray of Query_env.t * inner_type
+  | Tlist of Query_env.t * inner_type
   | Tdict of Query_env.t * inner_type
   | Tstring of Query_env.t
   | TtypeT of {env: Query_env.t; path: Path.t}
@@ -582,6 +583,7 @@ module Completable = struct
         source_arity: int;
       }
     | NArray
+    | NList  (** An element of a list literal *)
     | NDictValue of {optional: bool}
         (** The pattern or expression of a dict entry, [?P] if [optional] *)
 
@@ -597,11 +599,13 @@ module Completable = struct
       "polyvariantPayload::" ^ constructor_name ^ "($" ^ string_of_int item_num
       ^ ")"
     | NArray -> "array"
+    | NList -> "list"
     | NDictValue {optional} -> if optional then "dictValue(?)" else "dictValue"
 
   type context_path =
     | CPString
     | CPArray of context_path option
+    | CPList of context_path option
     | CPDict of context_path option
     | CPInt
     | CPFloat
@@ -704,6 +708,8 @@ module Completable = struct
     | CPArray (Some ctx_path) ->
       "array<" ^ context_path_to_string ctx_path ^ ">"
     | CPArray None -> "array"
+    | CPList (Some ctx_path) -> "list<" ^ context_path_to_string ctx_path ^ ">"
+    | CPList None -> "list"
     | CPDict (Some ctx_path) -> "dict<" ^ context_path_to_string ctx_path ^ ">"
     | CPDict None -> "dict"
     | CPId {path; completion_context} ->

analysis/src/type_utils.ml

@@ -103,6 +103,10 @@ let rec extracted_type_to_string ?(name_only = false) ?(inner = false) =
     "array<" ^ Shared.type_to_string inner_typ ^ ">"
   | Tarray (_, ExtractedType inner_typ) ->
     "array<" ^ extracted_type_to_string ~inner:true inner_typ ^ ">"
+  | Tlist (_, TypeExpr inner_typ) ->
+    "list<" ^ Shared.type_to_string inner_typ ^ ">"
+  | Tlist (_, ExtractedType inner_typ) ->
+    "list<" ^ extracted_type_to_string ~inner:true inner_typ ^ ">"
   | Tdict (_, TypeExpr inner_typ) ->
     "dict<" ^ Shared.type_to_string inner_typ ^ ">"
   | Tdict (_, ExtractedType inner_typ) ->
@@ -351,6 +355,8 @@ let rec extract_type ?(print_opening_debug = true)
     Some (Tpromise (env, payload_type_expr), type_arg_context)
   | Tconstr (Path.Pident {name = "array"}, [payload_type_expr], _) ->
     Some (Tarray (env, TypeExpr payload_type_expr), type_arg_context)
+  | Tconstr (Path.Pident {name = "list"}, [payload_type_expr], _) ->
+    Some (Tlist (env, TypeExpr payload_type_expr), type_arg_context)
   | Tconstr (Path.Pident {name = "dict"}, [payload_type_expr], _) ->
     Some (Tdict (env, TypeExpr payload_type_expr), type_arg_context)
   | Tconstr (Path.Pident {name = "result"}, [ok_type; error_type], _) ->
@@ -786,9 +792,10 @@ let rec resolve_nested ?type_arg_context ~env ~full ~state ~nested ?ctx
           |> Utils.Option.flat_map (fun (typ, type_arg_context) ->
               typ |> resolve_nested ?type_arg_context ~env ~state ~full ~nested)
         ))
-    | NArray, Tarray (env, ExtractedType typ) ->
+    | NArray, Tarray (env, ExtractedType typ)
+    | NList, Tlist (env, ExtractedType typ) ->
       typ |> resolve_nested ?type_arg_context ~env ~state ~full ~nested
-    | NArray, Tarray (env, TypeExpr typ) ->
+    | NArray, Tarray (env, TypeExpr typ) | NList, Tlist (env, TypeExpr typ) ->
       typ
       |> extract_type ~env ~state ~package:full.package
       |> Utils.Option.flat_map (fun (typ, type_arg_context) ->
@@ -981,6 +988,8 @@ let rec context_path_from_core_type (core_type : Parsetree.core_type) =
     |> Option.map (fun inner_typ -> Completable.CPOption inner_typ)
   | Ptyp_constr ({txt = Lident "array"}, [inner_typ]) ->
     Some (Completable.CPArray (inner_typ |> context_path_from_core_type))
+  | Ptyp_constr ({txt = Lident "list"}, [inner_typ]) ->
+    Some (Completable.CPList (inner_typ |> context_path_from_core_type))
   | Ptyp_constr ({txt = Lident "dict"}, [inner_typ]) ->
     Some (Completable.CPDict (inner_typ |> context_path_from_core_type))
   | Ptyp_constr (lid, _) ->

changes/list-literal-completion.fix.md

@@ -0,0 +1 @@
+- Editor: complete the elements of a list literal from the list's element type, like those of an array literal.

tests/analysis_tests/tests/src/CompletionListLiteral.res

@@ -0,0 +1,31 @@
+type kind = First | Second
+
+let takesList = (xs: list<kind>) => ignore(xs)
+let takesNested = (xs: list<list<kind>>) => ignore(xs)
+
+// let ys: list<kind> = list{First, }
+//                                 ^com
+
+// let ys: list<kind> = list{First, Se}
+//                                    ^com
+
+// let ys: list<kind> = list{}
+//                           ^com
+
+// let ys: list<kind> = list{Fi, Second}
+//                             ^com
+
+// let _ = takesList(list{})
+//                        ^com
+
+// let _ = takesList(list{First, Se, Second})
+//                                ^com
+
+// let _ = takesNested(list{list{First}, list{Se}})
+//                                              ^com
+
+// let ys: list<kind> =
+//                     ^com
+
+// let ys: array<list<kind>> = [list{Fi}]
+//                                     ^com

tests/analysis_tests/tests/src/CompletionSpreadLiteral.res

@@ -47,6 +47,14 @@ let pair = (a: kind, b: kind) => [a, b]
 // let ys = [...base, Fi]
 //                      ^com
 
-// A list literal gets no typed completion, with or without a spread
+// A list literal completes its elements like an array literal
 // let ys: list<kind> = list{...baseList, Fi, ...baseList}
 //                                          ^com
+
+// A trailing spread is the tail of a [::] chain, so `list{...baseList, }`
+// parses as `baseList`, and no element position is left
+// let ys: list<kind> = list{...baseList, }
+//                                        ^com
+
+// let ys: list<kind> = list{Fi, ...baseList}
+//                             ^com