rbs 1.7.0.beta.4 → 1.8.0

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

data/lib/rbs/prototype/helpers.rb

@@ -0,0 +1,113 @@
+module RBS
+  module Prototype
+    module Helpers
+      private
+
+      def block_from_body(node)
+        _, args_node, body_node = node.children
+
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
+
+        method_block = nil
+
+        if block
+          method_block = Types::Block.new(
+            # HACK: The `block` is :& on `def m(...)` syntax.
+            #       In this case the block looks optional in most cases, so it marks optional.
+            #       In other cases, we can't determine which is required or optional, so it marks required.
+            required: block != :&,
+            type: Types::Function.empty(untyped)
+          )
+        end
+
+        if body_node
+          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
+            method_block = Types::Block.new(
+              required: true,
+              type: Types::Function.empty(untyped)
+            )
+
+            yields.each do |yield_node|
+              array_content = yield_node.children[0]&.children&.compact || []
+
+              positionals, keywords = if keyword_hash?(array_content.last)
+                                        [array_content.take(array_content.size - 1), array_content.last]
+                                      else
+                                        [array_content, nil]
+                                      end
+
+              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+                diff.times do
+                  method_block.type.required_positionals << Types::Function::Param.new(
+                    type: untyped,
+                    name: nil
+                  )
+                end
+              end
+
+              if keywords
+                keywords.children[0].children.each_slice(2) do |key_node, value_node|
+                  if key_node
+                    key = key_node.children[0]
+                    method_block.type.required_keywords[key] ||=
+                      Types::Function::Param.new(
+                        type: untyped,
+                        name: nil
+                      )
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        method_block
+      end
+
+      def each_child(node, &block)
+        each_node node.children, &block
+      end
+
+      def each_node(nodes)
+        nodes.each do |child|
+          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+            yield child
+          end
+        end
+      end
+
+
+      def any_node?(node, nodes: [], &block)
+        if yield(node)
+          nodes << node
+        end
+
+        each_child node do |child|
+          any_node? child, nodes: nodes, &block
+        end
+
+        nodes.empty? ? nil : nodes
+      end
+
+      def keyword_hash?(node)
+        if node
+          if node.type == :HASH
+            node.children[0].children.compact.each_slice(2).all? {|key, _|
+              key.type == :LIT && key.children[0].is_a?(Symbol)
+            }
+          end
+        end
+      end
+
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
+      end
+
+      def untyped
+        @untyped ||= Types::Bases::Any.new(location: nil)
+      end
+    end
+  end
+end

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class RB
+      include Helpers
+
       Context = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
         def self.initial(namespace: Namespace.root)
           self.new(module_function: false, singleton: false, namespace: namespace)
@@ -372,18 +374,6 @@ module RBS
         end
       end
 
-      def each_node(nodes)
-        nodes.each do |child|
-          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
-            yield child
-          end
-        end
-      end
-
-      def each_child(node, &block)
-        each_node node.children, &block
-      end
-
       def function_type_from_body(node, def_name)
         table_node, args_node, *_ = node.children
 
@@ -568,95 +558,6 @@ module RBS
         end
       end
 
-      def block_from_body(node)
-        _, args_node, body_node = node.children
-
-        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
-
-        method_block = nil
-
-        if block
-          method_block = Types::Block.new(
-            # HACK: The `block` is :& on `def m(...)` syntax.
-            #       In this case the block looks optional in most cases, so it marks optional.
-            #       In other cases, we can't determine which is required or optional, so it marks required.
-            required: block != :&,
-            type: Types::Function.empty(untyped)
-          )
-        end
-
-        if body_node
-          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = Types::Block.new(
-              required: true,
-              type: Types::Function.empty(untyped)
-            )
-
-            yields.each do |yield_node|
-              array_content = yield_node.children[0]&.children&.compact || []
-
-              positionals, keywords = if keyword_hash?(array_content.last)
-                                        [array_content.take(array_content.size - 1), array_content.last]
-                                      else
-                                        [array_content, nil]
-                                      end
-
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
-                diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
-                    type: untyped,
-                    name: nil
-                  )
-                end
-              end
-
-              if keywords
-                keywords.children[0].children.each_slice(2) do |key_node, value_node|
-                  if key_node
-                    key = key_node.children[0]
-                    method_block.type.required_keywords[key] ||=
-                      Types::Function::Param.new(
-                        type: untyped,
-                        name: nil
-                      )
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        method_block
-      end
-
-      # NOTE: args_node may be a nil by a bug
-      #       https://bugs.ruby-lang.org/issues/17495
-      def args_from_node(args_node)
-        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
-      end
-
-      def keyword_hash?(node)
-        if node
-          if node.type == :HASH
-            node.children[0].children.compact.each_slice(2).all? {|key, _|
-              key.type == :LIT && key.children[0].is_a?(Symbol)
-            }
-          end
-        end
-      end
-
-      def any_node?(node, nodes: [], &block)
-        if yield(node)
-          nodes << node
-        end
-
-        each_child node do |child|
-          any_node? child, nodes: nodes, &block
-        end
-
-        nodes.empty? ? nil : nodes
-      end
-
       def node_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
         when :LIT
