Remove wrapping in assert

Author: josevalim

lib/elixir/lib/module/types/pattern.ex

@@ -158,9 +158,7 @@ defmodule Module.Types.Pattern do
                   end
 
                 :error ->
-                  meta = get_meta(expr) || stack.meta
-                  error = {:badpattern, expr, tag, context}
-                  throw({types, error(__MODULE__, error, meta, stack, context)})
+                  throw({types, to_badpattern_error(expr, tag, stack, context)})
               end
           end)
 
@@ -210,13 +208,23 @@ defmodule Module.Types.Pattern do
     end)
   end
 
+  defp to_badpattern_error(expr, tag, stack, context) do
+    meta =
+      if meta = get_meta(expr) do
+        meta ++ Keyword.take(stack.meta, [:generated, :line])
+      else
+        stack.meta
+      end
+
+    error(__MODULE__, {:badpattern, expr, tag, context}, meta, stack, context)
+  end
+
   defp of_pattern_intersect(tree, expected, expr, tag, stack, context) do
     actual = of_pattern_tree(tree, context)
     type = intersection(actual, expected)
 
     if empty?(type) do
-      meta = get_meta(expr) || stack.meta
-      {:error, error(__MODULE__, {:badpattern, expr, tag, context}, meta, stack, context)}
+      {:error, to_badpattern_error(expr, tag, stack, context)}
     else
       {:ok, type, context}
     end

lib/elixir/test/elixir/kernel_test.exs

@@ -301,8 +301,8 @@ defmodule KernelTest do
     assert (false and true) == false
     assert (false and 0) == false
     assert (false and raise("oops")) == false
-    assert ((x = Process.get(:unused, true)) and not x) == false
-    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) and 1 end
+    assert ((x = true) and not x) == false
+    assert_raise BadBooleanError, fn -> 0 and 1 end
   end
 
   test "or/2" do
@@ -313,8 +313,8 @@ defmodule KernelTest do
     assert (false or false) == false
     assert (false or true) == true
     assert (false or 0) == 0
-    assert ((x = Process.get(:unused, false)) or not x) == true
-    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) or 1 end
+    assert ((x = false) or not x) == true
+    assert_raise BadBooleanError, fn -> 0 or 1 end
   end
 
   defp delegate_is_struct(arg), do: is_struct(arg)
@@ -967,15 +967,15 @@ defmodule KernelTest do
     end
 
     test "get_in/1" do
-      users = Process.get(:unused, %{"john" => %{age: 27}, :meg => %{age: 23}})
+      users = %{"john" => %{age: 27}, :meg => %{age: 23}}
       assert get_in(users["john"][:age]) == 27
       assert get_in(users["dave"][:age]) == nil
       assert get_in(users["john"].age) == 27
       assert get_in(users["dave"].age) == nil
       assert get_in(users.meg[:age]) == 23
       assert get_in(users.meg.age) == 23
 
-      is_nil = Process.get(:unused, nil)
+      is_nil = nil
       assert get_in(is_nil.age) == nil
 
       assert_raise KeyError, ~r"key :unknown not found", fn -> get_in(users.unknown) end

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -50,7 +50,7 @@ defmodule ExUnit.AssertionsTest do
   defmacrop assert_ok_with_pin_from_quoted_var(arg) do
     quote do
       kind = :ok
-      assert {^kind, value} = Process.get(:unused, unquote(arg))
+      assert {^kind, value} = unquote(arg)
     end
   end
 
@@ -666,22 +666,22 @@ defmodule ExUnit.AssertionsTest do
 
   test "assert match when falsy but not match" do
     try do
-      assert {:ok, _x} = Process.get(:unused, nil)
+      assert {:ok, _x} = nil
     rescue
       error in [ExUnit.AssertionError] ->
         "match (=) failed" = error.message
-        "assert {:ok, _x} = Process.get(:unused, nil)" = Macro.to_string(error.expr)
+        "assert {:ok, _x} = nil" = Macro.to_string(error.expr)
         "nil" = Macro.to_string(error.right)
     end
   end
 
   test "assert match when falsy" do
     try do
-      assert _x = Process.get(:unused, nil)
+      assert _x = nil
     rescue
       error in [ExUnit.AssertionError] ->
         "Expected truthy, got nil" = error.message
-        "assert _x = Process.get(:unused, nil)" = Macro.to_string(error.expr)
+        "assert _x = nil" = Macro.to_string(error.expr)
     end
   end
 
@@ -1005,14 +1005,14 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "AssertionError.message/1 is nicely formatted" do
-    assert :a = Process.get(:unused, :b)
+    assert :a = :b
   rescue
     error in [ExUnit.AssertionError] ->
       """
 
 
       match (=) failed
-      code:  assert :a = Process.get(:unused, :b)
+      code:  assert :a = :b
       left:  :a
       right: :b
       """ = Exception.message(error)

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -347,7 +347,7 @@ defmodule ExUnit.FormatterTest do
       {:error,
        catch_assertion do
          expected_module = ExUnit.TestModule
-         assert %^expected_module{} = Process.get(:unused, nil)
+         assert %^expected_module{} = nil
        end, []}
     ]
 
@@ -357,7 +357,7 @@ defmodule ExUnit.FormatterTest do
                 match (=) failed
                 The following variables were pinned:
                   expected_module = ExUnit.TestModule
-                code:  assert %^expected_module{} = Process.get(:unused, nil)
+                code:  assert %^expected_module{} = nil
                 left:  %^expected_module{}
                 right: nil
            """