steep 0.47.1 → 0.48.0

data/lib/steep/interface/method_type.rb

@@ -77,7 +77,7 @@ module Steep
       end
 
       def to_s
-        type_params = !self.type_params.empty? ? "[#{self.type_params.map{|x| "#{x}" }.join(", ")}] " : ""
+        type_params = !self.type_params.empty? ? "[#{self.type_params.join(", ")}] " : ""
         params = type.params.to_s
         return_type = type.return_type
         block = self.block ? " #{self.block}" : ""
@@ -95,11 +95,9 @@ module Steep
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
       #
       def unify_overload(other)
-        type_params = []
-        s1 = Substitution.build(self.type_params)
-        type_params.push(*s1.dictionary.values.map(&:name))
-        s2 = Substitution.build(other.type_params)
-        type_params.push(*s2.dictionary.values.map(&:name))
+        type_params_1, s1 = TypeParam.rename(self.type_params)
+        type_params_2, s2 = TypeParam.rename(other.type_params)
+        type_params = type_params_1 + type_params_2
 
         block = case
                 when self.block && other.block
@@ -134,17 +132,12 @@ module Steep
       # Returns nil if self and other are incompatible.
       #
       def |(other)
-        self_type_params = Set.new(self.type_params)
-        other_type_params = Set.new(other.type_params)
-
-        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
-          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
-          fresh_names = fresh_types.map(&:name)
-          subst = Substitution.build(common_type_params, fresh_types)
-          other = other.instantiate(subst)
-          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        if other.type_params.empty?
+          type_params = self.type_params
         else
-          type_params = (self_type_params + other_type_params).to_a
+          other_params, s2 = TypeParam.rename(other.type_params)
+          other = other.instantiate(s2)
+          type_params = self.type_params + other_params
         end
 
         params = self.type.params & other.type.params or return
@@ -182,17 +175,12 @@ module Steep
       # Returns nil if self and other are incompatible.
       #
       def &(other)
-        self_type_params = Set.new(self.type_params)
-        other_type_params = Set.new(other.type_params)
-
-        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
-          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
-          fresh_names = fresh_types.map(&:name)
-          subst = Substitution.build(common_type_params, fresh_types)
-          other = other.subst(subst)
-          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        if other.type_params.empty?
+          type_params = self.type_params
         else
-          type_params = (self_type_params + other_type_params).to_a
+          other_params, s2 = TypeParam.rename(other.type_params)
+          other = other.instantiate(s2)
+          type_params = self.type_params + other_params
         end
 
         params = self.type.params | other.type.params

data/lib/steep/interface/type_param.rb

@@ -0,0 +1,103 @@
+module Steep
+  module Interface
+    class TypeParam
+      attr_reader :name
+      attr_reader :upper_bound
+      attr_reader :variance
+      attr_reader :unchecked
+      attr_reader :location
+
+      def initialize(name:, upper_bound:, variance:, unchecked:, location: nil)
+        @name = name
+        @upper_bound = upper_bound
+        @variance = variance
+        @unchecked = unchecked
+        @location = location
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.upper_bound == upper_bound &&
+          other.variance == variance &&
+          other.unchecked == unchecked
+      end
+
+      alias eql? ==
+
+      def hash
+        name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash
+      end
+
+      def self.rename(params, conflicting_names = params.map(&:name))
+        unless conflicting_names.empty?
+          new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) }
+          hash = conflicting_names.zip(new_names).to_h
+          new_types = new_names.map {|n| AST::Types::Var.new(name: n) }
+
+          subst = Substitution.build(conflicting_names, new_types)
+
+          [
+            params.map do |param|
+              if hash.key?(param.name) || param.upper_bound
+                TypeParam.new(
+                  name: hash[param.name] || param.name,
+                  upper_bound: param.upper_bound&.subst(subst),
+                  variance: param.variance,
+                  unchecked: param.unchecked,
+                  location: param.location
+                )
+              else
+                param
+              end
+            end,
+            subst
+          ]
+        else
+          [params, Substitution.empty]
+        end
+      end
+
+      def to_s
+        buf = ""
+
+        if unchecked
+          buf << "unchecked "
+        end
+
+        case variance
+        when :covariant
+          buf << "out "
+        when :contravariant
+          buf << "in "
+        end
+
+        buf << name.to_s
+
+        if upper_bound
+          buf << " < #{upper_bound}"
+        end
+
+        buf
+      end
+
+      def update(name: self.name, upper_bound: self.upper_bound, variance: self.variance, unchecked: self.unchecked, location: self.location)
+        TypeParam.new(
+          name: name,
+          upper_bound: upper_bound,
+          variance: variance,
+          unchecked: unchecked,
+          location: location
+        )
+      end
+
+      def subst(s)
+        if u = upper_bound
+          update(upper_bound: u.subst(s))
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/base_worker.rb