@@ -689,10 +590,6 @@ module RBS
         end
       end
 
-      def untyped
-        @untyped ||= Types::Bases::Any.new(location: nil)
-      end
-
       def private
         @private ||= AST::Members::Private.new(location: nil)
       end

data/lib/rbs/prototype/runtime.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class Runtime
+      include Helpers
+
       attr_reader :patterns
       attr_reader :env
       attr_reader :merge
@@ -138,6 +140,8 @@ module RBS
           end
         end
 
+        block ||= block_from_ast_of(method)
+
         return_type = if method.name == :initialize
                         Types::Bases::Void.new(location: nil)
                       else
@@ -522,6 +526,18 @@ module RBS
           []
         end
       end
+
+      def block_from_ast_of(method)
+        return nil if RUBY_VERSION < '3.1'
+
+        begin
+          ast = RubyVM::AbstractSyntaxTree.of(method)
+        rescue ArgumentError
+          return # When the method is defined in eval
+        end
+
+        block_from_body(ast) if ast&.type == :SCOPE
+      end
     end
   end
 end

data/lib/rbs/test/setup.rb

@@ -13,6 +13,7 @@ begin
   filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
   skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
   RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
+  logger.level = RBS.logger_level
   sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
   double_class = to_double_class(ENV['RBS_TEST_DOUBLE_SUITE'])
   unchecked_classes = (ENV['RBS_TEST_UNCHECKED_CLASSES'] || '').split(',').map! { |unchecked_class| unchecked_class.strip }.push(*double_class)

data/lib/rbs/type_alias_regularity.rb

@@ -0,0 +1,115 @@
+module RBS
+  class TypeAliasRegularity
+    class Diagnostic
+      attr_reader :type_name, :nonregular_type
+
+      def initialize(type_name:, nonregular_type:)
+        @type_name = type_name
+        @nonregular_type = nonregular_type
+      end
+    end
+
+    attr_reader :env, :builder, :diagnostics
+
+    def initialize(env:)
+      @env = env
+      @builder = DefinitionBuilder.new(env: env)
+      @diagnostics = {}
+    end
+
+    def validate
+      diagnostics.clear
+
+      each_mutual_alias_defs do |names|
+        # Find the first generic type alias in strongly connected component.
+        # This is to skip the regularity check when the alias is not generic.
+        names.each do |name|
+          # @type break: nil
+          if type = build_alias_type(name)
+            # Running validation only once from the first generic type is enough, because they are mutual recursive definition.
+            validate_alias_type(type, names, {})
+            break
+          end
+        end
+      end
+    end
+
+    def validate_alias_type(alias_type, names, types)
+      if names.include?(alias_type.name)
+        if ex_type = types[alias_type.name]
+          unless compatible_args?(ex_type.args, alias_type.args)
+            diagnostics[alias_type.name] ||=
+              Diagnostic.new(type_name: alias_type.name, nonregular_type: alias_type)
+          end
+
+          return
+        else
+          types[alias_type.name] = alias_type
+        end
+
+        expanded = builder.expand_alias2(alias_type.name, alias_type.args)
+        each_alias_type(expanded) do |at|
+          validate_alias_type(at, names, types)
+        end
+      end
+    end
+
+    def build_alias_type(name)
+      entry = env.alias_decls[name] or raise "Unknown alias name: #{name}"
+      unless entry.decl.type_params.empty?
+        as = entry.decl.type_params.each.map {|param| Types::Variable.new(name: param.name, location: nil) }
+        Types::Alias.new(name: name, args: as, location: nil)
+      end
+    end
+
+    def compatible_args?(args1, args2)
+      if args1.size == args2.size
+        args1.zip(args2).all? do |t1, t2|
+          t1.is_a?(Types::Bases::Any) ||
+            t2.is_a?(Types::Bases::Any) ||
+            t1 == t2
+        end
+      end
+    end
+
+    def nonregular?(type_name)
+      diagnostics[type_name]
+    end
+
+    def each_mutual_alias_defs(&block)
+      # @type var each_node: TSort::_EachNode[TypeName]
+      each_node = __skip__ = -> (&block) do
+        env.alias_decls.each_value do |decl|
+          block[decl.name]
+        end
+      end
+      # @type var each_child: TSort::_EachChild[TypeName]
+      each_child = __skip__ = -> (name, &block) do
+        type = builder.expand_alias1(name)
+        each_alias_type(type) do |ty|
+          block[ty.name]
+        end
+      end
+
+      TSort.each_strongly_connected_component(each_node, each_child) do |names|
+        yield Set.new(names)
+      end
+    end
+
+    def each_alias_type(type, &block)
+      if type.is_a?(RBS::Types::Alias)
+        yield type
+      end
+
+      type.each_type do |ty|
+        each_alias_type(ty, &block)
+      end
+    end
+
+    def self.validate(env:)
+      self.new(env: env).tap do |validator|
+        validator.validate()
+      end
+    end
+  end
+end

