Add support for lower bounds in type parameters

This change implements lower bound constraints for generic type
parameters in RBS, allowing declarations like `[T > SomeType]`.

The implementation includes:
- Parser and lexer modifications to handle ">" token in type params
- Relevant changes to the Ruby API, like Locator and Validator
- Schema updates to typeParam.json
- Documentation updates

Author: allcre

config.yml

@@ -279,6 +279,8 @@ nodes:
         c_type: rbs_keyword
       - name: upper_bound
         c_type: rbs_node
+      - name: lower_bound
+        c_type: rbs_node
       - name: default_type
         c_type: rbs_node
       - name: unchecked

docs/syntax.md

@@ -650,7 +650,7 @@ _module-type-parameters_ ::=                                                  #
 
 Class declaration can have type parameters and superclass. When you omit superclass, `::Object` is assumed.
 
-* Super class arguments and generic class upperbounds are not *classish-context* nor *self-context*
+* Super class arguments and generic class bounds are not *classish-context* nor *self-context*
 
 ### Module declaration
 
@@ -668,7 +668,7 @@ end
 
 The `Enumerable` module above requires `each` method for enumerating objects.
 
-* Self type arguments and generic class upperbounds are not *classish-context* nor *self-context*
+* Self type arguments and generic class bounds are not *classish-context* nor *self-context*
 
 ### Class/module alias declaration
 
@@ -764,7 +764,11 @@ _module-type-parameter_ ::= _generics-unchecked_ _generics-variance_ _type-varia
 _method-type-param_ ::= _type-variable_ _generics-bound_
 
 _generics-bound_ ::=                 (No type bound)
-                   | `<` _type_      (The generics parameter is bounded)
+                   | `<` _type_      (The generics parameter has an upper bound)
+                   | '>' _type_      (The generics parameter has a lower bound)
+
+# A type parameter can have both upper and lower bounds, which can be specified in either order:
+# `[T < UpperBound > LowerBound]` or `[T > LowerBound < UpperBound]`
 
 _default-type_ ::=                    (No default type)
                  | `=` _type_         (The generics parameter has default type)
@@ -834,13 +838,38 @@ class PrettyPrint[T < _Output]
 end
 ```
 
-If a type parameter has an upper bound, the type parameter must be instantiated with types that is a subtype of the upper bound.
+If a type parameter has an upper bound, the type parameter must be instantiated with types that are a subtype of the upper bound.
 
 ```rbs
 type str_printer = PrettyPrint[String]    # OK
 type int_printer = PrettyPrint[Integer]   # Type error
 ```
 
+If a type parameter has a lower bound, the type parameter must be instantiated with types that are a supertype of the lower bound.
+
+```rbs
+class PrettyPrint[T > Numeric]
+end
+
+type obj_printer = PrettyPrint[Object]    # OK
+type int_printer = PrettyPrint[Integer]   # Type error
+```
+
+A type parameter can have both an upper and a lower bound, and these bounds can be specified in any order.
+
+```rbs
+class FlexibleProcessor[T > Integer < Numeric]
+  # This class processes types T that are supertypes of Integer but also subtypes of Numeric.
+  # This includes Integer, Rational, Complex, Float, and Numeric itself.
+  def calculate: (T) -> T
+end
+
+type int_processor = FlexibleProcessor[Integer]   # OK (Integer > Integer and Integer < Numeric)
+type num_processor = FlexibleProcessor[Numeric]   # OK (Numeric > Integer and Numeric < Numeric)
+type obj_processor = FlexibleProcessor[Object]    # Type error (Object is not < Numeric)
+type str_processor = FlexibleProcessor[String]    # Type error (String is not > Integer)
+```
+
 The generics type parameter of modules, classes, interfaces, or type aliases can have a default type.
 
 ```rbs

ext/rbs_extension/ast_translation.c

