rbs 1.7.0 → 2.0.0.pre1

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,25 +19,25 @@ 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)
           end
         end
 
+        definition_builder.validate_type_name(type.name, type.location)
+
         type_params = case type
                       when Types::ClassInstance
-                        env.class_decls[type.name]&.type_params
+                        env.class_decls[type.name].type_params
                       when Types::Interface
-                        env.interface_decls[type.name]&.decl&.type_params
+                        env.interface_decls[type.name].decl.type_params
+                      when Types::Alias
+                        env.alias_decls[type.name].decl.type_params
                       end
 
-        unless type_params
-          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
-        end
-
         InvalidTypeApplicationError.check!(
           type_name: type.name,
           args: type.args,
@@ -43,10 +45,8 @@ module RBS
           location: type.location
         )
 
-      when Types::Alias, Types::ClassSingleton
-        # @type var type: Types::Alias | Types::ClassSingleton
-        type = _ = absolute_type(type, context: context) { type.name.absolute! }
-        NoTypeFoundError.check!(type.name, env: env, location: type.location)
+      when Types::ClassSingleton
+        definition_builder.validate_type_presence(type)
       end
 
       type.each_type do |type|
@@ -55,11 +55,95 @@ 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.find {|param| param.name == param_name } or raise
+            raise InvalidVarianceAnnotationError.new(
+              type_name: type_name,
+              param: param,
+              location: entry.decl.type.location
+            )
+          end
+        end
+
+        validate_type_params(
+          entry.decl.type_params,
+          type_name: type_name,
+          location: entry.decl.location&.aref(:type_params)
+        )
+      end
+    end
+
+    def validate_method_definition(method_def, type_name:)
+      method_def.types.each do |method_type|
+        unless method_type.type_params.empty?
+          loc = method_type.location&.aref(:type_params)
+
+          validate_type_params(
+            method_type.type_params,
+            type_name: type_name,
+            method_name: method_def.name,
+            location: loc
+          )
+        end
+      end
+    end
+
+    def validate_type_params(params, type_name: , method_name: nil, location:)
+      # @type var each_node: TSort::_EachNode[Symbol]
+      each_node = __skip__ = -> (&block) do
+        params.each do |param|
+          block[param.name]
+        end
+      end
+      # @type var each_child: TSort::_EachChild[Symbol]
+      each_child = __skip__ = -> (name, &block) do
+        if param = params.find {|p| p.name == name }
+          if b = param.upper_bound
+            b.free_variables.each do |tv|
+              block[tv]
+            end
+          end
+        end
+      end
+
+      TSort.each_strongly_connected_component(each_node, each_child) do |names|
+        if names.size > 1
+          params = names.map do |name|
+            params.find {|param| param.name == name} or raise
+          end
+
+          raise CyclicTypeParameterBound.new(
+            type_name: type_name,
+            method_name: method_name,
+            params: params,
+            location: location
+          )
+        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,36 +136,49 @@ 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|
-          var = type_params.params[i]
-          case var&.variance
-          when :invariant
-            type(ty, result: result, context: :invariant)
-          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)
+          if var = type_params[i]
+            case var.variance
+            when :invariant
+              type(ty, result: result, context: :invariant)
+            when :covariant
+              type(ty, result: result, context: context)
+            when :contravariant
+              type(ty, result: result, context: negate(context))
+            end
           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.0"
+  VERSION = "2.0.0.pre1"
 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
@@ -146,19 +146,7 @@ module RBS
         "#{name}"
       else
         ps = params.each.map do |param|
-          s = ""
-          if param.skip_validation
-            s << "unchecked "
-          end
-          case param.variance
-          when :invariant
-            # nop
-          when :covariant
-            s << "out "
-          when :contravariant
-            s << "in "
-          end
-          s + param.name.to_s
+          param.to_s
         end
 
         "#{name}[#{ps.join(", ")}]"

data/lib/rbs.rb

