steep 1.6.0 → 1.7.1

data/lib/steep/services/signature_help_provider.rb

@@ -7,18 +7,22 @@ module Steep
         # @implements Item
 
         def parameters
-          arguments = [] #: Array[String]
-          arguments.push(*method_type.type.required_positionals.map(&:to_s))
-          arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
-          arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
-          arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
-          arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
-          arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
-          arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
-          arguments
+          if method_type.type.is_a?(RBS::Types::Function)
+            arguments = [] #: Array[String]
+            arguments.push(*method_type.type.required_positionals.map(&:to_s))
+            arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+            arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+            arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+            arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+            arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+            arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+            arguments
+          end
         end
       end
 
+      include NodeHelper
+
       attr_reader :source, :path, :subtyping, :typing, :buffer
 
       def env
@@ -55,7 +59,7 @@ module Steep
               if begin_loc.end_pos <= pos && pos <= end_loc.begin_pos
                 # Given position is between open/close parens of args of send node
 
-                if parent && (parent.type == :block || parent.type == :numblock)
+                if parent && (parent.type == :block || parent.type == :numblock) && node.equal?(parent.children[0])
                   send_node = parent
                 else
                   send_node = node
@@ -76,7 +80,8 @@ module Steep
       end
 
       def last_argument_nodes_for(argument_nodes:, line:, column:)
-        return unless argument_nodes.last.children[2]  # No arguments
+        last = argument_nodes.last or raise
+        return unless last.children[2]  # No arguments
         return argument_nodes if argument_nodes.size > 1  # Cursor is on the last argument
 
         pos = buffer.loc_to_pos([line, column])
@@ -102,16 +107,11 @@ module Steep
         case call
         when MethodCall::Typed, MethodCall::Error
           type = call.receiver_type
-          if type.is_a?(AST::Types::Self)
-            type = context.self_type
-          end
+          config = Interface::Builder::Config.new(self_type: context.self_type, variable_bounds: context.variable_context.upper_bounds)
+
+          if shape = subtyping.builder.shape(type, config)
+            shape = shape.public_shape if private_send?(node)
 
-          shape = subtyping.builder.shape(
-            type,
-            public_only: !node.children[0].nil?,
-            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
-          )
-          if shape
             if method = shape.methods[call.method_name]
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
@@ -150,9 +150,9 @@ module Steep
             case last_argument_nodes[-3].type
             when :pair
               argname = last_argument_nodes[-3].children.first.children.first
-              if method_type.type.required_keywords[argname]
+              if method_type.type.required_keywords.key?(argname)
                 positionals + method_type.type.required_keywords.keys.index(argname).to_i + 1
-              elsif method_type.type.optional_keywords[argname]
+              elsif method_type.type.optional_keywords.key?(argname)
                 positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i + 1
               elsif method_type.type.rest_keywords
                 positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
@@ -161,7 +161,7 @@ module Steep
               positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
             end
           else
-            pos = node.children[2...].index { |c| c.location == last_argument_nodes[-2].location }.to_i
+            pos = (node.children[2...] || raise).index { |c| c.location == last_argument_nodes[-2].location }.to_i
             if method_type.type.rest_positionals
               [pos + 1, positionals - 1].min
             else
@@ -174,21 +174,23 @@ module Steep
           when :splat
             method_type.type.required_positionals.size + method_type.type.optional_positionals.size if method_type.type.rest_positionals
           when :kwargs
-            case argument_nodes[-3].type
-            when :pair
-              argname = argument_nodes[-3].children.first.children.first
-              if method_type.type.required_keywords[argname]
-                positionals + method_type.type.required_keywords.keys.index(argname).to_i
-              elsif method_type.type.optional_keywords[argname]
-                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
-              elsif method_type.type.rest_keywords
-                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+            if argument_nodes[-3]
+              case argument_nodes[-3].type
+              when :pair
+                argname = argument_nodes[-3].children.first.children.first
+                if method_type.type.required_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.keys.index(argname).to_i
+                elsif method_type.type.optional_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
+                elsif method_type.type.rest_keywords
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+                end
+              when :kwsplat
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
               end
-            when :kwsplat
-              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
             end
           else
