No longer automatically tag structs as dynamic

Author: josevalim

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

@@ -294,7 +294,6 @@ defmodule Module.Types.Expr do
     end
   end
 
-  # TODO: expr.fun(arg)
   def of_expr({{:., _, [remote, name]}, meta, args} = expr, stack, context) do
     {remote_type, context} = of_expr(remote, stack, context)
     {args_types, context} = Enum.map_reduce(args, context, &of_expr(&1, stack, &2))

lib/elixir/lib/module/types/of.ex

@@ -184,9 +184,7 @@ defmodule Module.Types.Of do
   @doc """
   Struct handling assuming the args have already been converted.
   """
-  # TODO: Allow structs fields to be defined. If the fields are defined,
-  # then the struct is no longer dynamic. And we need to validate args
-  # against the struct types.
+  # TODO: Allow structs fields to be defined and validate args against the struct types.
   # TODO: Use the struct default values to define the default types.
   def struct(struct, args_types, default_handling, meta, stack, context) do
     {info, context} = struct_info(struct, meta, stack, context)
@@ -200,7 +198,7 @@ defmodule Module.Types.Of do
         :only_defaults -> [{:__struct__, atom([struct])} | defaults]
       end
 
-    {dynamic(closed_map(pairs)), context}
+    {closed_map(pairs), context}
   end
 
   @doc """

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

@@ -459,31 +459,25 @@ defmodule Module.Types.ExprTest do
 
     test "creating structs" do
       assert typecheck!(%Point{}) ==
-               dynamic(
-                 closed_map(
-                   __struct__: atom([Point]),
-                   x: atom([nil]),
-                   y: atom([nil]),
-                   z: integer()
-                 )
+               closed_map(
+                 __struct__: atom([Point]),
+                 x: atom([nil]),
+                 y: atom([nil]),
+                 z: integer()
                )
 
       assert typecheck!(%Point{x: :zero}) ==
-               dynamic(
-                 closed_map(
-                   __struct__: atom([Point]),
-                   x: atom([:zero]),
-                   y: atom([nil]),
-                   z: integer()
-                 )
+               closed_map(
+                 __struct__: atom([Point]),
+                 x: atom([:zero]),
+                 y: atom([nil]),
+                 z: integer()
                )
     end
 
     test "updating structs" do
       assert typecheck!([x], %Point{x | x: :zero}) ==
-               dynamic(
-                 closed_map(__struct__: atom([Point]), x: atom([:zero]), y: term(), z: term())
-               )
+               closed_map(__struct__: atom([Point]), x: atom([:zero]), y: term(), z: term())
 
       assert typeerror!([x = :foo], %Point{x | x: :zero}) ==
                ~l"""
@@ -493,7 +487,7 @@ defmodule Module.Types.ExprTest do
 
                expected type:
 
-                   dynamic(%Point{x: term(), y: term(), z: term()})
+                   %Point{x: term(), y: term(), z: term()}
 
                but got type:
 
@@ -540,7 +534,7 @@ defmodule Module.Types.ExprTest do
 
              the given type does not have the given key:
 
-                 dynamic(%Point{x: nil, y: nil, z: integer()})
+                 %Point{x: nil, y: nil, z: integer()}
              """
     end
 
@@ -811,17 +805,15 @@ defmodule Module.Types.ExprTest do
 
                where "e" was given the type:
 
-                   # type: dynamic(
-                     %RuntimeError{__exception__: true, message: term()} or
-                       %SyntaxError{
-                         __exception__: true,
-                         column: term(),
-                         description: term(),
-                         file: term(),
-                         line: term(),
-                         snippet: term()
-                       }
-                   )
+                   # type: %RuntimeError{__exception__: true, message: term()} or
+                     %SyntaxError{
+                       __exception__: true,
+                       column: term(),
+                       description: term(),
+                       file: term(),
+                       line: term(),
+                       snippet: term()
+                     }
                    # from: types_test.ex:LINE-4
                    rescue e in [SyntaxError, RuntimeError] ->
                """