Handle Erlang/OTP 28 nominal types in Code.Typespec.fetch_types/1

-nominal type declarations (EEP 69, OTP 28) were silently dropped from
the result. Return them as {:nominal, type} entries, mirroring how
:opaque is reported, and tighten the spec to enumerate the kind atoms.
The spec comparison script now also expands remote nominal types.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: lukaszsamson

lib/elixir/lib/code/typespec.ex

@@ -80,13 +80,15 @@ defmodule Code.Typespec do
   Returns all types available from the module's BEAM code.
 
   The result is returned as a list of tuples where the first
-  element is the type (`:typep`, `:type` and `:opaque`).
+  element is the type (`:typep`, `:type`, `:opaque` and, on Erlang/OTP 28+,
+  `:nominal`).
 
   The module must have a corresponding BEAM file which can be
   located by the runtime system. The types will be in the Erlang
   Abstract Format.
   """
-  @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error
+  @spec fetch_types(module | binary) ::
+          {:ok, [{:nominal | :opaque | :type | :typep, tuple}]} | :error
   def fetch_types(module) when is_atom(module) or is_binary(module) do
     case typespecs_abstract_code(module) do
       {:ok, abstract_code} ->
@@ -95,9 +97,10 @@ defmodule Code.Typespec do
 
         types =
           for {:attribute, _, kind, {name, _, args} = type} <- abstract_code,
-              kind in [:opaque, :type] do
+              kind in [:opaque, :type, :nominal] do
             cond do
               kind == :opaque -> {:opaque, type}
+              kind == :nominal -> {:nominal, type}
               {name, length(args)} in exported_types -> {:type, type}
               true -> {:typep, type}
             end

lib/elixir/scripts/compare_specs_and_signatures.exs

@@ -399,7 +399,7 @@ defmodule SpecToDescr do
     with {:ok, types} <- Code.Typespec.fetch_types(mod),
          {_kind, {^name, body, params}} <-
            Enum.find(types, fn {kind, {n, _b, p}} ->
-             kind in [:type, :typep, :opaque] and n == name and length(p) == arity
+             kind in [:type, :typep, :opaque, :nominal] and n == name and length(p) == arity
            end) do
       {:ok, {params, body}}
     else

lib/elixir/test/elixir/typespec_test.exs

@@ -1438,6 +1438,23 @@ defmodule TypespecTest do
       assert Code.Typespec.fetch_specs(Unknown) == :error
     end
 
+    if System.otp_release() >= "28" do
+      test "retrieval of Erlang nominal types" do
+        forms = [
+          {:attribute, 1, :module, :typespec_nominal_sample},
+          {:attribute, 2, :export_type, [meters: 0]},
+          {:attribute, 3, :nominal, {:meters, {:type, 3, :integer, []}, []}},
+          {:attribute, 4, :type, {:plain, {:type, 4, :atom, []}, []}}
+        ]
+
+        {:ok, :typespec_nominal_sample, beam} = :compile.forms(forms, [:debug_info])
+
+        assert {:ok, types} = Code.Typespec.fetch_types(beam)
+        assert {:nominal, {:meters, {:type, 3, :integer, []}, []}} in types
+        assert {:typep, {:plain, {:type, 4, :atom, []}, []}} in types
+      end
+    end
+
     # This is a test that implements all types specified in lib/elixir/pages/typespecs.md
     test "documented types and their AST" do
       defmodule SomeStruct do