rbs 1.7.0 → 2.0.0.pre1

data/lib/rbs/environment.rb

@@ -39,22 +39,29 @@ module RBS
 
       def validate_type_params
         unless decls.empty?
+          # @type var hd_decl: MultiEntry::D[module_decl]
+          # @type var tl_decls: Array[MultiEntry::D[module_decl]]
           hd_decl, *tl_decls = decls
           raise unless hd_decl
 
           hd_params = hd_decl.decl.type_params
-          hd_names = hd_params.params.map(&:name)
 
           tl_decls.each do |tl_decl|
             tl_params = tl_decl.decl.type_params
 
-            unless hd_params.size == tl_params.size && hd_params == tl_params.rename_to(hd_names)
+            unless compatible_params?(hd_params, tl_params)
               raise GenericParameterMismatchError.new(name: name, decl: tl_decl.decl)
             end
           end
         end
       end
 
+      def compatible_params?(ps1, ps2)
+        if ps1.size == ps2.size
+          ps1 == AST::TypeParam.rename(ps2, new_names: ps1.map(&:name))
+        end
+      end
+
       def type_params
         primary.decl.type_params
       end
@@ -240,17 +247,19 @@ module RBS
         array.unshift(head + decl.name.to_namespace)
       end
 
+      outer_context = context.drop(1)
+
       case decl
       when AST::Declarations::Class
         outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Class.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           super_class: decl.super_class&.yield_self do |super_class|
             AST::Declarations::Class::Super.new(
-              name: absolute_type_name(resolver, super_class.name, context: context),
-              args: super_class.args.map {|type| absolute_type(resolver, type, context: context) },
+              name: absolute_type_name(resolver, super_class.name, context: outer_context),
+              args: super_class.args.map {|type| absolute_type(resolver, type, context: outer_context) },
               location: super_class.location
             )
           end,
@@ -278,7 +287,7 @@ module RBS
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           self_types: decl.self_types.map do |module_self|
             AST::Declarations::Module::Self.new(
               name: absolute_type_name(resolver, module_self.name, context: context),
@@ -308,7 +317,7 @@ module RBS
       when AST::Declarations::Interface
         AST::Declarations::Interface.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           members: decl.members.map do |member|
             resolve_member(resolver, member, context: context)
           end,
@@ -319,6 +328,7 @@ module RBS
       when AST::Declarations::Alias
         AST::Declarations::Alias.new(
           name: decl.name.with_prefix(prefix),
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           type: absolute_type(resolver, decl.type, context: context),
           location: decl.location,
           annotations: decl.annotations,
@@ -342,7 +352,7 @@ module RBS
           name: member.name,
           kind: member.kind,
           types: member.types.map do |type|
-            type.map_type {|ty| absolute_type(resolver, ty, context: context) }
+            resolve_method_type(resolver, type, context: context)
           end,
           comment: member.comment,
           overload: member.overload?,
@@ -429,6 +439,20 @@ module RBS
       end
     end
 
+    def resolve_method_type(resolver, type, context:)
+      type.map_type do |ty|
+        absolute_type(resolver, ty, context: context)
+      end.map_type_bound do |bound|
+        _ = absolute_type(resolver, bound, context: context)
+      end
+    end
+
+    def resolve_type_params(resolver, params, context:)
+      params.map do |param|
+        param.map_type {|type| _ = absolute_type(resolver, type, context: context) }
+      end
+    end
+
     def absolute_type_name(resolver, type_name, context:)
       resolver.resolve(type_name, context: context) || type_name
     end

data/lib/rbs/environment_loader.rb

@@ -48,8 +48,6 @@ module RBS
     end
 
     def add_collection(collection_config)
-      warn "warning: rbs collection is experimental, and the behavior may change until RBS v2.0"
-
       collection_config.check_rbs_availability!
 
       repository.add(collection_config.repo_path)

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

@@ -14,11 +14,11 @@ module RBS
     end
   end
 
-  class ErrorBase < StandardError; end
-  class LoadingError < ErrorBase; end
-  class DefinitionError < ErrorBase; end
+  class BaseError < StandardError; end
+  class LoadingError < BaseError; end
+  class DefinitionError < BaseError; end
 
-  class ParsingError < ErrorBase
+  class ParsingError < BaseError
     attr_reader :location
     attr_reader :error_message
     attr_reader :token_type
@@ -105,7 +105,7 @@ module RBS
     end
   end
 
-  class NoTypeFoundError < ErrorBase
+  class NoTypeFoundError < BaseError
     attr_reader :type_name
     attr_reader :location
 
@@ -416,7 +416,7 @@ module RBS
     end
   end
 
-  class RecursiveTypeAliasError < LoadingError
+  class RecursiveTypeAliasError < BaseError
     attr_reader :alias_names
     attr_reader :location
 
@@ -431,4 +431,29 @@ module RBS
       @alias_names.map(&:name).join(', ')
     end
   end
+
+  class NonregularTypeAliasError < BaseError
+    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
+
+  class CyclicTypeParameterBound < BaseError
+    attr_reader :params, :type_name, :method_name, :location
+
+    def initialize(type_name:, method_name:, params:, location:)
+      @type_name = type_name
+      @method_name = method_name
+      @params = params
+      @location = location
+
+      super "#{Location.to_string(location)}: Cyclic type parameter bound is prohibited"
+    end
+  end
 end

data/lib/rbs/location_aux.rb

@@ -17,6 +17,8 @@ module RBS
         end
     end
 
+    alias aref []
+
     WithChildren = self
 
     def name

data/lib/rbs/method_type.rb

@@ -29,11 +29,18 @@ module RBS
     end
 
     def sub(s)
-      s.without(*type_params).yield_self do |sub|
-        map_type do |ty|
-          ty.sub(sub)
-        end
-      end
+      sub = s.without(*type_param_names)
+
+      self.class.new(
+        type_params: type_params.map do |param|
+          param.map_type do |bound|
+            bound.map_type {|ty| ty.sub(sub) }
+          end
+        end,
+        type: type.sub(sub),
+        block: block&.sub(sub),
+        location: location
+      )
     end
 
     def update(type_params: self.type_params, type: self.type, block: self.block, location: self.location)
@@ -48,7 +55,7 @@ module RBS
     def free_variables(set = Set.new)
       type.free_variables(set)
       block&.type&.free_variables(set)
-      set.subtract(type_params)
+      set.subtract(type_param_names)
     end
 
     def map_type(&block)
@@ -62,6 +69,18 @@ module RBS
       )
     end
 
+    def map_type_bound(&block)
+      if type_params.empty?
+        self
+      else
+        self.update(
+          type_params: type_params.map {|param|
+            param.map_type(&block)
+          }
+        )
+      end
+    end
+
     def each_type(&block)
       if block
         type.each_type(&block)
@@ -89,5 +108,9 @@ module RBS
         "[#{type_params.join(", ")}] #{s}"
       end
     end
+
+    def type_param_names
+      type_params.map(&:name)
+    end
   end
 end

data/lib/rbs/prototype/rb.rb

@@ -49,7 +49,7 @@ module RBS
             annotations: [],
             comment: nil,
             location: nil,
-            type_params: AST::Declarations::ModuleTypeParams.empty
+            type_params: []
           )
           decls << top
         end