@@ -663,6 +663,7 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
         rb_hash_aset(h, ID2SYM(rb_intern("name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->name));                 // rbs_ast_symbol
         rb_hash_aset(h, ID2SYM(rb_intern("variance")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->variance));         // rbs_keyword
         rb_hash_aset(h, ID2SYM(rb_intern("upper_bound")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->upper_bound));   // rbs_node
+        rb_hash_aset(h, ID2SYM(rb_intern("lower_bound")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->lower_bound));   // rbs_node
         rb_hash_aset(h, ID2SYM(rb_intern("default_type")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->default_type)); // rbs_node
         rb_hash_aset(h, ID2SYM(rb_intern("unchecked")), node->unchecked ? Qtrue : Qfalse);
 

include/rbs/ast.h

@@ -450,6 +450,7 @@ typedef struct rbs_ast_type_param {
     struct rbs_ast_symbol *name;
     struct rbs_keyword *variance;
     struct rbs_node *upper_bound;
+    struct rbs_node *lower_bound;
     struct rbs_node *default_type;
     bool unchecked;
 } rbs_ast_type_param_t;
@@ -712,7 +713,7 @@ rbs_ast_ruby_annotations_node_type_assertion_t *rbs_ast_ruby_annotations_node_ty
 rbs_ast_ruby_annotations_return_type_annotation_t *rbs_ast_ruby_annotations_return_type_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *return_location, rbs_location_t *colon_location, rbs_node_t *return_type, rbs_location_t *comment_location);
 rbs_ast_ruby_annotations_skip_annotation_t *rbs_ast_ruby_annotations_skip_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *skip_location, rbs_location_t *comment_location);
 rbs_ast_string_t *rbs_ast_string_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_string_t string);
-rbs_ast_type_param_t *rbs_ast_type_param_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_ast_symbol_t *name, rbs_keyword_t *variance, rbs_node_t *upper_bound, rbs_node_t *default_type, bool unchecked);
+rbs_ast_type_param_t *rbs_ast_type_param_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_ast_symbol_t *name, rbs_keyword_t *variance, rbs_node_t *upper_bound, rbs_node_t *lower_bound, rbs_node_t *default_type, bool unchecked);
 rbs_method_type_t *rbs_method_type_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *type_params, rbs_node_t *type, rbs_types_block_t *block);
 rbs_namespace_t *rbs_namespace_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *path, bool absolute);
 rbs_signature_t *rbs_signature_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *directives, rbs_node_list_t *declarations);

include/rbs/lexer.h

@@ -30,6 +30,7 @@ enum RBSTokenType {
     pBANG,     /* ! */
     pQUESTION, /* ? */
     pLT,       /* < */
+    pGT,       /* > */
     pEQ,       /* = */
 
     kALIAS,        /* alias */

include/rbs/util/rbs_allocator.h

@@ -10,7 +10,10 @@
 #define alignof(type) __alignof(type)
 #else
 // Fallback using offset trick
-#define alignof(type) offsetof(struct { char c; type member; }, member)
+#define alignof(type) offsetof( \
+    struct { char c; type member; },                 \
+    member                      \
+)
 #endif
 #endif
 

lib/rbs/ast/type_param.rb

@@ -3,12 +3,13 @@
 module RBS
   module AST
     class TypeParam
-      attr_reader :name, :variance, :location, :upper_bound_type, :default_type
+      attr_reader :name, :variance, :location, :upper_bound_type, :lower_bound_type, :default_type
 
-      def initialize(name:, variance:, upper_bound:, location:, default_type: nil, unchecked: false)
+      def initialize(name:, variance:, upper_bound:, lower_bound:, location:, default_type: nil, unchecked: false)
         @name = name
         @variance = variance
         @upper_bound_type = upper_bound
+        @lower_bound_type = lower_bound
         @location = location
         @default_type = default_type
         @unchecked = unchecked
@@ -21,6 +22,13 @@ def upper_bound
         end
       end
 
+      def lower_bound
+        case lower_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          lower_bound_type
+        end
+      end
+
       def unchecked!(value = true)
         @unchecked = value ? true : false
         self
@@ -35,14 +43,15 @@ def ==(other)
           other.name == name &&
           other.variance == variance &&
           other.upper_bound_type == upper_bound_type &&
