rbs 1.7.1 → 1.8.0

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}"

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

data/lib/rbs/variance_calculator.rb

@@ -54,6 +54,21 @@ module RBS
           false
         end
       end
+
+      def incompatible?(params)
+        # @type set: Hash[Symbol]
+        set = Set[]
+
+        params.each do |param|
+          unless compatible?(param.name, with_annotation: param.variance)
+            set << param.name
+          end
+        end
+
+        unless set.empty?
+          set
+        end
+      end
     end
 
     attr_reader :builder
@@ -69,19 +84,12 @@ module RBS
     def in_method_type(method_type:, variables:)
       result = Result.new(variables: variables)
 
-      method_type.type.each_param do |param|
-        type(param.type, result: result, context: :contravariant)
-      end
+      function(method_type.type, result: result, context: :covariant)
 
       if block = method_type.block
-        block.type.each_param do |param|
-          type(param.type, result: result, context: :covariant)
-        end
-        type(block.type.return_type, result: result, context: :contravariant)
+        function(block.type, result: result, context: :contravariant)
       end
 
-      type(method_type.type.return_type, result: result, context: :covariant)
-
       result
     end
 
@@ -97,6 +105,14 @@ module RBS
       end
     end
 
+    def in_type_alias(name:)
+      decl = env.alias_decls[name].decl or raise
+      variables = decl.type_params.each.map(&:name)
+      Result.new(variables: variables).tap do |result|
+        type(decl.type, result: result, context: :covariant)
+      end
+    end
+
     def type(type, result:, context:)
       case type
       when Types::Variable
@@ -110,7 +126,7 @@ module RBS
             result.invariant(type.name)
           end
         end
-      when Types::ClassInstance, Types::Interface
+      when Types::ClassInstance, Types::Interface, Types::Alias
         NoTypeFoundError.check!(type.name,
                                 env: env,
                                 location: type.location)
@@ -120,6 +136,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
 
         type.args.each.with_index do |ty, i|
@@ -130,26 +148,36 @@ module RBS
           when :covariant
             type(ty, result: result, context: context)
           when :contravariant
-            # @type var con: variance
-            con = case context
-                  when :invariant
-                    :invariant
-                  when :covariant
-                    :contravariant
-                  when :contravariant
-                    :covariant
-                  else
-                    raise
-                  end
-            type(ty, result: result, context: con)
+            type(ty, result: result, context: negate(context))
           end
         end
-      when Types::Tuple, Types::Record, Types::Union, Types::Intersection
-        # Covariant types
+      when Types::Proc
+        function(type.type, result: result, context: context)
+      else
         type.each_type do |ty|
           type(ty, result: result, context: context)
         end
       end
     end
+
+    def function(type, result:, context:)
+      type.each_param do |param|
+        type(param.type, result: result, context: negate(context))
+      end
+      type(type.return_type, result: result, context: context)
+    end
+
+    def negate(variance)
+      case variance
+      when :invariant
+        :invariant
+      when :covariant
+        :contravariant
+      when :contravariant
+        :covariant
+      else
+        raise
+      end
+    end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.7.1"
+  VERSION = "1.8.0"
 end

data/lib/rbs/writer.rb

@@ -119,7 +119,7 @@ module RBS
       when AST::Declarations::Alias
         write_comment decl.comment
         write_annotation decl.annotations
-        puts "type #{decl.name} = #{decl.type}"
+        puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
 
       when AST::Declarations::Interface
         write_comment decl.comment

data/lib/rbs.rb

@@ -45,6 +45,7 @@ require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"
+require "rbs/type_alias_regularity"
 require "rbs/collection"
 
 require "rbs_extension"

data/schema/decls.json

@@ -12,6 +12,18 @@
         "name": {
           "type": "string"
         },
+        "type_params": {
+          "type": "object",
+          "properties": {
+            "params": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/moduleTypeParam"
+              }
+            }
+          },
+          "required": ["params"]
+        },
         "type": {
           "$ref": "types.json"
         },
@@ -28,7 +40,7 @@
           "$ref": "comment.json"
         }
       },