@@ -14,6 +14,7 @@ module Steep
         @writer = writer
         @skip_job = false
         @shutdown = false
+        @skip_jobs_after_shutdown = nil
       end
 
       def skip_jobs_after_shutdown!(flag = true)

data/lib/steep/server/interaction_worker.rb

@@ -338,7 +338,7 @@ HOVER
         else
           ps = params.each.map do |param|
             s = ""
-            if param.skip_validation
+            if param.unchecked?
               s << "unchecked "
             end
             case param.variance

data/lib/steep/server/type_check_worker.rb

@@ -144,7 +144,7 @@ module Steep
           if job.guid == current_type_check_guid
             Steep.logger.info { "Processing ValidateAppSignature for guid=#{job.guid}, path=#{job.path}" }
             service.validate_signature(path: project.relative_path(job.path)) do |path, diagnostics|
-              formatter = Diagnostic::LSPFormatter.new({})
+              formatter = Diagnostic::LSPFormatter.new({}, **{})
 
               writer.write(
                 method: :"textDocument/publishDiagnostics",
@@ -162,7 +162,7 @@ module Steep
           if job.guid == current_type_check_guid
             Steep.logger.info { "Processing ValidateLibrarySignature for guid=#{job.guid}, path=#{job.path}" }
             service.validate_signature(path: job.path) do |path, diagnostics|
-              formatter = Diagnostic::LSPFormatter.new({})
+              formatter = Diagnostic::LSPFormatter.new({}, **{})
 
               writer.write(
                 method: :"textDocument/publishDiagnostics",

data/lib/steep/services/signature_service.rb

@@ -224,7 +224,7 @@ module Steep
           Steep.measure "Loading new decls" do
             updated_files.each_value do |content|
               case decls = content.decls
-              when RBS::ErrorBase
+              when RBS::BaseError
                 errors << content.decls
               else
                 begin
@@ -283,7 +283,7 @@ module Steep
       def rescue_rbs_error(errors)
         begin
           yield
-        rescue RBS::ErrorBase => exn
+        rescue RBS::BaseError => exn
           errors << exn
         end
       end

data/lib/steep/services/type_check_service.rb

@@ -366,7 +366,8 @@ module Steep
           self_type: AST::Builtin::Object.instance_type,
           type_env: type_env,
           lvar_env: lvar_env,
-          call_context: TypeInference::MethodCall::TopLevelContext.new
+          call_context: TypeInference::MethodCall::TopLevelContext.new,
+          variable_context: TypeInference::Context::TypeVariableContext.empty
         )
 
         typing = Typing.new(source: source, root_context: context)

data/lib/steep/signature/validator.rb

@@ -56,9 +56,73 @@ module Steep
         validate_alias
       end
 
+      def validate_type_application_constraints(type_name, type_params, type_args, location:)
+        if type_params.size == type_args.size
+          type_params.zip(type_args).each do |param, arg|
+            if param.upper_bound
+              upper_bound_type = factory.type(param.upper_bound)
+              arg_type = factory.type(arg)
+
+              constraints = Subtyping::Constraints.empty
+
+              checker.check(
+                Subtyping::Relation.new(sub_type: arg_type, super_type: upper_bound_type),
+                self_type: nil,
+                class_type: nil,
+                instance_type: nil,
+                constraints: constraints
+              ).else do |result|
+                @errors << Diagnostic::Signature::UnsatisfiableTypeApplication.new(
+                  type_name: type_name,
+                  type_arg: arg_type,
+                  type_param: Interface::TypeParam.new(
+                    name: param.name,
+                    upper_bound: upper_bound_type,
+                    variance: param.variance,
+                    unchecked: param.unchecked?
+                  ),
+                  location: location
+                )
+              end
+            end
+          end
+        end
+      end
+
       def validate_type(type)
         Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+
         validator.validate_type type, context: [RBS::Namespace.root]
+
+        name, type_params, type_args =
+          case type
+          when RBS::Types::ClassInstance
+            [
+              type.name,
+              builder.build_instance(type.name).type_params_decl,
+              type.args
+            ]
+          when RBS::Types::Interface
+            [
+              type.name,
+              builder.build_interface(type.name).type_params_decl,
+              type.args
+            ]
+          when RBS::Types::Alias
+            entry = env.alias_decls[type.name]
+
+            [
+              type.name,
+              entry.decl.type_params,
+              type.args
+            ]
+          end
+
+        if name && type_params && type_args
+          if !type_params.empty? && !type_args.empty?
+            validate_type_application_constraints(type.name, type_params, type_args, location: type.location)
+          end
+        end
       end
 
       def ancestor_to_type(ancestor)
@@ -109,64 +173,109 @@ module Steep
         relations
       end
 
+      def each_method_type(definition)
+        type_name = definition.type_name
+
+        definition.methods.each_value do |method|
+          if method.defined_in == type_name
+            method.method_types.each do |method_type|
+              yield method_type
+            end
+          end
+        end
+      end
+
+      def each_variable_type(definition)
+        type_name = definition.type_name
+
+        definition.instance_variables.each_value do |var|
+          if var.declared_in == type_name
+            yield var.type
+          end
+        end
+
+        definition.class_variables.each_value do |var|
+          if var.declared_in == type_name
+            yield var.type
+          end
+        end
+      end
+
+      def validate_definition_type(definition)
+        each_method_type(definition) do |method_type|
+          upper_bounds = method_type.type_params.each.with_object({}) do |param, hash|
+            hash[param.name] = factory.type_opt(param.upper_bound)
+          end
+
+          checker.push_variable_bounds(upper_bounds) do
+            method_type.each_type do |type|
+              validate_type(type)
+            end
+          end
+        end
+
+        each_variable_type(definition) do |type|
+          validate_type(type)
+        end
+      end
+
       def validate_one_class(name)
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
-              definition.instance_variables.each do |name, var|
-                if parent = var.parent_variable
-                  var_type = checker.factory.type(var.type)
-                  parent_type = checker.factory.type(parent.type)
+              upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
+                bounds[param.name] = factory.type_opt(param.upper_bound)
+              end
 
-                  relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
-                  result1 = checker.check(
+              checker.push_variable_bounds(upper_bounds) do
+                definition.instance_variables.each do |name, var|
+                  if parent = var.parent_variable
+                    var_type = checker.factory.type(var.type)
+                    parent_type = checker.factory.type(parent.type)
+
+                    relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
+                    result1 = checker.check(relation, self_type: nil, instance_type: nil, class_type: nil, constraints: Subtyping::Constraints.empty)
+                    result2 = checker.check(relation.flip, self_type: nil, instance_type: nil, class_type: nil, constraints: Subtyping::Constraints.empty)
+
+                    unless result1.success? and result2.success?
+                      @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                        name: name,
+                        location: var.type.location,
+                        var_type: var_type,
+                        parent_type: parent_type
+                      )
+                    end
+                  end
+                end
+
+                ancestors = builder.ancestor_builder.one_instance_ancestors(name)
+                mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                  checker.check(
                     relation,
                     self_type: AST::Types::Self.new,
                     instance_type: AST::Types::Instance.new,
                     class_type: AST::Types::Class.new,
                     constraints: Subtyping::Constraints.empty
-                  )
-                  result2 = checker.check(
-                    relation.flip,
-                    self_type: AST::Types::Self.new,
-                    instance_type: AST::Types::Instance.new,
-                    class_type: AST::Types::Class.new,
-                    constraints: Subtyping::Constraints.empty
-                  )
-
-                  unless result1.success? and result2.success?
-                    @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                  ).else do
+                    @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
                       name: name,
