Transform the struct update syntax into a type assertion

This transforms the struct update into a type assertion,
requiring the type system to be sure the expression has
precisely the given struct type.

The struct update syntax may still be deprecated in the
future but this will provide a safer migration path and
allow us to engage in more conversations with the community.

Author: josevalim

lib/elixir/lib/exception.ex

@@ -1457,20 +1457,6 @@ defmodule BadFunctionError do
   end
 end
 
-defmodule BadStructError do
-  @moduledoc deprecated:
-               "This exception is deprecated alongside the struct update syntax that raises it"
-  defexception [:struct, :term]
-
-  @impl true
-  def message(exception) do
-    Exception.__format_message_with_term__(
-      "expected a struct named #{inspect(exception.struct)}, got:",
-      exception.term
-    )
-  end
-end
-
 defmodule BadMapError do
   @moduledoc """
   An exception raised when a map is expected, but something else was given.
@@ -2605,10 +2591,6 @@ defmodule ErlangError do
     %BadFunctionError{term: term}
   end
 
-  def normalize({:badstruct, struct, term}, _stacktrace) do
-    %BadStructError{struct: struct, term: term}
-  end
-
   def normalize({:badmatch, term}, _stacktrace) do
     %MatchError{term: term}
   end

lib/elixir/lib/module/types/expr.ex

@@ -231,21 +231,36 @@ defmodule Module.Types.Expr do
   # %Struct{map | ...}
   # This syntax is deprecated, so we simply traverse.
   def of_expr(
-        {:%, _, [_, {:%{}, _, [{:|, _, [map, args]}]}]} = struct,
+        {:%, meta, [module, {:%{}, _, [{:|, _, [map, pairs]}]}]} = struct,
         _expected,
         expr,
         stack,
         context
       ) do
-    {_, context} = of_expr(map, term(), struct, stack, context)
+    {map_type, context} = of_expr(map, term(), struct, stack, context)
 
     context =
-      Enum.reduce(args, context, fn {key, value}, context when is_atom(key) ->
-        {_, context} = of_expr(value, term(), expr, stack, context)
+      if stack.mode == :traversal do
         context
-      end)
+      else
+        with {false, struct_key_type} <- map_fetch(map_type, :__struct__),
+             {:finite, [^module]} <- atom_fetch(struct_key_type) do
+          context
+        else
+          _ ->
+            error(__MODULE__, {:badupdate, map_type, struct, context}, meta, stack, context)
+        end
+      end
 
-    {dynamic(), context}
+    Enum.reduce(pairs, {map_type, context}, fn {key, value}, {acc, context} ->
+      # TODO: Once we support typed structs, we need to type check them here
+      {type, context} = of_expr(value, term(), expr, stack, context)
+
+      case map_fetch_and_put(acc, key, type) do
+        {_value, acc} -> {acc, context}
+        _ -> {acc, context}
+      end
+    end)
   end
 
   # %{...}
@@ -791,6 +806,57 @@ defmodule Module.Types.Expr do
 
   ## Warning formatting
 
+  def format_diagnostic({:badupdate, type, expr, context}) do
+    {:%, _, [module, {:%{}, _, [{:|, _, [map, _]}]}]} = expr
+    traces = collect_traces(map, context)
+
+    fix =
+      case map do
+        {var, meta, context} when is_atom(var) and is_atom(context) ->
+          if capture = meta[:capture] do
+            "instead of using &#{capture}, you must define an anonymous function, define a variable and pattern match on \"%#{inspect(module)}{}\""
+          else
+            "when defining the variable \"#{Macro.to_string(map)}\", you must also pattern match on \"%#{inspect(module)}{}\""
+          end
+
+        _ ->
+          "you must assign \"#{Macro.to_string(map)}\" to variable and pattern match on \"%#{inspect(module)}{}\""
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          a struct for #{inspect(module)} is expected on struct update:
+
+              #{expr_to_string(expr, collapse_structs: false) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces),
+          """
+
+          #{fix}.
+
+          #{hint()} given pattern matching is enough to catch typing errors, \
+          you may optionally convert the struct update into a map update. For \
+          example, instead of:
+
+              user = some_fun()
+              %User{user | name: "John Doe"}
+
+          it is enough to write:
+
+              %User{} = user = some_fun()
+              %{user | name: "John Doe"}
+          """
+        ])
+    }
+  end
+
   def format_diagnostic({:badmap, type, expr, context}) do
     traces = collect_traces(expr, context)
 

lib/elixir/src/elixir_erl_pass.erl

@@ -472,24 +472,9 @@ translate_struct_var_name(Ann, Name, Args, S0) ->
   {TArgs1, S2} = generate_struct_name_guard(TArgs0, [], S1),
   {{map, MapAnn, TArgs1}, S2}.
 
-translate_struct(Ann, Name, {'%{}', _, [{'|', _, [Update, Assocs]}]}, S) ->
-  Generated = erl_anno:set_generated(true, Ann),
-  {VarName, VS} = elixir_erl_var:build('_', S),
-
-  Var = {var, Ann, VarName},
-  Map = {map, Ann, [{map_field_exact, Ann, {atom, Ann, '__struct__'}, {atom, Ann, Name}}]},
-
-  Match = {match, Ann, Var, Map},
-  %% Once this is removed, we should remove badstruct handling from elixir_erl_try
-  Error = {tuple, Ann, [{atom, Ann, badstruct}, {atom, Ann, Name}, Var]},
-
-  {TUpdate, TU} = translate(Update, Ann, VS),
-  {TAssocs, TS} = translate_map(Ann, Assocs, {ok, Var}, TU),
-
-  {{'case', Generated, TUpdate, [
-    {clause, Ann, [Match], [], [TAssocs]},
-    {clause, Generated, [Var], [], [?remote(Ann, erlang, error, [Error])]}
-  ]}, TS};
+translate_struct(Ann, _Name, {'%{}', _, [{'|', Meta, [Update, Assocs]}]}, S) ->
+  {TUpdate, SU} = translate(Update, Ann, S),
+  translate_map(?ann(Meta), Assocs, {ok, TUpdate}, SU);
 translate_struct(Ann, Name, {'%{}', _, Assocs}, S) ->
   translate_map(Ann, [{'__struct__', Name}] ++ Assocs, none, S).
 

lib/elixir/src/elixir_erl_try.erl

@@ -184,11 +184,6 @@ erl_rescue_guard_for(Meta, Var, 'Elixir.TryClauseError') ->
           erl_tuple_size(Meta, Var, 2),
           erl_record_compare(Meta, Var, try_clause));
 
-erl_rescue_guard_for(Meta, Var, 'Elixir.BadStructError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 3),
-          erl_record_compare(Meta, Var, badstruct));
-
 erl_rescue_guard_for(Meta, Var, 'Elixir.BadMapError') ->
   erl_and(Meta,
           erl_tuple_size(Meta, Var, 2),

lib/elixir/src/elixir_map.erl

@@ -18,18 +18,14 @@ expand_map(Meta, Args, S, E) ->
   validate_kv(Meta, EArgs, Args, E),
   {{'%{}', Meta, EArgs}, SE, EE}.
 
-expand_struct(Meta, Left, {'%{}', MapMeta, MapArgs} = Right, S, #{context := Context} = E) ->
+expand_struct(Meta, Left, {'%{}', MapMeta, MapArgs}, S, #{context := Context} = E) ->
   CleanMapArgs = delete_struct_key(Meta, MapArgs, E),
   {[ELeft, ERight], SE, EE} = elixir_expand:expand_args([Left, {'%{}', MapMeta, CleanMapArgs}], S, E),
 
   case validate_struct(ELeft, Context) of
     true when is_atom(ELeft) ->
       case ERight of
         {'%{}', MapMeta, [{'|', _, [_, Assocs]}]} ->
-          %% The update syntax for structs is deprecated,
-          %% so we return only the update syntax downstream.
-          %% TODO: Remove me on Elixir v2.0
-          file_warn(MapMeta, ?key(E, file), ?MODULE, {deprecated_update, ELeft, Right}),
           _ = load_struct_info(Meta, ELeft, Assocs, EE),
           {{'%', Meta, [ELeft, ERight]}, SE, EE};
 
@@ -303,9 +299,4 @@ format_error({invalid_key_for_struct, Key}) ->
   io_lib:format("invalid key ~ts for struct, struct keys must be atoms, got: ",
                 ['Elixir.Macro':to_string(Key)]);
 format_error(ignored_struct_key_in_struct) ->
-  "key :__struct__ is ignored when using structs";
-format_error({deprecated_update, Struct, MapUpdate}) ->
-  io_lib:format("the struct update syntax is deprecated:\n\n~ts\n\n"
-                "Instead, prefer to pattern match on structs when the variable is first defined and "
-                "use the regular map update syntax instead:\n\n~ts\n",
-                ['Elixir.Macro':to_string({'%', [], [Struct, MapUpdate]}), 'Elixir.Macro':to_string(MapUpdate)]).
+  "key :__struct__ is ignored when using structs".

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -958,6 +958,87 @@ defmodule Module.Types.ExprTest do
              """
     end
 
