rbs 1.7.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93b02ff74da3638b4aee35967e4ccc34460c1103ceb51ecfd5406d39e732f21
-  data.tar.gz: b11beb145022527d5d16e2c6545fcc4aa847790e3502b6054f77785685b7fe6c
+  metadata.gz: 9b12d92ea4eeeb5dbd6de6c5d58351b0306bdcd017d0f1e51a36599766bfded3
+  data.tar.gz: d60cfb836027441a5bb3f85fbebb0e2ab9bc03c49a21f00c3f10d4ab8dd1de65
 SHA512:
-  metadata.gz: 689cdd0da1b18d8d0d6c9cde454cd3a2de0d44f66e19d52400734bb13001770b44bf0f66a87db403d31fb91ddccdefee87a056686055165d1935ade8fd376ff6
-  data.tar.gz: 488b07051aea9edb7c3c32e9fafc8b1bfcd16f38b8dc492aa4656a0a15a1577615522a15f22c3e900acb458f0bce4620998c2dfc79b17638dd64f025bd0ff29c
+  metadata.gz: 9ef926a62415189173d41204d1a16674a4a8331e3fdefafe00a4e52c9cbf0f3eb84281194a5b5c43027455334c13ea0ab14e1b3f0a6b8d5f5644cb80733a246b
+  data.tar.gz: ce07016eee6b4142a66a28d8c7ffc356b3d4fdd747027f2dd521b347efcb6ac791385e903a1e3b9f8d468ec66e13995e341516137ceba990db511982c6d0d206

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## master
 