-      "required": ["declaration", "name", "type", "annotations", "location", "comment"]
+      "required": ["declaration", "name", "type_params", "type", "annotations", "location", "comment"]
     },
     "constant": {
       "title": "Constant declaration: `VERSION: String`, ...",

data/schema/types.json

@@ -106,7 +106,7 @@
       "required": ["class", "name", "args", "location"]
     },
     "alias": {
-      "title": "Type alias: `u`, `ty`, `json`, ...",
+      "title": "Type alias: `u`, `ty`, `json`, `list[Integer]`, ...",
       "type": "object",
       "properties": {
         "class": {
@@ -116,11 +116,17 @@
         "name": {
           "type": "string"
         },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
         "location": {
           "$ref": "location.json"
         }
       },
-      "required": ["class", "name", "location"]
+      "required": ["class", "name", "args", "location"]
     },
     "tuple": {
       "title": "Tuple type: `[Foo, bar]`, ...",

data/sig/declarations.rbs

@@ -217,19 +217,22 @@ module RBS
       end
 
       class Alias < Base
-        # type loc = Location
-        # ^^^^                keyword
-        #      ^^^            name
-        #          ^          eq
-        type loc = Location[:keyword | :name | :eq, bot]
+        # type loc[T] = Location[T, bot]
+        # ^^^^                            keyword
+        #      ^^^                        name
+        #         ^^^                     type_params
+        #             ^                      eq
+        #
+        type loc = Location[:keyword | :name | :eq, :type_params]
 
         attr_reader name: TypeName
+        attr_reader type_params: ModuleTypeParams
         attr_reader type: Types::t
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: ModuleTypeParams, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson

data/sig/definition_builder.rbs

@@ -43,8 +43,37 @@ module RBS
 
     def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
 
+    # Expand a type alias of given name without type arguments.
+    # Raises an error if the type alias requires arguments.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias("::foo")   # => error
+    # ```
+    #
     def expand_alias: (TypeName) -> Types::t
 
+    # Expand a type alias of given name with arguments of `untyped`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias1("::foo")   # => [untyped, untyped]
+    # ```
+    #
+    def expand_alias1: (TypeName) -> Types::t
+
+    # Expand a type alias of given name with `args`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
+    # ```
+    #
+    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
+
     def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
   end
 end

data/sig/environment_walker.rbs

@@ -1,4 +1,28 @@
 module RBS
+  # EnvironmentWalker provides topological sort of class/module definitions.
+  #
+  # If a method, attribute, or ancestor in a class definition have a reference to another class, it is dependency.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env)
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
+  # The `#only_ancestors!` method limits the dependency only to ancestors.
+  # Only super classes and included modules are dependencies with the option.
+  # This is useful to calculate the dependencies of class hierarchy.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env).only_ancestors!
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
   class EnvironmentWalker
     class InstanceNode
       attr_reader type_name: TypeName
@@ -32,6 +56,8 @@ module RBS
 
     def tsort_each_child: (node) { (node) -> void } -> void
 
+    private
+
     def each_type_name: (Types::t) { (TypeName) -> void } -> void
 
     def each_type_node: (Types::t) { (node) -> void } -> void

data/sig/errors.rbs

@@ -220,4 +220,14 @@ module RBS
 
     def name: () -> String
   end
+
+  class NonregularTypeAliasError < LoadingError
+    # Diagnostic reported from `TypeAliasRegularity`.
+    attr_reader diagnostic: TypeAliasRegularity::Diagnostic
+
+    # Location of the definition.
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (diagnostic: TypeAliasRegularity::Diagnostic, location: Location[untyped, untyped]?) -> void
+  end
 end

data/sig/type_alias_regularity.rbs

@@ -0,0 +1,92 @@
+module RBS
+  # `TypeAliasRegularity` validates if a type alias is regular or not.
+  #
+  # Generic and recursive type alias cannot be polymorphic in their definitions.
+  #
+  # ```rbs
+  # type foo[T] = Integer
+  #             | foo[T]?     # Allowed. The type argument of `foo` doesn't change.
+  #
+  # type bar[T] = Integer
+  #             | foo[T]
+  #             | foo[Array[T]]  # Allowed. There are two type arguments `T` and `Array[T]` of `foo`, but it's not definition of `foo`.
+  #
+  # type baz[T] = Integer
+  #             | baz[Array[T]]  # Error. Recursive definition of `baz` has different type argument from the definition.
+  # ```
+  #
+  # The `#nonregular?` method can be used to test if given type name is regular or not.
+  #
+  # ```rb
+  # validator = RBS::TypeAliasRegularity.validate(env: env)
+  #
+  # validator.nonregular?(TypeName("::foo"))    # => nil
+  # validator.nonregular?(TypeName("::bar"))    # => nil
+  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # ```
+  #
+  # A special case is when the type argument is `untyped`.
+  #
+  # ```rbs
+  # type foo[T] = Integer | foo[untyped]    # This is allowed.
+  # ```
+  #
+  class TypeAliasRegularity
+    attr_reader env: Environment
+
+    attr_reader builder: DefinitionBuilder
+
+    attr_reader diagnostics: Hash[TypeName, Diagnostic]
+
+    # `Diagnostic` represents an non-regular type alias declaration error.
+    # It consists of the name of the alias type and a type on which the nonregularity is detected.
+    #
+    # ```rbs
+    # type t[T] = Integer | t[T?]
+    # ```
+    #
+    # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
+    #
+    # ```
+    # diagnostic = validator.nonregular?(TypeName("::t"))
+    # diagnostic.type_name         # => TypeName("::t")
+    # diagnostic.nonregular_type   # => t[T?]
+    # ```
+    #
+    class Diagnostic
+      attr_reader type_name: TypeName
+
+      attr_reader nonregular_type: Types::Alias
+
+      def initialize: (type_name: TypeName, nonregular_type: Types::Alias) -> void
+    end
+
+    # Returns new instance which already run `#validate`.
+    #
+    def self.validate: (env: Environment) -> TypeAliasRegularity
+
+    def initialize: (env: Environment) -> void
+
+    # Returns `Diagnostic` instance if the alias type is nonregular.
+    # Regurns `nil` if the alias type is regular.
+    #
+    def nonregular?: (TypeName) -> Diagnostic?
+
+    def validate: () -> void
+
+    private
+
+    def validate_alias_type: (Types::Alias, Set[TypeName], Hash[TypeName, Types::Alias]) -> void
+
+    # Returns alias type for given type name, if the alias is generic.
+    # Returns nil if the type alias is not generic.
+    #
+    def build_alias_type: (TypeName) -> Types::Alias?
+
+    def compatible_args?: (Array[Types::t], Array[Types::t]) -> boolish
+
+    def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
+
+    def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
+  end
+end