-                      location: var.type.location,
-                      var_type: var_type,
-                      parent_type: parent_type
+                      location: ancestor.source&.location || raise,
+                      ancestor: ancestor,
+                      relation: relation
                     )
                   end
                 end
-              end
 
-              ancestors = builder.ancestor_builder.one_instance_ancestors(name)
-              mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
-                checker.check(
-                  relation,
-                  self_type: AST::Types::Self.new,
-                  instance_type: AST::Types::Instance.new,
-                  class_type: AST::Types::Class.new,
-                  constraints: Subtyping::Constraints.empty
-                ).else do
-                  @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
-                    name: name,
-                    location: ancestor.source&.location || raise,
-                    ancestor: ancestor,
-                    relation: relation
-                  )
+                ancestors.each_ancestor do |ancestor|
+                  case ancestor
+                  when RBS::Definition::Ancestor::Instance
+                    validate_ancestor_application(name, ancestor)
+                  end
                 end
-              end
 
-              definition.each_type do |type|
-                validate_type type
+                validate_definition_type(definition)
               end
             end
 
@@ -220,21 +329,78 @@ module Steep
                   )
                 end
               end
-
-              definition.each_type do |type|
-                validate_type type
+              ancestors.each_ancestor do |ancestor|
+                case ancestor
+                when RBS::Definition::Ancestor::Instance
+                  validate_ancestor_application(name, ancestor)
+                end
               end
