steep 1.6.0 → 1.7.0.dev.2

data/lib/steep/services/completion_provider.rb

@@ -157,6 +157,9 @@ module Steep
         end
       end
 
+      class TextItem < Struct.new(:text, :help_text, :range, :label, keyword_init: true)
+      end
+
       attr_reader :source_text
       attr_reader :path
       attr_reader :subtyping
@@ -205,7 +208,7 @@ module Steep
             end
           end
 
-          if at_comment?(position)
+          if comment = at_comment?(position)
             node, *parents = source.find_nodes(line: position.line, column: position.column)
 
             case
@@ -232,9 +235,41 @@ module Steep
               if annotation
                 annotation.location or raise
                 return items_for_rbs(position: position, buffer: annotation.location.buffer)
-              else
-                return []
               end
+
+              comment_content = comment.text[1..] || ""
+              comment_content.strip!
+
+              range = Range.new(
+                start: Position.new(line: line, column: column),
+                end: Position.new(line: line, column: column)
+              )
+
+              items = [
+                TextItem.new(label: "steep:ignore:start", text: "steep:ignore:start", help_text: "Open ignore block", range: range),
+                TextItem.new(label: "steep:ignore:end", text: "steep:ignore:end", help_text: "Close ignore block", range: range),
+                TextItem.new(label: "steep:ignore", text: "steep:ignore ${1:optional diagnostics}", help_text: "Ignore line", range: range),
+                TextItem.new(label: "@type var x: T", text: "@type var ${1:variable}: ${2:var type}", help_text: "Type of local variable", range: range),
+                TextItem.new(label: "@type self: T", text: "@type self: ${1:self type}", help_text: "Type of `self`", range: range),
+                TextItem.new(label: "@type block: T", text: "@type block: ${1:block type}", help_text: "Type of `block`", range: range),
+                TextItem.new(label: "@type break: T", text: "@type break: ${1:break type}", help_text: "Type of `block`", range: range),
+              ]
+
+              items = items.filter_map do |item|
+                if item.text.start_with?(comment_content)
+                  TextItem.new(
+                    label: item.label,
+                    text: item.text,
+                    help_text: item.help_text,
+                    range: Range.new(
+                      start: Position.new(line: item.range.start.line, column: item.range.start.column - comment_content.size),
+                      end: item.range.end
+                    )
+                  )
+                end
+              end
+
+              return items
             end
           end
 
@@ -294,11 +329,7 @@ module Steep
       end
 
       def at_comment?(position)
-        if source.find_comment(line: position.line, column: position.column)
-          true
-        else
-          false
-        end
+        source.find_comment(line: position.line, column: position.column)
       end
 
       def range_for(position, prefix: "")

data/lib/steep/services/file_loader.rb

@@ -15,8 +15,9 @@ module Steep
             absolute_path = base_dir + path
 
             if absolute_path.file?
-              if pattern =~ path
-                yield absolute_path.relative_path_from(base_dir)
+              relative_path = absolute_path.relative_path_from(base_dir)
+              if pattern =~ relative_path
+                yield relative_path
               end
             else
               files = if absolute_path.directory?

data/lib/steep/services/signature_help_provider.rb

@@ -55,7 +55,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 +76,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])
@@ -150,9 +151,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 +162,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 +175,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/source/ignore_ranges.rb

@@ -0,0 +1,69 @@
+module Steep
+  class Source
+    class IgnoreRanges
+      attr_reader :all_ignores, :error_ignores, :ignored_ranges, :ignored_lines
+
+      def initialize(ignores:)
+        @all_ignores = ignores.sort_by(&:line)
+        @error_ignores = []
+
+        @ignored_lines = {}
+        @ignored_ranges = []
+
+        last_start = nil #: AST::Ignore::IgnoreStart?
+
+        all_ignores.each do |ignore|
+          case ignore
+          when AST::Ignore::IgnoreStart
+            if last_start
+              error_ignores << last_start
+            end
+            last_start = ignore
+          when AST::Ignore::IgnoreEnd
+            if last_start
+              ignored_ranges << (last_start.line..ignore.line)
+              last_start = nil
+            else
+              error_ignores << ignore
+            end
+          when AST::Ignore::IgnoreLine
+            if last_start
+              error_ignores << ignore
+            else
+              ignored_lines[ignore.line] = ignore
+            end
+          end
+        end
+
+        if last_start
+          error_ignores << last_start
+        end
+      end
+
+      def ignore?(start_line, end_line, code)
+        if ignore = ignored_lines.fetch(start_line, nil)
+          ignore_code?(ignore, code) and return true
+        end
+
+        if start_line != end_line
+          if ignore = ignored_lines.fetch(end_line, nil)
+            ignore_code?(ignore, code) and return true
+          end
+        end
+
+        ignored_ranges.any? do |range|
+          range.cover?(start_line) && range.cover?(end_line)
+        end
+      end
+
+      def ignore_code?(line, code)
+        case diags = line.ignored_diagnostics
+        when Symbol
+          true
+        else
+          diags.any? {|d| code == "Ruby::#{d}" }
+        end
+      end
+    end
+  end
+end