+    test "updating structs" do
+      integer_date_type =
+        dynamic(
+          closed_map(
+            __struct__: atom([Date]),
+            day: integer(),
+            calendar: atom(),
+            month: term(),
+            year: term()
+          )
+        )
+
+      # When we know the type
+      assert typecheck!([], %Date{Date.new!(1, 1, 1) | day: 31}) ==
+               integer_date_type
+
+      assert typecheck!([], %Date{%Date{Date.new!(1, 1, 1) | day: 13} | day: 31}) ==
+               integer_date_type
+
+      # When we don't know the type of var
+      assert typeerror!([x], %Date{x | day: 31}) == ~l"""
+             a struct for Date is expected on struct update:
+
+                 %Date{x | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             where "x" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE
+                 x
+
+             when defining the variable "x", you must also pattern match on "%Date{}".
+
+             hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:
+
+                 user = some_fun()
+                 %User{user | name: "John Doe"}
+
+             it is enough to write:
+
+                 %User{} = user = some_fun()
+                 %{user | name: "John Doe"}
+             """
+
+      # When we don't know the type of capture
+      assert typeerror!([], &%Date{&1 | day: 31}) =~ ~l"""
+             a struct for Date is expected on struct update:
+
+                 %Date{&1 | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             where "capture" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE
+                 &1
+
+             instead of using &1, you must define an anonymous function, define a variable and pattern match on "%Date{}".
+             """
+
+      # When we don't know the type of expression
+      assert typeerror!([], %Date{SomeMod.fun() | day: 31}) =~ """
+             a struct for Date is expected on struct update:
+
+                 %Date{SomeMod.fun() | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             you must assign "SomeMod.fun()" to variable and pattern match on "%Date{}".
+             """
+    end
+
     test "updating to open maps" do
       assert typecheck!(
                [key],