+
+              validate_definition_type(definition)
             end
           end
         end
       end
 
+      def validate_ancestor_application(name, ancestor)
+        unless ancestor.args.empty?
+          definition =
+            case
+            when ancestor.name.class?
+              builder.build_instance(ancestor.name)
+            when ancestor.name.interface?
+              builder.build_interface(ancestor.name)
+            end
+
+          location =
+            if ancestor.source == :super
+              primary_decl = env.class_decls[name].primary.decl
+              if super_class = primary_decl.super_class
+                super_class.location
+              else
+                # Implicit super class (Object): this can be skipped in fact...
+                primary_decl.location[:name]
+              end
+            else
+              ancestor.source.location
+            end
+
+          validate_type_application_constraints(
+            ancestor.name,
+            definition.type_params_decl,
+            ancestor.args,
+            location: location
+          )
+        end
+      end
+
       def validate_one_interface(name)
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating interface `#{name}`..."
           Steep.logger.tagged "#{name}" do
-            builder.build_interface(name).each_type do |type|
-              validate_type type
+            definition = builder.build_interface(name)
+
+            upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
+              bounds[param.name] = factory.type_opt(param.upper_bound)
+            end
+
+            checker.push_variable_bounds(upper_bounds) do
+              validate_definition_type(definition)
+
+              ancestors = builder.ancestor_builder.one_interface_ancestors(name)
+              ancestors.each_ancestor do |ancestor|
+                case ancestor
+                when RBS::Definition::Ancestor::Instance
+                  # Interface ancestor cannot be other than Interface
+                  defn = builder.build_interface(ancestor.name)
+                  validate_type_application_constraints(
+                    ancestor.name,
+                    defn.type_params_decl,
+                    ancestor.args,
+                    location: ancestor.source.location || raise
+                  )
+                end
+              end
             end
           end
         end
@@ -277,24 +443,30 @@ module Steep
         end
       end
 
-      def validate_one_alias(name)
+      def validate_one_alias(name, entry = env.alias_decls[name])
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating alias `#{name}`..."
-          builder.expand_alias(name).tap do |type|
-            validate_type(type)
+          upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
+            bounds[param.name] = factory.type_opt(param.upper_bound)
+          end
+
+          validator.validate_type_alias(entry: entry) do |type|
+            checker.push_variable_bounds(upper_bounds) do
+              validate_type(entry.decl.type)
+            end
           end
         end
       end
 
       def validate_alias
         env.alias_decls.each do |name, entry|
-          validate_one_alias(name)
+          validate_one_alias(name, entry)
         end
       end
 
       def rescue_validation_errors(type_name = nil)
         yield
-      rescue RBS::ErrorBase => exn
+      rescue RBS::BaseError => exn
         @errors << Diagnostic::Signature.from_rbs_error(exn, factory: factory)
       end
     end

data/lib/steep/subtyping/cache.rb

@@ -0,0 +1,30 @@
+module Steep
+  module Subtyping
+    class Cache
+      attr_reader :subtypes
+
+      def initialize
+        @subtypes = {}
+      end
+
+      def subtype(relation, self_type, instance_type, class_type, bounds)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key]
+      end
+
+      def [](relation, self_type, instance_type, class_type, bounds)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key]
+      end
+
+      def []=(relation, self_type, instance_type, class_type, bounds, value)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key] = value
+      end
+
+      def no_subtype_cache?
+        @subtypes.empty?
+      end
+    end
+  end
+end