data/lib/rbs/types.rb

@@ -295,39 +295,27 @@ module RBS
 
     class Alias
       attr_reader :location
-      attr_reader :name
 
-      def initialize(name:, location:)
+      include Application
+
+      def initialize(name:, args:, location:)
         @name = name
+        @args = args
         @location = location
       end
 
-      def ==(other)
-        other.is_a?(Alias) && other.name == name
-      end
-
-      alias eql? ==
-
-      def hash
-        self.class.hash ^ name.hash
-      end
-
-      include NoFreeVariables
-      include NoSubst
-
       def to_json(state = _ = nil)
-        { class: :alias, name: name, location: location }.to_json(state)
+        { class: :alias, name: name, args: args, location: location }.to_json(state)
       end
 
-      def to_s(level = 0)
-        name.to_s
+      def sub(s)
+        Alias.new(name: name, args: args.map {|ty| ty.sub(s) }, location: location)
       end
 
-      include EmptyEachType
-
-      def map_type_name
+      def map_type_name(&block)
         Alias.new(
           name: yield(name, location, self),
+          args: args.map {|arg| arg.map_type_name(&block) },
           location: location
         )
       end
@@ -433,7 +421,7 @@ module RBS
         return "{ }" if self.fields.empty?
 
         fields = self.fields.map do |key, type|
-          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) && !Parser::KEYWORDS.include?(key)
+          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/)
             "#{key}: #{type}"
           else
             "#{key.inspect} => #{type}"
@@ -690,7 +678,7 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.include?(name)
+            if Parser::KEYWORDS.include?(name.to_s)
               "#{type} `#{name}`"
             else
               "#{type} #{name}"

data/lib/rbs/validator.rb

@@ -2,10 +2,12 @@ module RBS
   class Validator
     attr_reader :env
     attr_reader :resolver
+    attr_reader :definition_builder
 
     def initialize(env:, resolver:)
       @env = env
       @resolver = resolver
+      @definition_builder = DefinitionBuilder.new(env: env)
     end
 
     def absolute_type(type, context:)
@@ -17,8 +19,8 @@ module RBS
     # Validates presence of the relative type, and application arity match.
     def validate_type(type, context:)
       case type
-      when Types::ClassInstance, Types::Interface
-        # @type var type: Types::ClassInstance | Types::Interface
+      when Types::ClassInstance, Types::Interface, Types::Alias
+        # @type var type: Types::ClassInstance | Types::Interface | Types::Alias
         if type.name.namespace.relative?
           type = _ = absolute_type(type, context: context) do |_|
             NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
@@ -30,6 +32,8 @@ module RBS
                         env.class_decls[type.name]&.type_params
                       when Types::Interface
                         env.interface_decls[type.name]&.decl&.type_params
+                      when Types::Alias
+                        env.alias_decls[type.name]&.decl&.type_params
                       end
 
         unless type_params
@@ -43,8 +47,8 @@ module RBS
           location: type.location
         )
 
-      when Types::Alias, Types::ClassSingleton
-        # @type var type: Types::Alias | Types::ClassSingleton
+      when Types::ClassSingleton
+        # @type var type: Types::ClassSingleton
         type = _ = absolute_type(type, context: context) { type.name.absolute! }
         NoTypeFoundError.check!(type.name, env: env, location: type.location)
       end
@@ -55,11 +59,40 @@ module RBS
     end
 
     def validate_type_alias(entry:)
-      @type_alias_dependency ||= TypeAliasDependency.new(env: env)
-      if @type_alias_dependency.circular_definition?(entry.decl.name)
+      type_name = entry.decl.name
+
+      if type_alias_dependency.circular_definition?(type_name)
         location = entry.decl.location or raise
-        raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: location)
+        raise RecursiveTypeAliasError.new(alias_names: [type_name], location: location)
+      end
+
+      if diagnostic = type_alias_regularity.nonregular?(type_name)
+        location = entry.decl.location or raise
+        raise NonregularTypeAliasError.new(diagnostic: diagnostic, location: location)
+      end
+
+      unless entry.decl.type_params.empty?
+        calculator = VarianceCalculator.new(builder: definition_builder)
+        result = calculator.in_type_alias(name: type_name)
+        if set = result.incompatible?(entry.decl.type_params)
+          set.each do |param_name|
+            param = entry.decl.type_params[param_name] or raise
+            raise InvalidVarianceAnnotationError.new(
+              type_name: type_name,
+              param: param,
+              location: entry.decl.type.location
+            )
+          end
+        end
       end
     end
+
+    def type_alias_dependency
+      @type_alias_dependency ||= TypeAliasDependency.new(env: env)
+    end
+
+    def type_alias_regularity
+      @type_alias_regularity ||= TypeAliasRegularity.validate(env: env)
+    end
   end
 end