@@ -88,7 +88,7 @@ module RBS
           kls = AST::Declarations::Class.new(
             name: const_to_name(class_name),
             super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             members: [],
             annotations: [],
             location: nil,
@@ -108,7 +108,7 @@ module RBS
 
           mod = AST::Declarations::Module.new(
             name: const_to_name(module_name),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             self_types: [],
             members: [],
             annotations: [],

data/lib/rbs/prototype/rbi.rb

@@ -48,7 +48,7 @@ module RBS
         modules.push AST::Declarations::Class.new(
           name: nested_name(name),
           super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
-          type_params: AST::Declarations::ModuleTypeParams.empty,
+          type_params: [],
           members: [],
           annotations: [],
           location: nil,
@@ -65,7 +65,7 @@ module RBS
       def push_module(name, comment:)
         modules.push AST::Declarations::Module.new(
           name: nested_name(name),
-          type_params: AST::Declarations::ModuleTypeParams.empty,
+          type_params: [],
           members: [],
           annotations: [],
           location: nil,
@@ -212,10 +212,12 @@ module RBS
                            end
               end
 
-              current_module.type_params.add(
-                AST::Declarations::ModuleTypeParams::TypeParam.new(name: node.children[0],
-                                                                   variance: variance || :invariant,
-                                                                   skip_validation: false))
+              current_module.type_params << AST::TypeParam.new(
+                name: node.children[0],
+                variance: variance || :invariant,
+                location: nil,
+                upper_bound: nil
+              )
             end
           else
             name = node.children[0].yield_self do |n|

data/lib/rbs/prototype/runtime.rb

@@ -371,7 +371,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Class.new(
             name: to_type_name(only_name(mod)),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             super_class: generate_super_class(mod),
             members: [],
             annotations: [],
@@ -425,7 +425,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Module.new(
             name: to_type_name(only_name(mod)),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             self_types: [],
             members: [],
             annotations: [],
@@ -479,7 +479,7 @@ module RBS
             if outer_module.is_a?(Class)
               outer_decl = AST::Declarations::Class.new(
                 name: to_type_name(outer_module_name),
-                type_params: AST::Declarations::ModuleTypeParams.empty,
+                type_params: [],
                 super_class: generate_super_class(outer_module),
                 members: [],
                 annotations: [],
@@ -489,7 +489,7 @@ module RBS
             else
               outer_decl = AST::Declarations::Module.new(
                 name: to_type_name(outer_module_name),
-                type_params: AST::Declarations::ModuleTypeParams.empty,
+                type_params: [],
                 self_types: [],
                 members: [],
                 annotations: [],

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

@@ -26,6 +26,14 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type(&block)
+        if block
+          _ = self
+        else
+          enum_for(:map_type)
+        end
+      end
     end
 
     module Bases
@@ -261,6 +269,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Interface.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for(:map_type)
+        end
+      end
     end
 
     class ClassInstance
@@ -291,46 +311,58 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          ClassInstance.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     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
+
+      def map_type(&block)
+        if block
+          Alias.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Tuple
@@ -391,6 +423,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Tuple.new(
+            types: types.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Record
@@ -433,7 +476,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}"
@@ -456,6 +499,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Record.new(
+            fields: fields.transform_values {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Optional
@@ -515,6 +569,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Optional.new(
+            type: yield(type),
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Union
@@ -690,7 +755,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}"
@@ -1058,6 +1123,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Proc.new(
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Literal