@@ -16,6 +16,7 @@ require "rbs/namespace"
 require "rbs/type_name"
 require "rbs/types"
 require "rbs/method_type"
+require "rbs/ast/type_param"
 require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"
@@ -45,6 +46,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,12 @@
         "name": {
           "type": "string"
         },
+        "type_params": {
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
+        },
         "type": {
           "$ref": "types.json"
         },
@@ -28,7 +34,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`, ...",
@@ -76,21 +82,6 @@
       },
       "required": ["declaration", "name", "type", "comment", "location"]
     },
-    "moduleTypeParam": {
-      "type": "object",
-      "properties": {
-        "name": {
-          "type": "string"
-        },
-        "variance": {
-          "enum": ["covariant", "contravariant", "invariant"]
-        },
-        "skip_validation": {
-          "type": "boolean"
-        }
-      },
-      "required": ["name", "variance", "skip_validation"]
-    },
     "classMember": {
       "oneOf": [
         {
@@ -145,16 +136,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",
@@ -209,16 +194,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",
@@ -297,16 +276,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",

data/schema/methodType.json

@@ -20,7 +20,7 @@
     "type_params": {
       "type": "array",
       "items": {
-        "type": "string"
+        "$ref": "typeParam.json"
       }
     },
     "type": {

data/schema/typeParam.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Type param: `A`, `unchecked out A`, ...",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "variance": {
+      "enum": ["covariant", "contravariant", "invariant"]
+    },
+    "unchecked": {
+      "type": "boolean"
+    },
+    "upper_bound": {
+      "oneOf": [
+        {
+          "$ref": "types.json#definitions/classInstance"
+        },
+        {
+          "$ref": "types.json#definitions/classSingleton"
+        },
+        {
+          "$ref": "types.json#definitions/interface"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "location": {
+      "$ref": "location.json"
+    }
+  },
+  "required": ["name", "variance", "unchecked", "upper_bound", "location"]
+}

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/collection/collections.rbs

@@ -8,11 +8,15 @@ module RBS
         def versions: (Config::gem_entry) -> Array[String]
         def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
       end
 
       type source_entry = Git::source_entry
                             | Stdlib::source_entry
                             | Rubygems::source_entry
+      type manifest_entry = {
+        "dependencies" => Array[{"name" => String}]?,
+      }
 
       class Git
         METADATA_FILENAME: String
@@ -42,10 +46,14 @@ module RBS
 
         def to_lockfile: () -> source_entry
 
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
         private
 
         def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
 
+        def cp_r: (Pathname, Pathname) -> void
+
         def setup!: (revision: String) -> void
 
         def need_to_fetch?: (String revision ) -> bool
@@ -60,9 +68,9 @@ module RBS
 
         def resolve_revision: () -> String
 
-        def git: (*String cmd) -> String
+        def git: (*String cmd, **untyped opt) -> String
 
-        def sh!: (*String cmd) -> String
+        def sh!: (*String cmd, **untyped opt) -> String
 
         def format_config_entry: (Config::gem_entry) -> String
       end
@@ -84,6 +92,8 @@ module RBS
 
         def to_lockfile: () -> source_entry
 
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
         private
 
         def gem_dir: (Config::gem_entry) -> Pathname
@@ -102,6 +112,7 @@ module RBS
         def versions: (Config::gem_entry) -> Array[String]
         def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
 
         private
 

data/sig/collection/config.rbs

@@ -16,7 +16,7 @@ module RBS
 
         private
 
-        def assign_gem: (gem_name: String, version: String?) -> void
+        def assign_gem: (name: String, version: String?) -> void
 
         def upsert_gem: (gem_entry? old, gem_entry new) -> void
 
@@ -24,7 +24,7 @@ module RBS
 
         def remove_ignored_gems!: () -> void
 
-        def find_source: (gem_name: String) -> untyped
+        def find_source: (name: String) -> untyped
 
         def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
       end