 
       assert {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]} =
                return_type
-    end
-
-    test "@spec + @callback" do
-      bytecode =
-        test_module do
-          def my_fun(x), do: x
-          @spec my_fun(integer) :: integer
-          @spec my_fun(charlist) :: charlist
-          @callback cb(integer) :: integer
-        end
-
-      assert [{{:cb, 1}, [{:type, _, :fun, args}]}] = callbacks(bytecode)
-      assert [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}] = args
-
-      assert [{{:my_fun, 1}, [integer_clause, charlist_clause]}] = specs(bytecode)
-
-      assert {:type, _, :fun, [{:type, _, :product, [arg]}, return]} = integer_clause
-      assert {:type, _, :integer, []} = arg
-      assert {:type, _, :integer, []} = return
-
-      assert {:type, _, :fun, [{:type, _, :product, [arg]}, return]} = charlist_clause
-      assert {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :charlist}, []]} = arg
-      assert {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :charlist}, []]} = return
     end
 
     test "block handling" do

      end
    end

    test "@type with a variable starting with underscore" do
      test_module do
        assert @type(foo(_hello) :: integer) == :ok
      end
    end

    test "type variable _ should be invalid" do
      assert_raise CompileError, ~r"type variable '_' is invalid", fn ->
        test_module do
          @type foo(_) :: integer

      assert [type: {:my_type, {:type, _, :term, []}, []}] = types(bytecode)
    end

    test "@type with an atom/alias" do
      bytecode =
        test_module do
          @type foo :: :foo
          @type bar :: Bar
        end

      assert [
               type: {:bar, {:atom, _, Bar}, []},
               type: {:foo, {:atom, _, :foo}, []}
             ] = types(bytecode)
    end

    test "@type with an integer" do
      bytecode =
        test_module do
          @type pos :: 10
          @type neg :: -10
        end

      assert [
               type: {:neg, {:op, _, :-, {:integer, _, 10}}, []},
               type: {:pos, {:integer, _, 10}, []}
             ] = types(bytecode)
    end

    test "@type with a remote type" do