-            pos = node.children[2...].index { |c| c.location == argument_nodes[-2].location }.to_i
+            pos = (node.children[2...] || raise).index { |c| c.location == argument_nodes[-2].location }.to_i
             [pos, positionals - 1].min
           end
         end

data/lib/steep/services/type_check_service.rb

@@ -13,25 +13,27 @@ module Steep
         attr_reader :node
         attr_reader :typing
         attr_reader :errors
+        attr_reader :ignores
 
-        def initialize(path:, node:, content:, typing:, errors:)
+        def initialize(path:, node:, content:, typing:, ignores:, errors:)
           @path = path
           @node = node
           @content = content
           @typing = typing
+          @ignores = ignores
           @errors = errors
         end
 
         def self.with_syntax_error(path:, content:, error:)
-          new(path: path, node: false, content: content, errors: [error], typing: nil)
+          new(path: path, node: false, content: content, errors: [error], typing: nil, ignores: nil)
         end
 
-        def self.with_typing(path:, content:, typing:, node:)
-          new(path: path, node: node, content: content, errors: nil, typing: typing)
+        def self.with_typing(path:, content:, typing:, node:, ignores:)
+          new(path: path, node: node, content: content, errors: nil, typing: typing, ignores: ignores)
         end
 
         def self.no_data(path:, content:)
-          new(path: path, content: content, node: false, errors: nil, typing: nil)
+          new(path: path, content: content, node: false, errors: nil, typing: nil, ignores: nil)
         end
 
         def update_content(content)
@@ -40,12 +42,37 @@ module Steep
             content: content,
             node: node,
             errors: errors,
-            typing: typing
+            typing: typing,
+            ignores: ignores
           )
         end
 
         def diagnostics
-          errors || typing&.errors || []
+          case
+          when errors
+            errors
+          when typing && ignores
+            errors = [] #: Array[Diagnostic::Ruby::Base]
+
+            errors.concat(
+              typing.errors.delete_if do |diagnostic|
+                case diagnostic.location
+                when ::Parser::Source::Range
+                  ignores.ignore?(diagnostic.location.first_line, diagnostic.location.last_line, diagnostic.diagnostic_code)
+                when RBS::Location
+                  ignores.ignore?(diagnostic.location.start_line, diagnostic.location.end_line, diagnostic.diagnostic_code)
+                end
+              end
+            )
+
+            ignores.error_ignores.each do |ignore|
+              errors << Diagnostic::Ruby::InvalidIgnoreComment.new(comment: ignore.comment)
+            end
+
+            errors
+          else
+            []
+          end
         end
       end
 
@@ -327,7 +354,8 @@ module Steep
         Steep.logger.tagged "#type_check_file(#{path}@#{target.name})" do
           source = Source.parse(text, path: path, factory: subtyping.factory)
           typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: yield)
-          SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing)
+          ignores = Source::IgnoreRanges.new(ignores: source.ignores)
+          SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing, ignores: ignores)
         end
       rescue AnnotationParser::SyntaxError => exn
         error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: exn.location)

data/lib/steep/signature/validator.rb

@@ -5,10 +5,23 @@ module Steep
       Declarations = RBS::AST::Declarations
 
       attr_reader :checker
+      attr_reader :context
 
       def initialize(checker:)
         @checker = checker
         @errors = []
+        @context = []
+      end
+
+      def push_context(self_type: latest_context[0], class_type: latest_context[1], instance_type: latest_context[2])
+        @context.push([self_type, class_type, instance_type])
+        yield
+      ensure
+        @context.pop
+      end
+
+      def latest_context
+        context.last || [nil, nil, nil]
       end
 
       def has_error?
@@ -72,11 +85,13 @@ module Steep
 
               constraints = Subtyping::Constraints.empty
 