+          other.lower_bound_type == lower_bound_type &&
           other.default_type == default_type &&
           other.unchecked? == unchecked?
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ unchecked?.hash ^ default_type.hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ lower_bound_type.hash ^ unchecked?.hash ^ default_type.hash
       end
 
       def to_json(state = JSON::State.new)
@@ -52,6 +61,7 @@ def to_json(state = JSON::State.new)
           unchecked: unchecked?,
           location: location,
           upper_bound: upper_bound_type,
+          lower_bound: lower_bound_type,
           default_type: default_type
         }.to_json(state)
       end
@@ -61,6 +71,10 @@ def map_type(&block)
           _upper_bound_type = yield(b)
         end
 
+        if b = lower_bound_type
+          _lower_bound_type = yield(b)
+        end
+
         if dt = default_type
           _default_type = yield(dt)
         end
@@ -69,6 +83,7 @@ def map_type(&block)
           name: name,
           variance: variance,
           upper_bound: _upper_bound_type,
+          lower_bound: _lower_bound_type,
           location: location,
           default_type: _default_type
         ).unchecked!(unchecked?)
@@ -108,6 +123,7 @@ def self.rename(params, new_names:)
             name: new_name,
             variance: param.variance,
             upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            lower_bound: param.lower_bound_type&.map_type {|type| type.sub(subst) },
             location: param.location,
             default_type: param.default_type&.map_type {|type| type.sub(subst) }
           ).unchecked!(param.unchecked?)
@@ -136,6 +152,10 @@ def to_s
           s << " < #{type}"
         end
 
+        if type = lower_bound_type
+          s << " > #{type}"
+        end
+
         if dt = default_type
           s << " = #{dt}"
         end

lib/rbs/cli/validate.rb

@@ -159,6 +159,13 @@ def validate_class_module_definition
               @validator.validate_type(ub, context: nil)
             end
 
+            if lb = param.lower_bound_type
+              void_type_context_validator(lb)
+              no_self_type_validator(lb)
+              no_classish_type_validator(lb)
+              @validator.validate_type(lb, context: nil)
+            end
+
             if dt = param.default_type
               void_type_context_validator(dt, true)
               no_self_type_validator(dt)
@@ -244,6 +251,13 @@ def validate_interface
               @validator.validate_type(ub, context: nil)
             end
 
+            if lb = param.lower_bound_type
+              void_type_context_validator(lb)
+              no_self_type_validator(lb)
+              no_classish_type_validator(lb)
+              @validator.validate_type(lb, context: nil)
+            end
+
             if dt = param.default_type
               void_type_context_validator(dt, true)
               no_self_type_validator(dt)
@@ -317,6 +331,13 @@ def validate_type_alias
               @validator.validate_type(ub, context: nil)
             end
 
+            if lb = param.lower_bound_type
+              void_type_context_validator(lb)
+              no_self_type_validator(lb)
+              no_classish_type_validator(lb)
+              @validator.validate_type(lb, context: nil)
+            end
+
             if dt = param.default_type
               void_type_context_validator(dt, true)
               no_self_type_validator(dt)

lib/rbs/locator.rb

@@ -177,6 +177,10 @@ def find_in_type_param(pos, type_param:, array:)
           find_in_type(pos, type: upper_bound, array: array) and return true
         end
 
+        if lower_bound = type_param.lower_bound_type
+          find_in_type(pos, type: lower_bound, array: array) and return true
+        end
+
         if default_type = type_param.default_type
           find_in_type(pos, type: default_type, array: array) and return true
         end

lib/rbs/prototype/rbi.rb

@@ -235,6 +235,7 @@ def process(node, outer: [], comments:)
                 variance: variance || :invariant,
                 location: nil,
                 upper_bound: nil,
+                lower_bound: nil,
                 default_type: nil
               )
             end
@@ -332,6 +333,7 @@ def method_type(args_node, type_node, variables:, overloads:)
                   name: name,
                   variance: :invariant,
                   upper_bound: nil,
+                  lower_bound: nil,
                   location: nil,
                   default_type: nil
                 )