+## 1.8.0 (2021-12-02)
+
+RBS 1.8.0 ships with a language feature enchancement, _generic type alias_.
+You can define a type alias with type parameters now.
+
+```rbs
+type list[T] = [T, list[T]] | nil  # Defines a list of type T
+
+type int_list = list[Integer]      # List of Integer
+type string_list = list[String]    # List of String
+```
+
+You can find the detail in the [PR](https://github.com/ruby/rbs/pull/823).
+
+### Signature updates
+
+* `Date#+`, `Date#-` ([\#830](https://github.com/ruby/rbs/pull/830))
+* `#include?`, `#member?`, `#delete`, `#count` ([\#835](https://github.com/ruby/rbs/pull/835))
+
+### Language updates
+
+* Generic type alias ([\#823](https://github.com/ruby/rbs/pull/823))
+
 ## 1.7.1 (2021-11-18)
 
 ### Signature updates

data/core/array.rbs

@@ -699,7 +699,7 @@ class Array[unchecked out Elem] < Object
   #     ary.count {|x| x%2 == 0}   #=> 3
   #
   def count: () -> ::Integer
-           | (untyped obj) -> ::Integer
+           | (Elem obj) -> ::Integer
            | () { (Elem) -> boolish } -> ::Integer
 
   # Calls the given block for each element `n` times or forever if `nil` is given.
@@ -733,7 +733,7 @@ class Array[unchecked out Elem] < Object
   #     a.delete("z")                   #=> nil
   #     a.delete("z") {"not found"}     #=> "not found"
   #
-  def delete: (untyped obj) -> Elem?
+  def delete: (Elem obj) -> Elem?
             | [S, T] (S obj) { (S) -> T } -> (Elem | T)
 
   # Deletes the element at the specified `index`, returning that element, or `nil`
@@ -1029,7 +1029,7 @@ class Array[unchecked out Elem] < Object
   #     a.include?("b")   #=> true
   #     a.include?("z")   #=> false
   #
-  def include?: (untyped object) -> bool
+  def include?: (Elem object) -> bool
 
   # Returns the *index* of the first object in `ary` such that the object is `==`
   # to `obj`.

data/core/builtin.rbs

@@ -6,6 +6,10 @@ interface _ToInt
   def to_int: -> Integer
 end
 
+interface _ToR
+  def to_r: () -> Rational
+end
+
 interface _ToS
   def to_s: -> String
 end

data/core/enumerable.rbs

@@ -63,7 +63,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   # ary.count{ |x| x%2==0 } #=> 3
   # ```
   def count: () -> Integer
-           | (?untyped) -> Integer
+           | (Elem) -> Integer
            | () { (Elem) -> boolish } -> Integer
 
   def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
@@ -130,7 +130,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   def group_by: [U] () { (Elem arg0) -> U } -> ::Hash[U, ::Array[Elem]]
               | () -> ::Enumerator[Elem, ::Array[Elem]]
 
-  def `include?`: (untyped arg0) -> bool
+  def `include?`: (Elem arg0) -> bool
 
   def inject: (untyped init, Symbol method) -> untyped
             | (Symbol method) -> untyped
@@ -341,7 +341,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
          | () -> ::Enumerator[Elem, ::Array[untyped]]
 
-  def member?: (untyped arg0) -> bool
+  def member?: (Elem arg0) -> bool
 
   alias reduce inject
 

data/docs/syntax.md

@@ -5,14 +5,14 @@
 ```markdown
 _type_ ::= _class-name_ _type-arguments_                (Class instance type)
          | _interface-name_ _type-arguments_            (Interface type)
+         | _alias-name_ _type-arguments_                (Alias type)
          | `singleton(` _class-name_ `)`                (Class singleton type)
-         | _alias-name_                                 (Alias type)
          | _literal_                                    (Literal type)
          | _type_ `|` _type_                            (Union type)
          | _type_ `&` _type_                            (Intersection type)
          | _type_ `?`                                   (Optional type)
-         | `{` _record-name_ `:` _type_ `,` etc. `}`     (Record type)
-         | `[]` | `[` _type_ `,` etc. `]`                (Tuples)
+         | `{` _record-name_ `:` _type_ `,` etc. `}`    (Record type)
+         | `[]` | `[` _type_ `,` etc. `]`               (Tuples)
          | _type-variable_                              (Type variables)
          | `^(` _parameters_ `) ->` _type_              (Proc type)
          | `self`
@@ -35,8 +35,8 @@ _namespace_ ::=                                         (Empty namespace)
               | `::`                                    (Root)
               | _namespace_ /[A-Z]\w*/ `::`             (Namespace)
 
-_type-arguments_ ::=                                    (No application)
-                   | `[` _type_ `,` etc. `]`             (Type application)
+_type-arguments_ ::=                                    (No type arguments)
+                   | `[` _type_ `,` etc. `]`            (Type arguments)
 
 _literal_ ::= _string-literal_
             | _symbol-literal_
@@ -64,25 +64,25 @@ _ToS                          # _ToS interface
 ::MyApp::_Each[String]        # Interface name with namespace and type application
 ```
 
-### Class singleton type
-
-Class singleton type denotes _the type of a singleton object of a class_.
-
-```
-singleton(String)
-singleton(::Hash)            # Class singleton type cannot be parametrized.
-```
-
 ### Alias type
 
 Alias type denotes an alias declared with _alias declaration_.
 
 The name of type aliases starts with lowercase `[a-z]`.
 
-
 ```
 name
 ::JSON::t                    # Alias name with namespace
+list[Integer]                # Type alias can be generic
+```
+
+### Class singleton type
+
+Class singleton type denotes _the type of a singleton object of a class_.
+
+```
+singleton(String)
+singleton(::Hash)            # Class singleton type cannot be parametrized.
 ```
 
 ### Literal type
@@ -155,7 +155,7 @@ Elem
 ```
 
 Type variables cannot be distinguished from _class instance types_.
-They are scoped in _class/module/interface declaration_ or _generic method types_.
+They are scoped in _class/module/interface/alias declaration_ or _generic method types_.
 
 ```
 class Ref[T]              # Object is scoped in the class declaration.
@@ -414,7 +414,6 @@ These work only as _statements_, not per-method specifier.
 _decl_ ::= _class-decl_                         # Class declaration
          | _module-decl_                        # Module declaration
          | _interface-decl_                     # Interface declaration
-         | _extension-decl_                     # Extension declaration
          | _type-alias-decl_                    # Type alias declaration
          | _const-decl_                         # Constant declaration
          | _global-decl_                        # Global declaration
@@ -434,9 +433,7 @@ _interface-members_ ::= _method-member_              # Method
                       | _include-member_             # Mixin (include)
                       | _alias-member_               # Alias
 
-_extension-decl_ ::= `extension` _class-name_ _type-parameters_ `(` _extension-name_ `)` _members_ `end`
-
-_type-alias-decl_ ::= `type` _alias-name_ `=` _type_
+_type-alias-decl_ ::= `type` _alias-name_ _module-type-parameters_ `=` _type_
 
 _const-decl_ ::= _const-name_ `:` _type_
 
@@ -536,6 +533,12 @@ type subject = Attendee | Speaker
 type JSON::t = Integer | TrueClass | FalseClass | String | Hash[Symbol, t] | Array[t]
 ```
 
+Type alias can be generic like class, module, and interface.
+
+```
+type list[out T] = [T, list[T]] | nil
+```
+
 ### Constant type declaration
 
 You can declare a constant.

data/ext/rbs_extension/parser.c

@@ -815,6 +815,8 @@ static VALUE parse_simple(parserstate *state) {
   }
   case tULIDENT:
     // fallthrough
+  case tLIDENT:
+    // fallthrough
   case pCOLON2: {
     range name_range;
     range args_range;
@@ -857,19 +859,11 @@ static VALUE parse_simple(parserstate *state) {
     } else if (kind == INTERFACE_NAME) {
       return rbs_interface(typename, types, location);
     } else if (kind == ALIAS_NAME) {
-      return rbs_alias(typename, location);
+      return rbs_alias(typename, types, location);
     } else {
       return Qnil;
     }
   }
-  case tLIDENT: {
-    VALUE location = rbs_location_current_token(state);
-    rbs_loc *loc = rbs_check_location(location);
-    rbs_loc_add_required_child(loc, rb_intern("name"), state->current_token.range);
-    rbs_loc_add_optional_child(loc, rb_intern("args"), NULL_RANGE);
-    VALUE typename = parse_type_name(state, ALIAS_NAME, NULL);
-    return rbs_alias(typename, location);
-  }
   case kSINGLETON: {
     range name_range;
     range type_range;
@@ -1093,12 +1087,98 @@ VALUE parse_const_decl(parserstate *state) {
   return rbs_ast_decl_constant(typename, type, location, comment);
 }
 
+/*
+  module_type_params ::= {} `[` module_type_param `,` ... <`]`>
+                       | {<>}
+
+  module_type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT
+*/
+VALUE parse_module_type_params(parserstate *state, range *rg) {
+  VALUE params = rbs_ast_decl_module_type_params();
+
+  if (state->next_token.type == pLBRACKET) {
+    parser_advance(state);
+
+    rg->start = state->current_token.range.start;
+
+    while (true) {
+      VALUE name;
+      VALUE unchecked = Qfalse;
+      VALUE variance = ID2SYM(rb_intern("invariant"));
+
+      range param_range = NULL_RANGE;
+      range name_range;
+      range variance_range = NULL_RANGE;
+      range unchecked_range = NULL_RANGE;
+
+      param_range.start = state->next_token.range.start;
+
+      if (state->next_token.type == kUNCHECKED) {
+        unchecked = Qtrue;
+        parser_advance(state);
+        unchecked_range = state->current_token.range;
+      }
+
+      if (state->next_token.type == kIN || state->next_token.type == kOUT) {
+        switch (state->next_token.type) {
+        case kIN:
+          variance = ID2SYM(rb_intern("contravariant"));
+          break;
+        case kOUT:
+          variance = ID2SYM(rb_intern("covariant"));
+          break;
+        default:
+          rbs_abort();
+        }
+
+        parser_advance(state);
+        variance_range = state->current_token.range;
+      }
+
+      parser_advance_assert(state, tUIDENT);
+      name_range = state->current_token.range;
+      param_range.end = state->current_token.range.end;
+
+      ID id = INTERN_TOKEN(state, state->current_token);
+      name = ID2SYM(id);
+
+      parser_insert_typevar(state, id);
+
+      VALUE location = rbs_new_location(state->buffer, param_range);
+      rbs_loc *loc = rbs_check_location(location);
+      rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+      rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
+      rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
+
+      VALUE param = rbs_ast_decl_module_type_params_param(name, variance, unchecked, location);
+      rb_funcall(params, rb_intern("add"), 1, param);
+
+      if (state->next_token.type == pCOMMA) {
+        parser_advance(state);
+      }
+
+      if (state->next_token.type == pRBRACKET) {
+        break;
+      }
+    }
+
+    parser_advance_assert(state, pRBRACKET);
+    rg->end = state->current_token.range.end;
+  } else {
+    *rg = NULL_RANGE;
+  }
+
+  return params;
+}
+
 /*
   type_decl ::= {kTYPE} alias_name `=` <type>
 */
 VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotations) {
   range decl_range;
-  range keyword_range, name_range, eq_range;
+  range keyword_range, name_range, params_range, eq_range;
+
+  parser_push_typevar_table(state, true);
 
   decl_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, decl_range.start);
@@ -1108,6 +1188,8 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
   parser_advance(state);
   VALUE typename = parse_type_name(state, ALIAS_NAME, &name_range);
 
+  VALUE type_params = parse_module_type_params(state, &params_range);
+
   parser_advance_assert(state, pEQ);
   eq_range = state->current_token.range;
 
@@ -1118,10 +1200,14 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
   rbs_loc *loc = rbs_check_location(location);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+  rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
   rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
 
+  parser_pop_typevar_table(state);
+
   return rbs_ast_decl_alias(
     typename,
+    type_params,
     type,
     annotations,
     location,
@@ -1184,90 +1270,6 @@ VALUE parse_annotation(parserstate *state) {
   return rbs_ast_annotation(string, location);
 }
 
-/*
-  module_type_params ::= {} `[` module_type_param `,` ... <`]`>
-                       | {<>}
-
-  module_type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT
-*/
-VALUE parse_module_type_params(parserstate *state, range *rg) {
-  VALUE params = rbs_ast_decl_module_type_params();
-
-  if (state->next_token.type == pLBRACKET) {
-    parser_advance(state);
-
-    rg->start = state->current_token.range.start;
-
-    while (true) {
-      VALUE name;
-      VALUE unchecked = Qfalse;
-      VALUE variance = ID2SYM(rb_intern("invariant"));
-
-      range param_range = NULL_RANGE;
-      range name_range;
-      range variance_range = NULL_RANGE;
-      range unchecked_range = NULL_RANGE;
-
-      param_range.start = state->next_token.range.start;
-
-      if (state->next_token.type == kUNCHECKED) {
-        unchecked = Qtrue;
-        parser_advance(state);
-        unchecked_range = state->current_token.range;
-      }
-
-      if (state->next_token.type == kIN || state->next_token.type == kOUT) {
-        switch (state->next_token.type) {
-        case kIN:
-          variance = ID2SYM(rb_intern("contravariant"));
-          break;
-        case kOUT:
-          variance = ID2SYM(rb_intern("covariant"));
-          break;
-        default:
-          rbs_abort();
-        }
-
-        parser_advance(state);
-        variance_range = state->current_token.range;
-      }
-
-      parser_advance_assert(state, tUIDENT);
-      name_range = state->current_token.range;
-      param_range.end = state->current_token.range.end;
-
-      ID id = INTERN_TOKEN(state, state->current_token);
-      name = ID2SYM(id);
-
-      parser_insert_typevar(state, id);
-
-      VALUE location = rbs_new_location(state->buffer, param_range);
-      rbs_loc *loc = rbs_check_location(location);
-      rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
-      rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
-      rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
-
-      VALUE param = rbs_ast_decl_module_type_params_param(name, variance, unchecked, location);
-      rb_funcall(params, rb_intern("add"), 1, param);
-
-      if (state->next_token.type == pCOMMA) {
-        parser_advance(state);
-      }
-
-      if (state->next_token.type == pRBRACKET) {
-        break;
-      }
-    }
-
-    parser_advance_assert(state, pRBRACKET);
-    rg->end = state->current_token.range.end;
-  } else {
-    *rg = NULL_RANGE;
-  }
-
-  return params;
-}
-
 /*
   annotations ::= {} annotation ... <annotation>
                 | {<>}

data/ext/rbs_extension/ruby_objs.c

@@ -70,15 +70,16 @@ VALUE rbs_class_singleton(VALUE typename, VALUE location) {
   );
 }
 
-VALUE rbs_alias(VALUE typename, VALUE location) {
-  VALUE args = rb_hash_new();
-  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
-  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+VALUE rbs_alias(VALUE typename, VALUE args, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("args")), args);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
 
   return CLASS_NEW_INSTANCE(
     RBS_Types_Alias,
     1,
-    &args
+    &kwargs
   );
 }
 
@@ -339,9 +340,10 @@ VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment)
   );
 }
 
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
   rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
   rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);

data/ext/rbs_extension/ruby_objs.h

@@ -3,10 +3,10 @@
 
 #include "ruby.h"
 
-VALUE rbs_alias(VALUE typename, VALUE location);
+VALUE rbs_alias(VALUE typename, VALUE args, VALUE location);
 VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, VALUE location);
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);

data/lib/rbs/ast/declarations.rb

@@ -362,13 +362,15 @@ module RBS
 
       class Alias < Base
         attr_reader :name
+        attr_reader :type_params
         attr_reader :type
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
 
-        def initialize(name:, type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, type:, annotations:, location:, comment:)
           @name = name
+          @type_params = type_params
           @type = type
           @annotations = annotations
           @location = location
@@ -378,19 +380,21 @@ module RBS
         def ==(other)
           other.is_a?(Alias) &&
             other.name == name &&
+            other.type_params == type_params &&
             other.type == type
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ type.hash
         end
 
         def to_json(state = _ = nil)
           {
             declaration: :alias,
             name: name,
+            type_params: type_params,
             type: type,
             annotations: annotations,
             location: location,

data/lib/rbs/cli.rb

@@ -460,7 +460,7 @@ EOU
 
       env.alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
-        builder.expand_alias(name).tap do |type|
+        builder.expand_alias1(name).tap do |type|
           validator.validate_type type, context: [Namespace.root]
         end
         validator.validate_type_alias(entry: decl)

data/lib/rbs/definition_builder.rb

@@ -781,9 +781,36 @@ module RBS
     end
 
     def expand_alias(type_name)
-      entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      expand_alias2(type_name, [])
+    end
+
+    def expand_alias1(type_name)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+      as = entry.decl.type_params.each.map { Types::Bases::Any.new(location: nil) }
+      expand_alias2(type_name, as)
+    end
+
+    def expand_alias2(type_name, args)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
-      entry.decl.type
+      params = entry.decl.type_params.each.map(&:name)
+
+      unless params.size == args.size
+        as = "[#{args.join(", ")}]" unless args.empty?
+        ps = "[#{params.join(", ")}]" unless params.empty?
+
+        raise "Invalid type application: type = #{type_name}#{as}, decl = #{type_name}#{ps}"
+      end
+
+      type = entry.decl.type
+
+      unless params.empty?
+        subst = Substitution.build(params, args)
+        type = type.sub(subst)
+      end
+
+      type
     end
 
     def update(env:, except:, ancestor_builder:)

data/lib/rbs/environment.rb

@@ -319,6 +319,7 @@ module RBS
       when AST::Declarations::Alias
         AST::Declarations::Alias.new(
           name: decl.name.with_prefix(prefix),
+          type_params: decl.type_params,
           type: absolute_type(resolver, decl.type, context: context),
           location: decl.location,
           annotations: decl.annotations,

data/lib/rbs/environment_walker.rb

@@ -57,7 +57,7 @@ module RBS
             end
           end
         when name.alias?
-          each_type_node builder.expand_alias(name), &block
+          each_type_node builder.expand_alias1(name), &block
         else
           raise "Unexpected TypeNameNode with type_name=#{name}"
         end
@@ -126,6 +126,9 @@ module RBS
         end
       when RBS::Types::Alias
         yield TypeNameNode.new(type_name: type.name)
+        type.args.each do |ty|
+          each_type_node(ty, &block)
+        end
       when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
         type.types.each do |ty|
           each_type_node ty, &block

data/lib/rbs/errors.rb

@@ -431,4 +431,16 @@ module RBS
       @alias_names.map(&:name).join(', ')
     end
   end
+
+  class NonregularTypeAliasError < LoadingError
+    attr_reader :diagnostic
+    attr_reader :location
+
+    def initialize(diagnostic:, location:)
+      @diagnostic = diagnostic
+      @location = location
+
+      super "#{Location.to_string location}: Nonregular generic type alias is prohibited: #{diagnostic.type_name}, #{diagnostic.nonregular_type}"
+    end
+  end
 end