+              self_type, class_type, instance_type = latest_context
+
               checker.check(
                 Subtyping::Relation.new(sub_type: arg_type, super_type: upper_bound_type),
-                self_type: AST::Types::Self.instance,
-                class_type: nil,
-                instance_type: nil,
+                self_type: self_type,
+                class_type: class_type,
+                instance_type: instance_type,
                 constraints: constraints
               ).else do |result|
                 @errors << Diagnostic::Signature::UnsatisfiableTypeApplication.new(
@@ -134,7 +149,7 @@ module Steep
       end
 
       def validate_type(type)
-        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+        Steep.logger.debug { "#{Location.to_string type.location}: Validating #{type}..." }
 
         validator.validate_type(type, context: nil)
         validate_type_application(type)
@@ -236,25 +251,113 @@ module Steep
         end
       end
 
-      def validate_one_class_decl(name)
+      def validate_one_class_decl(name, entry)
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
+          class_type = AST::Types::Name::Singleton.new(name: name, location: nil)
+          instance_type = AST::Types::Name::Instance.new(
+            name: name,
+            args: entry.type_params.map { AST::Types::Any.new(location: nil) },
+            location: nil
+          )
+
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
               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
+              self_type = AST::Types::Name::Instance.new(
+                name: name,
+                args: entry.type_params.map { AST::Types::Var.new(name: _1.name) },
+                location: nil
+              )
+
+              push_context(self_type: self_type, class_type: class_type, instance_type: instance_type) do
+                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 || raise, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                    checker.check(
+                      relation,
+                      self_type: AST::Types::Self.instance,
+                      instance_type: AST::Types::Instance.instance,
+                      class_type: AST::Types::Class.instance,
+                      constraints: Subtyping::Constraints.empty
+                    ).else do
+                      raise if ancestor.source.is_a?(Symbol)
+
+                      @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
+                        name: name,
+                        location: ancestor.source&.location || raise,
+                        ancestor: ancestor,
+                        relation: relation
+                      )
+                    end
+                  end
+
+                  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
+
+            builder.build_singleton(name).tap do |definition|
+              entry =
+                case definition.entry
+                when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+                  definition.entry
+                else
+                  raise
+                end
+
+              push_context(self_type: class_type, class_type: class_type, instance_type: instance_type) 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)
+                    result1 = checker.check(
+                      relation,
+                      self_type: AST::Types::Self.instance,
+                      instance_type: AST::Types::Instance.instance,
+                      class_type: AST::Types::Class.instance,
+                      constraints: Subtyping::Constraints.empty
+                    )
+                    result2 = checker.check(
+                      relation.flip,
+                      self_type: AST::Types::Self.instance,
+                      instance_type: AST::Types::Instance.instance,
+                      class_type: AST::Types::Class.instance,
+                      constraints: Subtyping::Constraints.empty
+                    )
 
                     unless result1.success? and result2.success?
                       @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
@@ -267,11 +370,32 @@ module Steep
                   end
                 end
 
