Get domain upper bounds

Author: josevalim

lib/elixir/test/elixir/enum_test.exs

@@ -1885,10 +1885,6 @@ defmodule EnumTest.Range do
     assert Enum.drop_every(1..5//2, 0) == [1, 3, 5]
     assert Enum.drop_every(1..5//2, 1) == []
     assert Enum.drop_every(1..5//2, 2) == [3]
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.drop_every(1..10, 3.33)
-    end
   end
 
   test "drop_while/2" do

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

@@ -39,10 +39,10 @@ defmodule Module.Types.InferTest do
       end
 
     args = [
-      dynamic(open_map(__struct__: atom([Point]))),
-      dynamic(open_map(__struct__: atom([Point]))),
-      dynamic(atom([Point])),
-      dynamic(atom([Point]))
+      open_map(__struct__: atom([Point])),
+      open_map(__struct__: atom([Point])),
+      atom([Point]),
+      atom([Point])
     ]
 
     assert types[{:fun1, 4}] == {:infer, nil, [{args, atom([:ok])}]}
@@ -62,7 +62,7 @@ defmodule Module.Types.InferTest do
     number = union(integer(), float())
 
     assert types[{:fun, 1}] ==
-             {:infer, nil, [{[dynamic(open_map(foo: number, bar: number))], dynamic(number)}]}
+             {:infer, nil, [{[open_map(foo: number, bar: number)], dynamic(number)}]}
   end
 
   test "infer with Elixir built-in", config do
@@ -73,7 +73,7 @@ defmodule Module.Types.InferTest do
 
     assert types[{:parse, 1}] ==
              {:infer, nil,
-              [{[dynamic()], dynamic(union(atom([:error]), tuple([integer(), term()])))}]}
+              [{[term()], dynamic(union(atom([:error]), tuple([integer(), term()])))}]}
   end
 
   test "merges patterns", config do
@@ -87,11 +87,11 @@ defmodule Module.Types.InferTest do
       end
 
     assert types[{:fun, 1}] ==
-             {:infer, [dynamic(union(atom([:ok, :error]), binary()))],
+             {:infer, [union(atom([:ok, :error]), binary())],
               [
-                {[dynamic(atom([:ok]))], atom([:one])},
-                {[dynamic(binary())], atom([:two, :three, :four])},
-                {[dynamic(atom([:error]))], atom([:five])}
+                {[atom([:ok])], atom([:one])},
+                {[binary()], atom([:two, :three, :four])},
+                {[atom([:error])], atom([:five])}
               ]}
   end
 
@@ -104,7 +104,7 @@ defmodule Module.Types.InferTest do
       end
 
     assert types[{:pub, 1}] ==
-             {:infer, nil, [{[dynamic(atom([:ok, :error]))], dynamic(atom([:ok, :error]))}]}
+             {:infer, nil, [{[atom([:ok, :error])], dynamic(atom([:ok, :error]))}]}
 
     assert types[{:priv, 1}] == nil
   end
@@ -119,7 +119,7 @@ defmodule Module.Types.InferTest do
       end
 
     assert types[{:pub, 1}] ==
-             {:infer, nil, [{[dynamic(atom([:ok, :error]))], dynamic(atom([:ok, :error]))}]}
+             {:infer, nil, [{[atom([:ok, :error])], dynamic(atom([:ok, :error]))}]}
   end
 
   test "infers return types even with loops", config do
@@ -128,6 +128,6 @@ defmodule Module.Types.InferTest do
         def pub(x), do: pub(x)
       end
 
-    assert types[{:pub, 1}] == {:infer, nil, [{[dynamic()], dynamic()}]}
+    assert types[{:pub, 1}] == {:infer, nil, [{[term()], dynamic()}]}
   end
 end

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

@@ -232,10 +232,11 @@ defmodule Module.Types.IntegrationTest do
       refute stderr =~ "this_wont_warn"
 
       itself_arg = fn mod ->
-        {_, %{sig: {:infer, nil, [{[value], value}]}}} =
+        {_, %{sig: {:infer, nil, [{[domain], return}]}}} =
           List.keyfind(read_chunk(modules[mod]).exports, {:itself, 1}, 0)
 
-        value
+        assert equal?(dynamic(domain), return)
+        return
       end
 
       assert itself_arg.(Itself.Atom) == dynamic(atom())
@@ -295,10 +296,10 @@ defmodule Module.Types.IntegrationTest do
             but expected one of:
 
                 #1
-                dynamic(:ok)
+                :ok
 
                 #2
-                dynamic(:error)
+                :error
         """,
         """
             warning: the following pattern will never match:
@@ -710,7 +711,7 @@ defmodule Module.Types.IntegrationTest do
 
             but expected one of:
 
-                dynamic(:ok)
+                :ok
 
             typing violation found at:
             │