data/lib/steep/source.rb

@@ -5,15 +5,17 @@ module Steep
     attr_reader :node
     attr_reader :mapping
     attr_reader :comments
+    attr_reader :ignores
 
     extend NodeHelper
 
-    def initialize(buffer:, path:, node:, mapping:, comments:)
+    def initialize(buffer:, path:, node:, mapping:, comments:, ignores:)
       @buffer = buffer
       @path = path
       @node = node
       @mapping = mapping
       @comments = comments
+      @ignores = ignores
     end
 
     class Builder < ::Parser::Builders::Default
@@ -28,7 +30,7 @@ module Steep
     end
 
     def self.new_parser
-      ::Parser::Ruby32.new(Builder.new).tap do |parser|
+      ::Parser::Ruby33.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -88,7 +90,11 @@ module Steep
         map[node] << annot
       end
 
-      new(buffer: buffer, path: path, node: node, mapping: map, comments: comments)
+      ignores = comments.filter_map do |comment|
+        AST::Ignore.parse(comment, buffer)
+      end
+
+      new(buffer: buffer, path: path, node: node, mapping: map, comments: comments, ignores: ignores)
     end
 
     def self.construct_mapping(node:, annotations:, mapping:, line_range: nil)
@@ -432,7 +438,7 @@ module Steep
           mapping[node_] << annot
         end
 
-        Source.new(buffer: buffer, path: path, node: node_, mapping: mapping, comments: comments)
+        Source.new(buffer: buffer, path: path, node: node_, mapping: mapping, comments: comments, ignores: ignores)
       else
         self
       end

data/lib/steep/subtyping/check.rb

@@ -1,6 +1,8 @@
 module Steep
   module Subtyping
     class Check
+      ABORT_LIMIT = ENV.fetch("STEEP_SUBTYPING_ABORT_LIMIT", 50).to_i
+
       attr_reader :builder
       attr_reader :cache
 
@@ -187,6 +189,10 @@ module Steep
       end
 
       def check_type(relation)
+        if assumptions.size > ABORT_LIMIT
+          return Failure(relation, Result::Failure::LoopAbort.new)
+        end
+
         relation.type!
 
         Steep.logger.tagged "#{relation.sub_type} <: #{relation.super_type}" do

data/lib/steep/subtyping/result.rb

@@ -269,6 +269,12 @@ module Steep
           end
         end
 
+        class LoopAbort
+          def message
+            "Detected infinite loop with limit of `#{Check::ABORT_LIMIT}`; specify $STEEP_SUBTYPING_ABORT_LIMIT env var to override the limit."
+          end
+        end
+
         attr_reader :error
 
         def initialize(relation, error)

data/lib/steep/type_construction.rb

@@ -1966,113 +1966,7 @@ module Steep
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
 
             if cond