-                ancestors = builder.ancestor_builder.one_instance_ancestors(name)
-                mixin_constraints(definition, ancestors.included_modules || raise, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                definition.class_variables.each do |name, var|
+                  if var.declared_in == definition.type_name
+                    if (parent = var.parent_variable) && var.declared_in != parent.declared_in
+                      class_var = entry.decls.flat_map {|decl| decl.decl.members }.find do |member|
+                        member.is_a?(RBS::AST::Members::ClassVariable) && member.name == name
+                      end
+
+                      if class_var
+                        loc = class_var.location #: RBS::Location[untyped, untyped]?
+                        @errors << Diagnostic::Signature::ClassVariableDuplicationError.new(
+                          class_name: definition.type_name,
+                          other_class_name: parent.declared_in,
+                          variable_name: name,
+                          location: loc&.[](:name) || raise
+                        )
+                      end
+                    end
+                  end
+                end
+
+                ancestors = builder.ancestor_builder.one_singleton_ancestors(name)
+                ancestors.extended_modules or raise
+                mixin_constraints(definition, ancestors.extended_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
                   checker.check(
                     relation,
-                    self_type: AST::Types::Self.instance,
+                    self_type: AST::Types::Self.instance ,
                     instance_type: AST::Types::Instance.instance,
                     class_type: AST::Types::Class.instance,
                     constraints: Subtyping::Constraints.empty
@@ -286,7 +410,6 @@ module Steep
                     )
                   end
                 end
-
                 ancestors.each_ancestor do |ancestor|
                   case ancestor
                   when RBS::Definition::Ancestor::Instance
@@ -297,97 +420,6 @@ module Steep
                 validate_definition_type(definition)
               end
             end
-
-            builder.build_singleton(name).tap do |definition|
-              entry =
-                case definition.entry
-                when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-                  definition.entry
-                else
-                  raise
-                end
-
-              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: AST::Types::Self.instance,
-                    instance_type: AST::Types::Instance.instance,
-                    class_type: AST::Types::Class.instance,
-                    constraints: Subtyping::Constraints.empty
-                  )
-                  result2 = checker.check(
-                    relation.flip,
-                    self_type: AST::Types::Self.instance,
-                    instance_type: AST::Types::Instance.instance,
-                    class_type: AST::Types::Class.instance,
-                    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
-
-              definition.class_variables.each do |name, var|
-                if var.declared_in == definition.type_name
-                  if (parent = var.parent_variable) && var.declared_in != parent.declared_in
-                    class_var = entry.decls.flat_map {|decl| decl.decl.members }.find do |member|
-                      member.is_a?(RBS::AST::Members::ClassVariable) && member.name == name
-                    end
-
-                    if class_var
-                      loc = class_var.location #: RBS::Location[untyped, untyped]?
-                      @errors << Diagnostic::Signature::ClassVariableDuplicationError.new(
-                        class_name: definition.type_name,
-                        other_class_name: parent.declared_in,
-                        variable_name: name,
-                        location: loc&.[](:name) || raise
-                      )
-                    end
-                  end
-                end
-              end
-
-              ancestors = builder.ancestor_builder.one_singleton_ancestors(name)
-              ancestors.extended_modules or raise
-              mixin_constraints(definition, ancestors.extended_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
-                checker.check(
-                  relation,
-                  self_type: AST::Types::Self.instance ,
-                  instance_type: AST::Types::Instance.instance,
-                  class_type: AST::Types::Class.instance,
-                  constraints: Subtyping::Constraints.empty
-                ).else do
-                  raise if ancestor.source.is_a?(Symbol)
-
-                  @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
-                    name: name,
-                    location: ancestor.source&.location || raise,
-                    ancestor: ancestor,
-                    relation: relation
-                  )
-                end
-              end
-              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
@@ -397,7 +429,7 @@ module Steep
 
         case entry
         when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-          validate_one_class_decl(name)
+          validate_one_class_decl(name, entry)
         when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
           validate_one_class_alias(name, entry)
         end
@@ -453,23 +485,31 @@ module Steep
               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
-                  ancestor.source.is_a?(Symbol) and raise
-
-                  defn = builder.build_interface(ancestor.name)
-                  validate_type_application_constraints(
-                    ancestor.name,
-                    defn.type_params_decl,
-                    ancestor.args,
-                    location: ancestor.source&.location || raise
-                  )
+            self_type = AST::Types::Name::Interface.new(
+              name: name,
+              args: definition.type_params.map { AST::Types::Var.new(name: _1) },
+              location: nil
+            )
+
+            push_context(self_type: self_type, class_type: nil, instance_type: nil) do
+              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
+                    ancestor.source.is_a?(Symbol) and raise
+
+                    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
@@ -519,21 +559,33 @@ module Steep
       end
 
       def validate_one_alias(name, entry = env.type_alias_decls[name])
-        rescue_validation_errors(name) do
-          Steep.logger.debug "Validating alias `#{name}`..."
+        *, inner_most_outer_module = entry.outer
+        if inner_most_outer_module
+          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name, location: nil)
+          instance_type = AST::Types::Name::Instance.new(
+            name: inner_most_outer_module.name,
+            args: inner_most_outer_module.type_params.map { AST::Types::Any.new(location: nil) },
+            location: nil
+          )
+        end
 
-          unless name.namespace.empty?
-            outer = name.namespace.to_type_name
-            builder.validate_type_name(outer, entry.decl.location&.aref(:name))
-          end
+        push_context(class_type: class_type, instance_type: instance_type, self_type: nil) do
+          rescue_validation_errors(name) do
+            Steep.logger.debug "Validating alias `#{name}`..."
 
-          upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
-            bounds[param.name] = factory.type_opt(param.upper_bound)
-          end
+            unless name.namespace.empty?
+              outer = name.namespace.to_type_name
+              builder.validate_type_name(outer, entry.decl.location&.aref(:name))
+            end
+
+            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)
+            validator.validate_type_alias(entry: entry) do |type|
+              checker.push_variable_bounds(upper_bounds) do
+                validate_type(entry.decl.type)
+              end
             end
           end
         end