-              branch_results = [] #: Array[Pair]
-
-              cond_type, constr = constr.synthesize(cond)
-
-              var_name = :"_a[#{SecureRandom.alphanumeric(4)}]"
-              var_cond, value_node = transform_condition_node(cond, var_name)
-              constr = constr.update_type_env {|env| env.assign_local_variable(var_name, cond_type, nil) }
-
-              next_branch_reachable = true
-
-              when_constr = constr
-              whens.each do |clause|
-                # @type var tests: Array[Parser::AST::Node]
-                # @type var body: Parser::AST::Node?
-                *tests, body = clause.children
-
-                test_constr = when_constr
-                # @type var test_envs: Array[TypeInference::TypeEnv]
-                test_envs = []
-
-                branch_reachable = false
-                false_branch_reachable = false
-
-                tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, var_cond])
-                  test_type, test_constr = test_constr.synthesize(test_node, condition: true).to_ary
-                  truthy, falsy = interpreter.eval(node: test_node, env: test_constr.context.type_env)
-
-                  truthy_env = propagate_type_env(var_name, value_node, truthy.env)
-                  falsy_env = propagate_type_env(var_name, value_node, falsy.env)
-
-                  test_envs << truthy_env
-
-                  test_constr = test_constr.update_type_env { falsy_env }
-
-                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
-                  false_branch_reachable = !falsy.unreachable
-                end
-
-                next_branch_reachable &&= false_branch_reachable
-                body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
-
-                branch_result =
-                  if body
-                    body_constr
-                      .for_branch(body)
-                      .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
-                      .synthesize(body, hint: hint)
-                  else
-                    Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
-                  end
-
-                branch_results << branch_result
-
-                if !branch_reachable && !branch_result.type.is_a?(AST::Types::Bot)
-                  typing.add_error(
-                    Diagnostic::Ruby::UnreachableValueBranch.new(
-                      node: clause,
-                      type: branch_result.type,
-                      location: clause.location.keyword
-                    )
-                  )
-                end
-
-                when_constr = test_constr
-              end
-
-              if els
-                node.loc.else or raise
-
-                begin_pos = node.loc.else.end_pos
-                end_pos = node.loc.end.begin_pos
-                typing.add_context(begin_pos..end_pos, context: when_constr.context)
-
-                else_result = when_constr.synthesize(els, hint: hint)
-
-                if next_branch_reachable
-                  branch_results << else_result
-                end
-              end
-
-              types = branch_results.map(&:type)
-              constrs = branch_results.map(&:constr)
-
-              if !next_branch_reachable
-                # Exhaustive
-                _, _, _, loc = deconstruct_case_node!(node)
-
-                # `else` may present even if it's empty
-                if loc.else
-                  if els
-                    else_result or raise
-                    unless else_result.type.is_a?(AST::Types::Bot)
-                      typing.add_error Diagnostic::Ruby::UnreachableValueBranch.new(
-                        node: els,
-                        type: else_result.type,
-                        location: node.loc.else || raise
-                      )
-                    end
-                  end
-                end
-              else
-                unless els
-                  constrs << when_constr
-                  types << AST::Builtin.nil_type
-                end
-              end
+              types, envs = TypeInference::CaseWhen.type_check(constr, node, interpreter, hint: hint, condition: condition)
             else
               branch_results = [] #: Array[Pair]
 
@@ -2131,7 +2025,7 @@ module Steep
               end
 
               types = branch_results.map(&:type)
-              constrs = branch_results.map(&:constr)
+              envs = branch_results.map {|result| result.constr.context.type_env }
 
               unless els
                 types << AST::Builtin.nil_type
@@ -2139,7 +2033,6 @@ module Steep
             end
 
             constr = constr.update_type_env do |env|
-              envs = constrs.map {|c| c.context.type_env }
               env.join(*envs)
             end
 
@@ -2455,11 +2348,8 @@ module Steep
           end
 
         when :defined?
-          each_child_node(node) do |child|
-            synthesize(child)
-          end
-
-          add_typing(node, type: AST::Builtin.any_type)
+          type_any_rec(node, only_children: true)
+          add_typing(node, type: AST::Builtin.optional(AST::Builtin::String.instance_type))
 
         when :gvasgn
           yield_self do
@@ -3732,10 +3622,6 @@ module Steep
       end
     end
 
-    def inspect
-      "#<#{self.class}>"
-    end
-
     def with_child_typing(range:)
       constr = with_new_typing(typing.new_child(range))
 
@@ -4774,8 +4660,8 @@ module Steep
       !nodes.empty? && nodes.all? {|child| child.type == :class || child.type == :module}
     end
 
-    def type_any_rec(node)
-      add_typing node, type: AST::Builtin.any_type
+    def type_any_rec(node, only_children: false)
+      add_typing node, type: AST::Builtin.any_type unless only_children
 
       each_child_node(node) do |child|
         type_any_rec(child)
@@ -5162,22 +5048,6 @@ module Steep
       with_new_typing(typing.parent || raise)
     end
 
-    def transform_condition_node(node, var_name)
-      case node.type
-      when :lvasgn
-        name, rhs = node.children
-        rhs, value_node = transform_condition_node(rhs, var_name)
-        [node.updated(nil, [name, rhs]), value_node]
-      when :begin
-        *children, last = node.children
-        last, value_node = transform_condition_node(last, var_name)
-        [node.updated(nil, children.push(last)), value_node]
-      else
-        var_node = node.updated(:lvar, [var_name])
-        [var_node, node]
-      end
-    end
-
     def type_name(type)
       case type
       when AST::Types::Name::Instance, AST::Types::Name::Singleton
@@ -5228,20 +5098,5 @@ module Steep
         end
       end
     end
-
-    def propagate_type_env(source, dest, env)
-      source_type = env[source] or raise
-
-      if dest.type == :lvar
-        var_name = dest.children[0] #: Symbol
-        env.assign_local_variable(var_name, source_type, nil)
-      else
-        if env[dest]
-          env.replace_pure_call_type(dest, source_type)
-        else
-          env
-        end
-      end
-    end
   end
 end